对于Reactor模型的具体介绍以及3种模型的实现这里就不多介绍了，网上有大量参考的资料，这里只做简要讲述，重点是阐述Netty中对Reactor模型的实现

Reactor模型的核心思想是将关注的IO事件注册到多路复用器上，一旦有 I/O 事件触发，将事件分发到事件处理器中，执行就绪 I/O 事件对应的处理函数中。模型中有三个重要的组件：

• 多路复用器：由操作系统提供接口，Linux 提供的 I/O 复用接口有select、poll、epoll 。
• 事件分离器：将多路复用器返回的就绪事件分发到事件处理器中。
• 事件处理器：处理就绪事件处理函数。

我很反感现在微博的一些没有自己思考的声音。NBA事件现在沸沸扬扬，我也无数次在心里骂着莫雷，不管他是出于自己的言论自由口嗨还是政治目的，他都不应该让肖华和整个NBA替他的行为背锅。但我同时也很反感国内的过激反应，我理解大家的爱国心情，我们的国家也确实值得我们自豪。但不知道什么时候开始，一旦某个事件一旦涉及到了ruhua，全民的情绪都会被调动起来，会翻老本的查找你任何不妥的举动，甚至全民进行道德绑架。

《算法设计与分析》课程学习总结

0x00 插入排序

pass

0x01 希尔排序

原理：将待排序的数组元素按照下标进行一定的增量分组，分成多个子序列，对这些子序列进行插入排序，然后依次缩减增量再进行排序，直到增量为1，排序结束

Java的动态代理其实用到了代理模式的手段。所谓代理模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象。

参考链接

• Java中的代理模式

参考链接：

• Java 动态代理-掘金
• 仿照Spring实现简单的IOC和AOP

• Java 设计模式：代理模式

• 源码可以参考github地址

Java 实现动态代理主要涉及以下几个类：

• java.lang.reflect.Proxy: 这是生成代理类的主类，通过 Proxy 类生成的代理类都继承了 Proxy 类，即 DynamicProxyClass extends Proxy。
• java.lang.reflect.InvocationHandler: 这里称他为”调用处理器”，他是一个接口，我们动态生成的代理类需要完成的具体内容需要自己定义一个类，而这个类必须实现 InvocationHandler 接口。

######参考Blog：
adaBoost算法

######参考书籍：
《机器学习实战》

• 参考书籍：

  Adaboost是一种迭代算法，其核心思想是针对同一个训练集训练不同的分类器（弱分类器），然后把这些弱分类器集合起来，构成一个更强的最终分类器（强分类器）。Adaboost算法本身是通过改变数据分布来实现的，它根据每次训练集之中每个样本的分类是否正确，以及上次的总体分类的准确率，来确定每个样本的权值。将修改过权值的新数据集送给下层分类器进行训练，最后将每次得到的分类器最后融合起来，作为最后的决策分类器。

算法概述

AdaBoost为每个分类器分配了一个权重值alpha，这些alpha值是基于每个弱分类器的错误率进行计算的

• 1. 先通过对N个训练样本的学习得到第一个弱分类器(权重相等)

• 2.在第二次训练中，第一次分对的样本的权重降低，分错的样本权重提高（突出错误样本）

• 3.最终经过提升的强分类器，即某个数据被分为哪一类主要由各匪类器权值决定

对比Bagging（基于数据随机重抽样的分类器构建方法）

• 使用加权后选取的训练数据代替随机选取的训练样本，训练的重点被放在被已有分类器错分的那些数据，从而获得新的分类器
• 联合所有弱分类器，使用加权的投票机制代替平均投票机制。分类效果好的弱分类器具有较大的权重，分类效果差的分类器具有较小的权重。

算法训练过程

adaBoost 算法流程

1.被错误分类的样本权重(alpha)会升高（见下面?alpha定义）

1. 分类效果差的分类器的权重会降低

• 错误率的定义为：
  

• alpha计算公式：
  

• 样本权重公式:

由公式可以看到，权值是关于误差的表达式。每次迭代都会提高错分点的权值，当下一次分类器再次错分这些点之后，会提高整体的错误率，这样就导致分类器权值变小，进而导致这个分类器在最终的混合分类器中的权值变小，也就是说，Adaboost算法让正确率高的分类器占整体的权值更高，让正确率低的分类器权值更低，从而提高最终分类器的正确率。

实例讲解

[站外图片上传中…(image-17246c-1515809860998)]
图中“+”和“-”表示两种类别。我们用水平或者垂直的直线作为分类器进行分类。
算法开始前默认均匀分布D，共10个样本，故每个样本权值为0.1.
第一次分类：
[站外图片上传中…(image-72228f-1515809860998)]
第一次划分有3个点划分错误，根据误差表达式计算可得
e1 = (0.1+0.1+0.1)/1.0 = 0.3

