Models
Unsupervised-clustering
1.k-means
算法过程
- 选择簇个数k
- 计算各样本到簇中心距离
- 根据划分结果更新簇中心
- 重复2，3
- 满足停止条件结束（中心点不变，达到最大迭代次数）
要点
- 时间复杂度O(n): 假设I次迭代，n个数据，每个数据m个feature，则为O(I m n), I和n为常数，化简为O(n)。
- k自由选择，在每个k值重复运行避免local opt，一般k选择较小，可通过枚举探究。
- 注意数据规格化。
- 距离选择：Minkowski distance, Euclidean distance, Manhattan distance.
模型评估
- 凝聚度：对某个元素，计算其与簇内其他元素距离平均值，记为ai。
- 分离度：对某个元素，计算其与另一簇所有点平均距离，遍历所有簇，找到最小平均距离,记为bi。
- 轮廓系数：对某个元素， s i = b i − a i m a x ( a i , b i ) s_{i} = \frac{b_{i}-a_{i}}{max(a_{i},b_{i})} si=max(ai,bi)bi−ai。计算所有元素轮廓系数，平均值为该聚类整体轮廓系数。
- 评估： s i s_{i} si小于0，聚类效果差；si接近1，效果好。
代码
sklearn 实现
import numpy as py
from sklearn.cluster import KMeans
def loadData(filePath):
fr = open(filePath,'r+')
lines = fr.readlines()
retData = []
retFlowerName = []
for line in lines:
items = line.strip().split(",")
print(items)
retFlowerName.append(items[4])
retData.append([float(items[i]) for i in range(0,len(items)-1)])
return retData,retFlowerName
if __name__ == '__main__':
data,FlowerName = loadData("iris.data")
km = KMeans(n_clusters=3)
label = km.fit_predict(data)
result = []
for i in range(len(label)):
if label[i] == 0:
result.append(1)
elif label[i] == 1:
result.append(2)
else:
result.append(3)
print(result)
parameters:
n_clusters
max_iter
n_init:用不同质心初始化运算次数
Python笔记
1.__name__
__name__ 是python的内置属性，是系统全局变量！每一个py文件都有一个属于自己的__name__：
如果py文件作为模块被导入(import)，那么__name__就是该py文件的文件名(也称 模块名)；如果py文件直接运行时(Ctrl+Shift+F10)，那么__name__默认等于字符串”__main__”;
2.__name__ == “__main__” 作为启动py文件的main函数入口
3.一个项目中必然会包含多个模块文件，每个模块文件在自己写完代码之后会做一些简单的测试用于检测bug 或者 对自己的函数调用写一个简单的示例，而恰到好处的是：__name__ == “__main__” 既不会影响你的测试代码，也不会影响别人调用你的接口函数。
缺点
- 实际情况下对于k的选择没有合适的依据。
- 会受到离群点的影响，因为kmeans会给所有的点分类。
- 主要适用于球星分布数据，凹图形效果不好。
2.DBSCAN
定义
- Eps：同一簇中样本最大距离（参数）
- MinPts：同一簇中最少样本点数
- 核心点：Eps内样本点超过Minpts的点
- 边界点：Eps内样本点小于MinPts，但在核心领域内
- 噪音点：Neither
算法流程
- 按照核心点，边界点，噪音点label所有的点
- 删除噪音点
- 为Eps内的核心点连一条边
- 每组连通的核心点形成簇
- 把边界点归入簇中
代码
import numpy as np
from sklearn.cluster import DBSCAN
def load_data(data_file):
fr = open(data_file,"r+")
lines = fr.readlines()
data = []
for line in lines:
items = line.strip().split(",")
data.append([float(items[i]) for i in range(len(items)-1)])
return data
if __name__ == '__main__':
data = load_data("iris.data")
dbs = DBSCAN(eps=0.62,min_samples=3).fit(data)
labels = dbs.labels_
print("Labels:")
print(labels)
parameters：
metric：距离方式
algorithm：最近搜索算法
eps：样本中最大距离
min_samples：MinPts
对比Kmeans
pros
- 不需要指定k。
- 可以适用于不同数据集。
- 可以识别出离群点。
cons
- 速度比kmeans慢。
- eps与min_samples设定较难：eps小，可能没有核心点，所有点都是噪声点；eps大，所有点都归为一个簇。min_samples太大，核心点更少，噪声更多。
Unsupervised-降维
PCA（Principle Component Analysis）
原理
Matrix的主成分就是其协方差Matrix对应的特征向量
推导
PCA推导过程
算法过程
- 对样本进行去中心化
- 计算样本协方差矩阵
- 对协方差矩阵做特征值分解
- 取最大的d特征作为特征向量
代码
import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.datasets import load_iris
data = load_iris()
y = data.target
x = data.data
pca = PCA(n_components=2)
reduced_X = pca.fit_transform(x)
red_x,red_y = [],[]
blue_x,blue_y = [],[]
green_x,green_y = [],[]
for i in range(len(reduced_X)):
if y[i] == 0:
red_x.append(reduced_X[i][0])
red_y.append(reduced_X[i][1])
elif y[i] == 1:
blue_x.append(reduced_X[i][0])
blue_y.append(reduced_X[i][1])
else:
green_x.append(reduced_X[i][0])
green_y.append(reduced_X[i][1])
plt.scatter(red_x,red_y,c='r',marker='x')
plt.scatter(blue_x,blue_y,c='b',marker='D')
plt.scatter(green_x,green_y,c='g',marker='.')
plt.savefig('iris_flower.jpg')
n_components
svd_solver：奇异值分解方法
贡献率与k
在我的文章特征值和特征向量中说过，特征值反映了矩阵对于特征向量的拉伸程度，只有拉伸而没有旋转，也就是在特征向量方向上的作用程度，所以在PCA中我们选取前K个特征向量组成新基进行投影，就是因为原特征在前K个特征向量有最大的作用程度，投影过后可以保留更多的信息，作用程度是用特征值表示的，所以我们可以使用下面的式子表示贡献率，贡献率是表示投影后信息的保留程度的变量，可以用下面的式子表示：
∑ i = 0 K λ i ∑ i = 0 m λ i \frac{\sum_{i=0}^{K}\lambda _{i}}{\sum_{i=0}^{m}\lambda _{i}} ∑i=0mλi∑i=0Kλi
也就是特征值的总和比上前K个特征值，一般来说贡献率要大于85%。
kernel PCA
PCA利用协方差矩阵判断变量间的方差一致性，寻找出变量之间的最佳的线性组合，来代替特征，从而达到降维的目的。从高维到低维的映射是线性的，所以对于非线形相关特征区分效果不好。
首先计算n个样本间的距离矩阵D（n*n），利用核函数F，F(D)为高维空间投射。
NMF(Non-negative matrix factorization)
原理
任意给定一个非负矩阵V，其能够寻找到一个非负矩阵W和一个非负矩阵H，满足条件V=WH,从而将一个非负的矩阵分解为左右两个非负矩阵的乘积。其中W为基础图像矩阵（字典矩阵），H为拓展矩阵。个人理解有点像是分解成了元素权值的感觉。
损失函数
- 欧式距离
arg min 1 2 ∥ A − W H ∥ 2 \arg \min \frac{1}{2}\left \| A-WH\right \|^{2} argmin21∥A−WH∥2 - KL散度
d K L ( X , Y ) = ∑ i , j ( X i j l o g ( X i j W H i j ) − X i j + W H i j ) ) d_{KL}(X,Y) = \sum_{i,j}(X_{ij}log(\frac{X_{ij}}{WH_{ij}})-X_{ij}+WH_{ij})) dKL(X,Y)=∑i,j(Xijlog(WHijXij)−Xij+WHij))
代码
from numpy.random import RandomState
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_olivetti_faces
from sklearn import decomposition
n_row, n_col = 2, 3
n_components = n_row * n_col
image_shape = (64,64)
###############################################################################
# Load faces data
dataset = fetch_olivetti_faces(shuffle=True, random_state=RandomState(0))
faces = dataset.data
print(faces)
###############################################################################
def plot_gallery(title, images, n_col=n_col, n_row=n_row):
plt.figure(figsize=(2. * n_col, 2.26 * n_row))
plt.suptitle(title, size=16)
for i, comp in enumerate(images):
plt.subplot(n_row, n_col, i + 1)
vmax = max(comp.max(), -comp.min())
plt.imshow(comp.reshape(image_shape), cmap=plt.cm.gray,
interpolation='nearest', vmin=-vmax, vmax=vmax)
plt.xticks(())
plt.yticks(())
plt.subplots_adjust(0.01, 0.05, 0.99, 0.94, 0.04, 0.)
plot_gallery("First centered Olivetti faces", faces[:n_components])
###############################################################################
estimators = [
('Eigenfaces - PCA using randomized SVD',
decomposition.PCA(n_components=6,whiten=True)),
('Non-negative components - NMF',
decomposition.NMF(n_components=6, init='nndsvda', tol=5e-3))
]
###############################################################################
for name, estimator in estimators:
print("Extracting the top %d %s..." % (n_components, name))
print(faces.shape)
estimator.fit(faces)
components_ = estimator.components_
print(components_[0].shape)
plot_gallery(name, components_[:n_components])
plt.show()
一些疑惑：
对于库中fetch_olivetti_faces数据集中导出的数据比较疑惑，应该是已经进行了一些处理。因为自己在利用其他数据进行尝试时，output出的feature不像fetch_olivetti_faces提取出的feature那样可视化效果好，基本看不出原本图像的印象了。
Supervised-classification
Logistic Regression
启发
为了能实现分类目的，更倾向于让output介于0-1之间，可以利用sigmoid函数的值域为(0,1)性质实现。
h
θ
(
x
)
=
g
(
θ
T
x
)
=
1
1
+
e
−
θ
T
x
h_{\theta }\left ( x \right )=g\left ( \theta^{T} x \right )=\frac{1}{1+e^{-\theta ^{T}x}}
hθ(x)=g(θTx)=1+e−θTx1
相当于对LR的结果做了一个sigmoid的转换。
预测思路
根据
h
θ
(
x
)
h_{\theta }\left ( x \right )
hθ(x)的值域范围，可以把
h
θ
(
x
)
h_{\theta }\left ( x \right )
hθ(x)视为在x的输入条件下，y输出为1的概率。即
h
θ
(
x
)
=
P
(
y
=
1
∣
x
;
θ
)
h_{\theta }\left ( x \right )=P\left ( y=1|x;\theta \right )
hθ(x)=P(y=1∣x;θ)。当概率P
≥
\geq
≥ 0.5时，预测为1.
根据sigmoid函数图像，P
≥
\geq
≥ 0.5时，
θ
T
x
≥
\theta^{T} x\geq
θTx≥ 0。即为decision boudary，图像上为分界线。
损失函数
在利用sigmoid函数的情况下，运用MSE会构造出一个nonconvex的代价函数，不利于优化。
所以设计出新的优化函数：
c
o
s
t
(
h
θ
(
x
)
,
y
)
=
{
−
l
o
g
(
h
θ
(
x
)
)
if
y
=
1
−
l
o
g
(
1
−
h
θ
(
x
)
)
if
y
=
0
cost(h_{\theta }(x),y)=\begin{cases} & -log(h_{\theta }(x))\text{ if } y=1 \\ & -log(1-h_{\theta }(x))\text{ if } y=0 \end{cases}
cost(hθ(x),y)={−log(hθ(x)) if y=1−log(1−hθ(x)) if y=0
即
c
o
s
t
(
h
θ
(
x
)
,
y
)
=
−
y
l
o
g
(
h
θ
(
x
)
)
−
(
1
−
y
)
l
o
g
(
1
−
h
θ
(
x
)
)
cost(h_{\theta }(x),y)= -ylog(h_{\theta }(x)) -(1-y)log(1-h_{\theta }(x))
cost(hθ(x),y)=−ylog(hθ(x))−(1−y)log(1−hθ(x))
优化函数
梯度下降
其他优化函数：
conjugate gradient
BFGS
L-BFGS
Advantages：不需要人工选取学习率；通常更快
Disadvantages：更复杂
多分类问题
利用one-vs-all策略
过拟合问题
high bias —— underfit
high variance —— overfit
解决方案：
- 减少feature数量：人工筛选feaures；利用模型进行模型筛选
- 减少feature的magnitude：正则化
正则化项
-
L2 Norm
J ( θ ) = 1 2 m [ ∑ i = 1 m ( h θ ( x i ) − y i ) 2 + λ ∑ j = 1 n θ j 2 ] J\left ( \theta \right )=\frac{1}{2m}\left [ \sum_{i=1}^{m} (h_{\theta }(x^{i})-y^{i})^{2}+\lambda \sum_{j=1}^{n}\theta _{j}^{2}\right ] J(θ)=2m1[∑i=1m(hθ(xi)−yi)2+λ∑j=1nθj2] -
L1 Norm
J ( θ ) = 1 2 m [ ∑ i = 1 m ( h θ ( x i ) − y i ) 2 + λ ∑ j = 1 n ｜ θ j ｜ ] J\left ( \theta \right )=\frac{1}{2m}\left [ \sum_{i=1}^{m} (h_{\theta }(x^{i})-y^{i})^{2}+\lambda \sum_{j=1}^{n}｜\theta _{j}｜\right ] J(θ)=2m1[∑i=1m(hθ(xi)−yi)2+λ∑j=1n｜θj｜]
不对偏置项做正则化，因为在对输出结果的贡献中，参数b对于输入的改变是不敏感的，不管输入改变是大还是小，参数b的贡献就只是加个偏置而已。相当于如果是曲线曲率太大了，也与b无关。
Naive Bayes
算法思路
根据条件概率公式：
P
(
A
∣
B
)
=
P
(
A
B
)
P
(
B
)
P(A|B)=\frac{P(AB)}{P(B)}
P(A∣B)=P(B)P(AB)和全概率公式可以推出贝叶斯公式：
P
(
B
i
∣
A
)
=
P
(
B
i
)
P
(
A
∣
B
i
)
∑
j
=
1
n
P
(
B
j
)
P
(
A
∣
B
j
)
)
P(B_{i}|A)=\frac{P(B_{i})P(A|B_{i})}{\sum_{j=1}^{n}P(B_{j})P(A|B_{j}))}
P(Bi∣A)=∑j=1nP(Bj)P(A∣Bj))P(Bi)P(A∣Bi)。
给定dataset(X,Y)，样本特征 X = ( x 1 , x 2 , x 3 . . . x n ) X = (x_{1},x_{2},x_{3}...x_{n}) X=(x1,x2,x3...xn),类别标记 Y = ( y 1 , y 2 , y 3 . . . y n ) Y = (y_{1},y_{2},y_{3}...y_{n}) Y=(y1,y2,y3...yn)。给定新样本X，判断类别。即给定X，求出 P ( y 1 ∣ x ) , P ( y 2 ∣ x ) . . . P ( y n ∣ x ) P(y_{1}|x),P(y_{2}|x)...P(y_{n}|x) P(y1∣x),P(y2∣x)...P(yn∣x)中概率最大的那个，也就是求出后验概率最大的输出。
根据贝叶斯公式，可得 P ( y k ∣ x ) = P ( y k ) P ( x ∣ y k ) ∑ k P ( y k ) P ( x ∣ y k ) ) P(y_{k}|x)=\frac{P(y_{k})P(x|y_{k})}{\sum_{k}P(y_{k})P(x|y_{k}))} P(yk∣x)=∑kP(yk)P(x∣yk))P(yk)P(x∣yk),其中 P ( y k ) P(y_{k}) P(yk)为先验概率。
而 P ( x ∣ y k ) = P ( x 1 x 2 . . . x n ∣ y k ) P(x|y_{k})=P(x_{1}x_{2}...x_{n}|y_{k}) P(x∣yk)=P(x1x2...xn∣yk)，设第 i i i维特征 x i x_{i} xi取值有S_{i}个，则参数有 k ∏ i = 1 n S i k \prod_{i=1}^{n}S_{i} k∏i=1nSi个。假设特征相互独立，则 P ( x ∣ y k ) = ∏ i = 1 n P ( x i ∣ y k ) P(x|y_{k})=\prod_{i=1}^{n}P(x_{i}|y_{k}) P(x∣yk)=∏i=1nP(xi∣yk)。
则上述内容都可以通过给出的样本计算得出，便可以得到要求的内容。
算法过程
- x = { a 1 , a 2 , . . . , a m } x=\{a_{1},a_{2},...,a_{m}\} x={a1,a2,...,am}为待分项，每个a为x的一个特性属性。
- 类别集合 C = { y 1 , y 2 , . . . , y n } C=\{y_{1},y_{2},...,y_{n}\} C={y1,y2,...,yn}
- 计算 P ( y 1 ∣ x ) , P ( y 2 ∣ x ) . . . P ( y n ∣ x ) P(y_{1}|x),P(y_{2}|x)...P(y_{n}|x) P(y1∣x),P(y2∣x)...P(yn∣x)
- 若 P ( x ∣ y k ) = m a x { P ( y 1 ∣ x ) , P ( y 2 ∣ x ) . . . P ( y n ∣ x ) } P(x|y_{k})=max\{P(y_{1}|x),P(y_{2}|x)...P(y_{n}|x)\} P(x∣yk)=max{P(y1∣x),P(y2∣x)...P(yn∣x)}
- 输出预测结果 y k y_{k} yk
要点
- 该算法对于小规模效果较好。
- 若有的类别太稀有，可以进行拉普拉斯平滑（ α = 1 \alpha=1 α=1）,Lidstone平滑( 0 < α < 1 0<\alpha<1 0<α<1)。
生成模型：由数据学习得到概率分布，求P(Y|X)。例如朴素贝叶斯、马尔可夫、高斯混合、LDA等
判别模型：由数据学得决策函数或条件概率分布。例如k近邻、SVM、决策树、感知机等
高斯模型
如果特征为连续值，利用朴素贝叶斯会导致
P
(
x
i
∣
y
i
)
=
0
P(x_{i}|y_{i})=0
P(xi∣yi)=0的情况过多。此时可以利用高斯贝叶斯模型。
e
.
g
.
e.g.
e.g.例如通过height, weight,shoesize来预测gender。假设三个特征均为正态分布，根据样本计算平均值和方差。
则可以得到
P
(
x
i
∣
y
i
)
=
1
2
π
σ
2
e
−
(
x
−
μ
)
2
2
σ
2
P(x_{i}|y_{i})=\frac{1}{\sqrt{2\pi \sigma ^{2}}}e^{-\frac{(x-\mu)^{2}}{2\sigma^{2}}}
P(xi∣yi)=2πσ21e−2σ2(x−μ)2，之后的流程与朴素贝叶斯类似。
KNN、Decision Tree、Logistic Regression
代码
import pandas as pd
import numpy as np
from sklearn.metrics import classification_report
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn import model_selection
def iris_type(s):
class_label={b'Iris-setosa':0,b'Iris-versicolor':1,b'Iris-virginica':2}
return class_label[s]
filepath = 'iris.data'
data = np.loadtxt(filepath,dtype=float,delimiter=',',converters={4:iris_type})
X,y = np.split(data,(4,),axis=1)
x_train,x_test,y_train,y_test=model_selection.train_test_split(X,y,random_state=1,test_size=0.3)
print('Start training knn')
knn = KNeighborsClassifier().fit(x_train,y_train)
print('Training Done')
answer_knn = knn.predict(x_test)
print('Prediction done')
print('Start training DT')
dt = DecisionTreeClassifier().fit(x_train, y_train)
print('Training done')
answer_dt = dt.predict(x_test)
print('Prediction done')
print('Start training Bayes')
gnb = GaussianNB().fit(x_train, y_train)
print('Training done')
answer_gnb = gnb.predict(x_test)
print('Prediction done')
print('\n\nThe classification report for knn:')
print(classification_report(y_test, answer_knn))
print('\n\nThe classification report for DT:')
print(classification_report(y_test, answer_dt))
print('\n\nThe classification report for Bayes:')
print(classification_report(y_test, answer_gnb))
KNN表现较好。
SVM（Support Vector Machine）
启发
Logistc Regression损失函数为：
J
(
θ
)
=
1
m
∑
i
=
1
m
[
−
y
(
i
)
l
o
g
(
h
θ
(
x
(
i
)
)
)
−
(
1
−
y
(
i
)
)
l
o
g
(
1
−
h
θ
(
x
(
i
)
)
)
]
+
λ
2
m
∑
j
=
1
n
θ
j
2
J\left ( \theta \right )=\frac{1}{m} \sum_{i=1}^{m}\left[ -y^{(i)}log(h_{\theta }(x^{(i)})) -(1-y^{(i)})log(1-h_{\theta }(x^{(i)}))\right ]+\frac{\lambda}{2m} \sum_{j=1}^{n}\theta _{j}^{2}
J(θ)=m1∑i=1m[−y(i)log(hθ(x(i)))−(1−y(i))log(1−hθ(x(i)))]+2mλ∑j=1nθj2
其中
−
l
o
g
h
θ
(
x
(
i
)
)
(
y
=
1
)
-logh_{\theta}(x^{(i)})(y=1)
−loghθ(x(i))(y=1)改为
c
o
s
t
1
(
θ
T
x
(
i
)
)
cost_{1}(\theta^{T}x^{(i)})
cost1(θTx(i))。
得到：
m
i
n
C
∑
i
=
1
m
[
y
(
i
)
c
o
s
t
i
(
θ
T
x
(
i
)
)
+
(
1
−
y
(
i
)
)
c
o
s
t
0
(
θ
T
x
(
i
)
)
]
+
1
2
∑
i
=
1
n
θ
j
2
minC\sum_{i=1}^{m} \left[y^{(i)}cost_{i}(\theta^{T}x^{(i)})+(1-y^{(i)})cost_{0}(\theta^{T}x^{(i)})\right]+\frac{1}{2}\sum_{i=1}^{n}\theta_{j}^{2}
minC∑i=1m[y(i)costi(θTx(i))+(1−y(i))cost0(θTx(i))]+21∑i=1nθj2
然后可以根据
−
l
o
g
h
θ
(
x
(
i
)
)
(
y
=
1
)
-logh_{\theta}(x^{(i)})(y=1)
−loghθ(x(i))(y=1)的图像近似得到
c
o
s
t
1
(
θ
T
x
(
i
)
)
cost_{1}(\theta^{T}x^{(i)})
cost1(θTx(i))：
发现
y
=
1
y=1
y=1时，
z
≥
1
z\geq1
z≥1时
c
o
s
t
cost
cost为0，
y
=
0
y=0
y=0时，
z
≤
−
1
z\leq-1
z≤−1时
c
o
s
t
cost
cost为0。
其中
z
=
θ
T
x
z=\theta^{T}x
z=θTx，即
θ
T
x
≥
1
\theta^{T}x\geq1
θTx≥1与
θ
T
x
≤
−
1
\theta^{T}x\leq-1
θTx≤−1为decision boudary。
所以最终优化目标可以写为：
m
i
n
1
2
∑
j
=
1
n
θ
j
2
min\frac{1}{2}\sum_{j=1}^{n}\theta_{j}^{2}
min21∑j=1nθj2
s
.
t
.
s.t.
s.t.
θ
T
x
(
i
)
≥
1
\theta^{T}x^{(i)}\geq1
θTx(i)≥1,
i
f
if
if
y
i
=
1
y_{i}=1
yi=1
θ
T
x
(
i
)
≤
−
1
\theta^{T}x^{(i)}\leq-1
θTx(i)≤−1,
i
f
if
if
y
i
=
0
y_{i}=0
yi=0
优化函数推导
推导过程
利用拉格朗日和KKT条件
松弛变量
由于受到噪声影响，可能很难找到合适的超平面，为了避免出现与另一类别有所重叠的噪声影响，引入松弛变量
ξ
\xi
ξ，即
θ
T
x
(
i
)
≥
1
+
ξ
i
,
i
=
(
1
,
2
,
.
.
.
n
)
\theta^{T}x^{(i)}\geq1+\xi_{i},i=(1,2,...n)
θTx(i)≥1+ξi,i=(1,2,...n)
kernel
当样本空间是线形不可分的时候，就需要引入新的特征。
e
.
g
.
e.g.
e.g.
在二维特征空间中，引入三个点，记作
l
1
,
l
2
,
l
3
l_{1},l_{2},l_{3}
l1,l2,l3然后对于每个样本，分别计算其与这三个点的高斯距离，记作
f
1
(
i
)
,
f
2
(
i
)
,
f
3
(
i
)
f_{1}^{(i)},f_{2}^{(i)},f_{3}^{(i)}
f1(i),f2(i),f3(i)。则当
θ
0
+
θ
1
f
1
(
i
)
+
θ
2
f
2
(
i
)
+
θ
3
f
3
(
i
)
≥
0
\theta_{0}+\theta_{1}f_{1}^{(i)}+\theta_{2}f_{2}^{(i)}+\theta_{3}f_{3}^{(i)}\geq0
θ0+θ1f1(i)+θ2f2(i)+θ3f3(i)≥0时，预测为1。
c
o
s
t
f
u
n
c
t
i
o
n
cost function
costfunction也变为
c
o
s
t
1
(
θ
T
f
(
i
)
)
cost_{1}(\theta^{T}f^{(i)})
cost1(θTf(i))和
c
o
s
t
0
(
θ
T
f
(
i
)
)
cost_{0}(\theta^{T}f^{(i)})
cost0(θTf(i))。
之后的推导与SVM类似。
更改上述例子中的距离计算公式，便可以得到不同的核函数。
参数分析
优化目标中的C，即对应正则化中的
1
λ
\frac{1}{\lambda}
λ1：
Large C会导致Lower bias, higher variance;
Small C会导致Higher bias, lower variance;
如果应用高斯kernel，其中的
σ
2
\sigma^{2}
σ2（根据高斯图像推断）：
Large
σ
2
\sigma^{2}
σ2会导致Higher bias, lower variance;
Small
σ
2
\sigma^{2}
σ2会导致Lower bias, Higher variance;
SVM vs Logistic Regression
设n为特征数，m为样本数。
- 若相比m，n更大，即 n ≥ m n\geq m n≥m：适用Logistic Regression，或者不用kernel的SVM；
- n较小，m中等：适用高斯核的SVM；
- n较小，m很大：可以先增加一些特征，然后适用Logistic Regression或不用kernel的SVM。
Supervised-Regression
Linear regression
代价函数
MAE:
L
(
w
,
b
)
=
1
n
∑
i
=
1
n
(
y
i
^
−
y
i
)
2
L(w,b)=\frac{1}{n}\sum_{i=1}^{n}(\hat{y_{i}}-y_{i})^{2}
L(w,b)=n1∑i=1n(yi^−yi)2
解法
- 最小二乘法
- Gradient descent：其中可以设置学习率为 α t \frac{\alpha}{t} tα或者 α t \frac{\alpha}{\sqrt{t}} tα的形式，使得最终更好达到最优点。
Polynomial regression
思想
在
y
i
=
w
0
+
w
1
x
i
+
w
2
x
i
2
+
.
.
.
+
w
p
x
i
p
y_{i} = w_{0}+w_{1}x_{i}+w_{2}x_{i}^{2}+...+w_{p}x_{i}^{p}
yi=w0+w1xi+w2xi2+...+wpxip中，
把其中的
{
1
,
x
i
,
x
i
2
,
.
.
.
,
x
i
p
}
\{1,x_{i},x_{i}^{2},...,x_{i}^{p}\}
{1,xi,xi2,...,xip}堪称features，就转变成了线形的。
Ridge regression
思想
在Polynomial regression的基础上增加了L2 Norm。
代价函数
J
(
θ
)
=
1
2
[
∑
i
=
1
m
(
h
θ
(
x
i
)
−
y
i
)
2
+
λ
∑
j
=
1
n
θ
j
2
]
J\left ( \theta \right )=\frac{1}{2}\left [ \sum_{i=1}^{m} (h_{\theta }(x^{i})-y^{i})^{2}+\lambda \sum_{j=1}^{n}\theta _{j}^{2}\right ]
J(θ)=21[∑i=1m(hθ(xi)−yi)2+λ∑j=1nθj2]
R
S
S
(
w
)
=
∑
i
=
1
m
(
h
θ
(
x
i
)
−
y
i
)
2
RSS(w)=\sum_{i=1}^{m} (h_{\theta }(x^{i})-y^{i})^{2}
RSS(w)=∑i=1m(hθ(xi)−yi)2
参数分析
λ
\lambda
λ是用来平衡RSS与正则项的关系：
当
λ
=
0
\lambda=0
λ=0,Cost function = RSS，即无正则项；
当
λ
=
∞
\lambda=\infty
λ=∞,最终
w
趋
近
于
0
w趋近于0
w趋近于0（永远不会达到0）。
通常利用Validation set来寻找合适的
λ
\lambda
λ：leave one cross validation.
Lasso regression(Least absolute shrinkage and selection operator)
思想
在Polynomial regression的基础上增加了L1 Norm。
代价函数
J
(
θ
)
=
1
2
[
∑
i
=
1
m
(
h
θ
(
x
i
)
−
y
i
)
2
+
λ
∑
j
=
1
n
｜
θ
j
｜
]
J\left ( \theta \right )=\frac{1}{2}\left [ \sum_{i=1}^{m} (h_{\theta }(x^{i})-y^{i})^{2}+\lambda \sum_{j=1}^{n}｜\theta _{j}｜\right ]
J(θ)=21[∑i=1m(hθ(xi)−yi)2+λ∑j=1n｜θj｜]
R
S
S
(
w
)
=
∑
i
=
1
m
(
h
θ
(
x
i
)
−
y
i
)
2
RSS(w)=\sum_{i=1}^{m} (h_{\theta }(x^{i})-y^{i})^{2}
RSS(w)=∑i=1m(hθ(xi)−yi)2
Feature Selection方法：
1. 自由组合：先选只有一个feature的，然后两个feature的...每一类最好的都在validation set上进行测试，选取最后表现最好的。
2. 贪心算法。
3. Lasso。
Feature Selection
- Ridge regression：如果选取一个阈值，然后过滤阈值较低的结果，这种方法不可行。因为如果有若干相关性较高的features，那么这些feature的权值会都比较小（相当于一个权值分配到了很多个上）
- Lasso：
λ
\lambda
λ增加的时候，会出现有的feature的权重变成0，即稀疏性。
上述原因可以通过画出RSS与L1，L2的图像，然后会发现L1+RSS的图像的最优化中心可能会出现在数轴上。
Neural Network
算法推导
推导过程
训练流程
Mini-batch：
- 采样一个batch数据
- 前向计算loss
- 反向计算梯度
- 用这部分梯度迭代更新权重
- 重复
batch size:批尺寸
机器学习中参数更新方法：
1. Batch Gradient Descent：批处理下降，每次遍历全部数据集以后进行一次参数更新，这样下降方向更加准确，但开销更大；
2. Stochastic Gradient Descent：随机梯度下降，每个样本进行一次梯度下降，下降快，但不准确；
3. Mini-batch Gradient Decent：小批量下降，把样本分成若干批，分别计算损失函数和更新参数。
Iteration：迭代，每更新一次w和b，就是一次Iteration。
Epoch：所有样本被计算一次就是一次Epoch。
激活函数
-
用途：在网络中引入非线性，增强神经网络的表达能力
-
Sigmoid：把输入变化为（0，1）的输出。
缺点：- 初始化权值为[0,1]之间的随机值时，梯度消失发生的概率较大；初始化为(1,+ ∞ \infty ∞)，容易发生梯度爆炸。
- 输出非0均值，所以对 w w w求局部梯度都为正，使得梯度下降都往一个方向，收敛缓慢。（可通过分batch训练缓解）
- 公式中有幂运算，求解复杂。
-
tanh函数：(Hyperbolic Tangent)
t a n h ( x ) = e x − e − x e x + e − x tanh(x) = \frac{e^{x}-e^{-x}}{e^{x}+e^{-x}} tanh(x)=ex+e−xex−e−x
解决了sigmoid非0均值输出的问题，但梯度消失和幂运算问题仍然存在。 -
Relu：
$Relu = max(0,x)
优点：- 在正区间解决了梯度消失的问题；
- 计算速度快；
- 收敛速度快。
缺点：
- 非零均值；
- 某些神经元永远不被激活（与learning rate和初始化有关）。
-
Leaky ReLU
f ( x ) = m a x ( α x , x ) f(x) = max(\alpha x,x) f(x)=max(αx,x)
把ReLU左边的0改为了非0。 α \alpha α通常取0.01。
参数初始化
-
初始化0时，所有状态无差别，都输出0，无法训练；
-
初始化为很小的随机数，对于层数少的模型可行，层数较高的网络会方差越来越小，输出基本不变；
-
初始化为大一点的随机数，输出要么是1要么是0，梯度为0；
参数初始化两个必要条件：各层激活值不会出现饱和现象；各层激活值不为0。
Feature Scaling
利用每一个维度特征的mean和variance进行标准化。
Batch Normalization
为了解决Internal Covariate Shift的问题，对每一层的output（一个batch的，不能太小）进行Normalization。
较详细解释
Multiple output
利用one-vs-all策略，把output设置为一个向量，同时把样本的label值都做一个one-hot的转变。
RNN
所存在问题
梯度消失或者梯度爆炸的问题，如果采用sigmoid函数作为激活函数，sigmoid的导数值域为
(
0
，
1
4
)
(0，\frac{1}{4})
(0，41)，在推导过程中会发现有它连乘的情况，当层次增加的时候，就会趋近于0.
GRU
算法核心
增加了Memory Cell：
c
~
<
t
>
=
t
a
n
h
(
w
c
[
c
t
−
1
,
x
<
t
>
]
+
b
n
)
\widetilde{c}^{<t>}=tanh(w_{c}[c^{t-1},x^{<t>}]+b_{n})
c
<t>=tanh(wc[ct−1,x<t>]+bn)
Γ
u
=
σ
(
w
u
[
c
<
t
−
1
>
,
x
<
t
>
]
+
b
u
)
\Gamma _{u} = \sigma (w_{u}[c^{<t-1>},x^{<t>}]+b_{u})
Γu=σ(wu[c<t−1>,x<t>]+bu)
c
<
t
>
=
Γ
u
∗
c
~
<
t
>
+
(
1
−
Γ
u
)
∗
c
~
<
t
−
1
>
c^{<t>} = \Gamma _{u}\ast \widetilde{c}^{<t>}+(1-\Gamma _{u})\ast \widetilde{c}^{<t-1>}
c<t>=Γu∗c
<t>+(1−Γu)∗c
<t−1>
- 增加了记忆门，使得之前的信息也可以存储下来，为之后的预测提供信息；
- 在进行梯度下降时，求导会得到 1 − Γ u 1-\Gamma_{u} 1−Γu这一项，所以我们可以对其进行控制，防止梯度消失的发生。
LSTM
算法核心
增加了update gate，output gate，forget gate：
c
~
<
t
>
=
t
a
n
h
(
w
c
[
c
t
−
1
,
x
<
t
>
]
+
b
n
)
\widetilde{c}^{<t>}=tanh(w_{c}[c^{t-1},x^{<t>}]+b_{n})
c
<t>=tanh(wc[ct−1,x<t>]+bn)
Γ
u
=
σ
(
w
u
[
c
<
t
−
1
>
,
x
<
t
>
]
+
b
u
)
\Gamma _{u} = \sigma (w_{u}[c^{<t-1>},x^{<t>}]+b_{u})
Γu=σ(wu[c<t−1>,x<t>]+bu)
Γ
f
=
σ
(
w
f
[
c
<
t
−
1
>
,
x
<
t
>
]
+
b
f
)
\Gamma _{f} = \sigma (w_{f}[c^{<t-1>},x^{<t>}]+b_{f})
Γf=σ(wf[c<t−1>,x<t>]+bf)
Γ
o
=
σ
(
w
o
[
c
<
t
−
1
>
,
x
<
t
>
]
+
b
o
)
\Gamma _{o} = \sigma (w_{o}[c^{<t-1>},x^{<t>}]+b_{o})
Γo=σ(wo[c<t−1>,x<t>]+bo)
c
<
t
>
=
Γ
u
∗
c
~
<
t
>
+
Γ
f
∗
c
~
<
t
−
1
>
c^{<t>} = \Gamma _{u}\ast \widetilde{c}^{<t>}+\Gamma _{f}\ast \widetilde{c}^{<t-1>}
c<t>=Γu∗c
<t>+Γf∗c
<t−1>
a
<
t
>
=
Γ
o
∗
t
a
n
h
(
c
<
t
>
)
a^{<t>} = \Gamma _{o}\ast tanh(c^{<t>})
a<t>=Γo∗tanh(c<t>)
LSTM vs GRU
GRU为LSTM的一个变种。
LSTM更复杂一些，但是也更powerful；
GRU更简单，但表达能力相对更弱。
BRNN
y
^
(
t
)
=
g
(
w
y
[
a
→
<
t
>
,
a
←
<
l
−
t
>
]
+
b
y
)
\hat{y}^{(t)} = g(w_{y}[\overrightarrow{a}^{<t>},\overleftarrow{a}^{<l-t>}]+b_{y})
y^(t)=g(wy[a<t>,a<l−t>]+by)
其基本神经元可以是LSTM或者GRU。
集成学习
bagging：并行，基学习器无强依赖
boosting：串行，有强依赖性
Bagging：Random Forest
算法思想
bagging+决策树。对data进行抽样训练基学习器，同时随机筛选部分特征子集进行训练。
优点
- 消除了DT过拟合的问题；
- 减小了预测值的方差。
Boosting：Adaboost
算法思想
减小了上一轮分类正确的权值，提升了分类错误样本的权值。
对于最终的学习器的预测结果进行加权投票。
Boosting：BDT
算法思想
利用原始数据训练一个决策树，然后计算预测值与真实值的残差。
然后利用特征与残差组成新的数据集，并用该数据集训练新的学习器，不断迭代。
Boosting：GBDT
算法思想
梯度下降+BDT。利用最速下降的近似方法，利用loss function的负梯度拟合基学习器。
−
[
∂
L
(
y
i
,
F
(
x
i
)
)
∂
F
(
x
i
)
]
F
(
x
)
=
F
t
−
1
(
x
)
-[\frac{\partial{L(y_{i},F(x_{i}))}}{\partial{F(x_{i})}}]_{F(x)}=F_{t-1}(x)
−[∂F(xi)∂L(yi,F(xi))]F(x)=Ft−1(x)
取Loss function为平方差，会发现负梯度其实和残差一样，所以可以利用负梯度来替代残差。
Regression Tree
算法思想
-
计算每个类别的标准方差
条件标准方差： S ( T , X ) = ∑ c ∈ x P ( c ) S ( c ) S(T,X)=\sum_{c\in x}P(c)S(c) S(T,X)=∑c∈xP(c)S(c) -
计算方差减小值：
S D R ( T , X ) = S ( T ) − S ( T , X ) SDR(T,X)=S(T)-S(T,X) SDR(T,X)=S(T)−S(T,X)
选取下降最多的作为分裂标准。 -
停止条件：
- 某分支变化系数小于某个阈值：
变化系数：Coifficient of variance = CV = S x ˉ ∗ 100 \frac{S}{\bar{x}}*100% xˉS∗100
- 节点元素个数小于某个阈值
Boosting：XGboost
算法推导
- 每次生成新的树，优化目标为：
O b j ( Θ ) = ∑ i = 1 N L ( y i + y F ) + ∑ j = 1 t Ω ( f i ) Obj(\Theta)=\sum_{i=1}^{N}L(y_{i}+\overset{F}{y})+\sum_{j=1}^{t}\Omega(f_{i}) Obj(Θ)=∑i=1NL(yi+yF)+∑j=1tΩ(fi)
其中 y F \overset{F}{y} yF为新生成的树的预测值。
O b j ( Θ ) = ∑ i = 1 N L ( y i , y ^ i ( t ) ) + ∑ j = 1 t Ω ( f i ) Obj(\Theta)=\sum_{i=1}^{N}L(y_{i},\hat{y}_{i}^{(t)})+\sum_{j=1}^{t}\Omega(f_{i}) Obj(Θ)=∑i=1NL(yi,y^i(t))+∑j=1tΩ(fi)
O b j ( Θ ) = ∑ i = 1 N L ( y i , y ^ i ( t − 1 ) + f t ( x i ) ) + O m e g a ( f t ) + c o n s t Obj(\Theta)=\sum_{i=1}^{N}L(y_{i},\hat{y}_{i}^{(t-1)}+f_{t}(x_{i}))+Omega(f_{t})+const Obj(Θ)=∑i=1NL(yi,y^i(t−1)+ft(xi))+Omega(ft)+const
泰勒展开，推导后可得：
O b j = ∑ i = 1 N ( g i f t ( x i ) + 1 2 h t f t 2 ( x i ) ) + Ω ( f t ) Obj= \sum_{i=1}^{N}(g_{i}f_{t}(x_{i})+\frac{1}{2}h_{t}f_{t}^{2}(x_{i}))+\Omega(f_{t}) Obj=∑i=1N(gift(xi)+21htft2(xi))+Ω(ft)
即 O b j = ∑ i = 1 N ( g i w i + 1 2 h t w i 2 ( x i ) + γ T Obj= \sum_{i=1}^{N}(g_{i}w_{i}+\frac{1}{2}h_{t}w_{i}^{2}(x_{i})+\gamma T Obj=∑i=1N(giwi+21htwi2(xi)+γT
求导=0:
w j = − G j H j + λ w_{j}=-\frac{G_{j}}{H_{j}+\lambda} wj=−Hj+λGj
带回。
然后根据Obj可以推导出新的Gain的算法，可以作为树分裂的依据。
扫一扫
3070
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