分类器权重为：

第二次分类：

分类误差为e2 = 0.2144
分类器权重：a2 = 0.6493
错分的3个点权值为：d2 = 0.1*（1-0.2144)/0.2144 = 0.3664

第三次分类：

e3= 0.1365 a3 = 0.9223 d3 = 0.6326

最终的强分类器即为三个弱分类器的叠加：

adaboost Python代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

# -*- coding: utf-8 -*-
'''
将所有的弱分类器的结果加权求和就可以得到最后的结果 :P

'''

from numpy import *

# demo数据集
def loadSimpData():
    datMat = matrix([[ 1. ,  2.1],
        [ 2. ,  1.1],
        [ 1.3,  1. ],
        [ 1. ,  1. ],
        [ 2. ,  1. ]])
    classLabels = [1.0, 1.0, -1.0, -1.0, 1.0]
    return datMat,classLabels

def stumpClassify(dataMatrix,dimen,threshVal,threshIneg):
    retArray = ones((shape(dataMatrix)[0],1))
    if threshIneg == 'lt':
        #数据过滤
        retArray[dataMatrix[:,dimen] <= threshVal] = -1.0
    else:
        retArray[dataMatrix[:,dimen] > threshVal] = -1.0
    return retArray

def buildStump(dataArr,classLabels,D):
    dataMatrix = mat(dataArr)
    labelMat = mat(classLabels).T
    m,n = shape(dataMatrix)
    numSteps = 10.0 ; bestStump = {};bestClasEst = mat(zeros((m,1)))
    minError = inf
    for i in range(n):
        rangeMin = dataMatrix[:,i].min(); rangeMax = dataMatrix[:,i].max()
        stepSize = (rangeMax-rangeMin)/ numSteps
        for j in range(-1,int(numSteps)+1): ## 阀值可以设置在取值范围之外
            for inequal in ['lt','gt']:
                threshVal = (rangeMin + float(j)*stepSize)
                predictedVals = stumpClassify(dataMatrix,i,threshVal,inequal)
                errArr = mat(ones((m,1)))
                errArr[predictedVals == labelMat] = 0
                weightdError = D.T * errArr
                # print "split : dim %d ,thresh %.2f , thresh inequal: %s, the weighted error is %.3f" % \
                #     (i,threshVal,inequal,weightdError)

                if weightdError < minError:
                    minError = weightdError
                    bestClasEst = predictedVals.copy()
                    bestStump['dim'] = i
                    bestStump['thresh'] = threshVal
                    bestStump['ineq'] = inequal

    return bestStump,minError,bestClasEst


def adaBoostTrainDS(dataArr,classLabels,numIt=40): # 单层决策树(decision stump)
    weakClassArr = []
    m = shape(dataArr)[0] # 数组第一维的个数
    D = mat(ones((m,1))/m) # 一开始的权重是相等的
    aggClassEst = mat(zeros((m,1)))
    for i in range(numIt):
        bestStump,error,classEst = buildStump(dataArr,classLabels,D)
        print "current D:",D.T
        # 算法为分配器分配的权重值
        alpha = float(0.5*log((1.0-error)/max(error,1e-16)))  # 确保不会发生除0
        bestStump['alpha'] = alpha
        weakClassArr.append(bestStump)
        print "classEst: ",classEst.T

        expon = multiply(-1*alpha*mat(classLabels).T,classEst)
        D= multiply(D,exp(expon))
        D = D/D.sum()
        aggClassEst += alpha*classEst #将错误率累加计算,可以更好的估计出这个值是对的还是错误的
        print "aggClassEst: ",aggClassEst.T

        aggErrors = multiply(sign(aggClassEst) != mat(classLabels).T,ones((m,1))) # numpy.sign() 大于0的返回1,小于0的返回-1 ,等于0的返回0
        errorRate = aggErrors.sum()/m
        print "total error: ",errorRate,"\n"
        if errorRate == 0.0:break
    return weakClassArr


def addClassify(datToClass,classifierArr):
    dataMatrix = mat(datToClass)
    m = shape(dataMatrix)[0]
    aggClassEst = mat(zeros((m,1)))
    for i in range(len(classifierArr)):
        classEst = stumpClassify(dataMatrix,classifierArr[i]['dim'],classifierArr[i]['thresh'],classifierArr[i]['ineq'])
        aggClassEst += classifierArr[i]['alpha']*classEst #将多个弱分类器的错误率累加计算,可以更好的估计出这个值是否是错误的
        print aggClassEst
    return sign(aggClassEst)

if __name__ == '__main__':
    dataMat,classLabels = loadSimpData()
    adaBoostTrainDS(dataMat,classLabels,9)

#####算法优点：

• 1)Adaboost是一种有很高精度的分类器
• 2)可以使用各种方法构建子分类器,Adaboost算法提供的是框架
• 3）不用做特征筛选
• 4）不用担心overfitting的问题

#####算法缺点：

• 1）容易受到噪声干扰（大部分算法存在这样的缺点）
• 2）训练时间较长
• 3）依赖弱分类器的选择

参考：http://blog.csdn.net/xlinsist/article/details/51212348

引言

在运用一些机器学习算法的时候不可避免地要对数据进行特征缩放（feature scaling），比如：在随机梯度下降（stochastic gradient descent）算法中，特征缩放有时能提高算法的收敛速度。下面我会主要介绍一些特征缩放的方法。

什么是特征缩放

特征缩放是用来标准化数据特征的范围。

机器算法为什么要特征缩放

特征缩放还可以使机器学习算法工作的更好。比如在K近邻算法中，分类器主要是计算两点之间的欧几里得距离，如果一个特征比其它的特征有更大的范围值，那么距离将会被这个特征值所主导。因此每个特征应该被归一化，比如将取值范围处理为0到1之间。

就如我在引言所说，特征缩放也可以加快梯度收敛的速度。

特征缩放的一些方法

调节比例（Rescaling）

这种方法是将数据的特征缩放到[0,1]或[-1,1]之间。缩放到什么范围取决于数据的性质。对于这种方法的公式如下：

标准化(Standardization)

特征标准化使每个特征的值有零均值(zero-mean)和单位方差(unit-variance)。这个方法在机器学习地算法中被广泛地使用。例如：SVM，逻辑回归和神经网络。这个方法的公式如下：

• 其中delta为x的标准差

平方误差代价函数

我们的目标就是让J()尽可能的小

梯度下降

• := 是赋值的意思
• $\alpha$ 是指learning rate(学习速度)

对theta求导（斜率），theta在左半边的时候，斜率为负，所以theta会向右更新，同理在又边的时候会向左更新。可以得出当斜率为0的时候，theta不再更新。

我们可以用梯度下降对多个参数（theta）进行求导，当多个参数均开始收敛（即前后两次迭代的值不再发生变化了。一般情况下，会设置一个具体的参数，当前后两次迭代差值小于该参数时候结束迭代）的时候，这即为一个比较合适的值。

最小二乘法

• 知识回顾：矩阵的迹
  http://blog.csdn.net/mathmetics/article/deta ils/17504179

将训练特征表示为X矩阵，结果表示成y向量，仍然是线性回归模型，误差函数不变。那么θ可以直接由下面公式得出

1	此方法要求X是列满秩的，而且求矩阵的逆比较慢。

最小二乘法讲解：
https://www.cnblogs.com/iamccme/archive/2013/05/15/3080737.html

最大似然估计
http://www.cnblogs.com/liliu/archive/2010/11/22/1883702.html

带权重的线性回归

1

上面提到的线性回归的误差函数里系统都是1，没有权重。带权重的线性回归加入了权重信息。

• 基本假设是
  

• 其中假设w(i)符合公式：
  

其中x是要预测的特征，这样假设的道理是离x越近的样本权重越大，越远的影响越小。这个公式与高斯分布类似，但不一样,因为W(i)不是随机变量。
此方法成为非参数学习算法，因为误差函数随着预测值的不同而不同，这样θ无法事先确定，预测一次需要临时计算，感觉类似KNN。

分类和对数回归

一般来说，回归不用在分类问题上，因为回归是连续型模型，而且受噪声影响比较大。如果非要应用进入，可以使用对数回归。

对数回归本质上是线性回归，只是在特征到结果的映射中加入了一层函数映射，即先把特征线性求和，然后使用函数g(z)将最为假设函数来预测。g(z)可以将连续值映射到0和1上。

对数回归的假设函数如下，线性回归假设函数只是θ^T x

######sigmod函数/Logistic函数

对数回归用来分类0/1问题，也就是预测结果属于0或者1的二值分类问题。这里假设了二值满足伯努利分布，也就是

当然假设它满足泊松分布、指数分布等等也可以，只是比较复杂，后面会提到线性回归的一般形式。
与第7节一样，仍然求的是最大似然估计，然后求导，得到迭代公式结果为

这个结果看上去与线性回归类似，只是θ^T x(i)换成了hθ (x（i))，但其实h就是θ^T x(i)经过g(z)映射过来的，而这也是它与最小二乘回归的最大区别

岭回归

• 参考资料：
  http://blog.csdn.net/computerme/article/details/50486937

简单来说，岭回归是在矩阵X^tX上加入一个∂ I 从而使矩阵奇异，进而能对X^tX+ ∂ I 求逆。其中矩阵I是一个m*m的单位矩阵，对角线元素为1，其余元素为0，而∂是一个用户定义的数值。在这种情况下，回归系数的计算公式变成：

岭回归最先用于处理特征数多于样本数的情况，现在也用于在估计中加入偏差，从而得到更好的估计，这里通过引入∂来限制了所有w之和，通过引入惩罚项，能够减少不重要的参数，这个技术在统计学中也叫做缩减。

PS：本文建立在使用Mac或者linux系统的基础上，也不建议使用window系统进行spark配置=_=

安装JAVA环境

这部没啥好说的吧，上网搜java安装一大把。
切记配置java全局变量

1

vim ~/.bash_profile

然后输入

1

export JAVA_HOME=$(/usr/libexec/java_home)

安装scala

这里推荐Mac党首选工具brew
可以省去你配置全局变量以及管理包这一影响效率的过程

• 安装scala的命令

  1	brew install scala

安装完成后用

1

$ scala -version

查看是否安装成功

安装Spark

这里有一个坑一定要注意，
不要用brew去安装spark！！！
不要用brew去安装spark！！！
不要用brew去安装spark！！！

因为brew安装完的所有的包地址都在

1

$ /usr/local/Cellar/

里面，这意味着你在pycharm执行命令会有权限问题的产生

所以我们采用去官网下载包的方式: P

1

http://spark.apache.org/downloads.html

下载完成后解压

1

tar -zxvf spark-2.0.1-bin-hadoop2.7.tgz

配置spark路径

1

vim ~/.bash_profile

配置如下参数（自己本机spark路径，*填自己的真实路径）

1
2

export  SPARK_HOME = /Users/***/spark/spark-2.0.1-bin-hadoop2.7
export PATH= $PATH:$SPARK_HOME/bin

如果一切没有配置过SSH，在主目录输入如下命令：

1

ssh-keygen –t rsa –P

一直按回车直到结束，接着输入命令，追加私钥：

1

cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys

启动Spark

进入Spark目录运行pyspark启动脚本：

1

$ pyspark

在pycharm中配置spark

首先打开pyCharm 的Perferences > Project Structure

• 选择右边?的Add Content Root
• 找到spark的目录
• 导入py4j和pyspark的包
  包的具体位置为：

  1	spark > python >lib

配置完成后：

接着我们打开工程右上角的Edit Condigurations

找到Environment Variables配置：

接着配置PYTHONPATH和SPARK_HOME

PYTHONPATH为spark目录下python包的位置
在我的电脑中，PYTHONPATH为

1

/Users/xulei2/Documents/tmpFile/DataMining/spark-2.2.0-bin-hadoop2.7/python

SPARK_HOME为：

1

/Users/xulei2/Documents/tmpFile/DataMining/spark-2.2.0-bin-hadoop2.7

点击确认，配置成功：）

测试是否能够正常运行

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import sys

try:
    from pyspark import SparkContext
    from pyspark import SparkConf

    print ("Successfully imported Spark Modules")
except ImportError as e:
    print ("Can not import Spark Modules", e)
    sys.exit(1)

sc = SparkContext("local","apple")
words = sc.parallelize(["scala", "java", "hadoop", "spark", "akka"])
print(words.count())

输入下面结果即为正常

####brew安装的种种坑
这里就不提了，别用brew安装spark就成，我是配置了一个下午无果，始终显示

1

Java gateway process exited before sending the driver its port number

如果有老司机能够给予解答，万分感谢，毕竟brew配置spark比起自己手动配置方便了不是一点两点- -

如果其他童鞋配置spark有问题，欢迎给我留言共同交流：）

0x00 贝叶斯定理

条件概率$ P(A|B) = \frac{P(AB)}{ P(B)}$ 表示的是事件B已经发生的情况下事件A发生的概率，进而可以推出

贝叶斯定理$ P(B|A) = \frac{P(A|B)P(B)}{P(A)} $

先验概率 $P(B)$

0x01 朴素贝叶斯分类

朴素贝叶斯思想基础：对于给出的待分类项，求解在此项出现的条件下各个类别出现的概率，哪个最大，就认为此待分类项属于哪个类别。

正式定义：

所以由上述步骤理论，在各个特征属性独立的前提下，根据贝叶斯定理可以得到
$$
P(y_i|x) = \frac{P(x|y_i)P(y_i)}{P(x)}
$$
因为分母为一个常数，所以只需要$P(x|y_i)P(y_i) $最大化即可，同时因为各个属性是条件独立，所以有：
$$
P(x|y_i)P(y_i) = P(a_1|y_i)P(y_i)…P(a_m|y_i)P(y_i) = P(yi)\prod{j=1}^nP(a_j|y_i)
$$