机器学习基础

一、数据分析步骤

1. 数据清洗

剔除强势样本，数据类型处理。

2. 数据分析

（1）查看数据统计指标，了解数据大概情况。

（2）划分离散与连续特征值。离散的通过通过分组看与目标值的关系，可以crosstab进行离散数据统计查看。连续的通过统计直方图、散点图看与目标的关系。还可以通过cut将连续数据离散化来观察。

（3）选择模型：连续用回归模型，离散用分类模型。

（4）特征值如果多数为离散的就用决策树模型----集合算法。

3. 梯度下降

沿着梯度向量相反的方向，梯度减少最快，也就是更加容易找到函数的最小值。

二、机器学习的一般过程

数据处理	机器学习	业务运维
1. 数据收集 （数据检索、数据挖掘、爬虫）2. 数据清洗3. 特征工程	1. 选择模型 （算法）2. 训练模型 （算法）3. 评估模型 （工具、框架、算法知识）4. 测试模型	1. 应用模型2. 维护模型

三、数据预处理

标准化、范围缩放、归一化能加快梯度下降的求解速度，即提升模型的收敛速度。

1. 均值移除(标准化)：整个样本的每列

将各个特征的平均值调整为0，标准差调整为1，防止某一个特征列数值太大而一家独大。

作用：消除不同数据之间的量纲，收敛速度更快，损失值更小。

import sklearn.preprocessing as sp
# 均值移除可以让样本矩阵中的每一列的平均值为0，标准差为1。
A = sp.scale(array)

2. 范围缩放：整个样本的每列

最大、最小值的范围缩放到合理的大小（通常是1-0），使得特征的范围具有可比性。

# 创建MinMax缩放器
mms = sp.MinMaxScaler(feature_range=(0, 1))
# 调用mms对象的方法执行缩放操作, 返回缩放过后的结果
result = mms.fit_transform(原始样本矩阵)

3. 归一化：注重每行样本的比例

用占比表示特征，用每个样本的绝对值除以该样本绝对值之和，以使每个样本的特征值绝对值之和为1。

作用：归一化是为了消除不同数据之间的量纲，方便数据比较和共同处理，比如在神经网络中，归一化可以加快训练网络的收敛性。

# array 原始样本矩阵
# norm  范数
# l1范数，元素绝对值之和。L1可以实现稀疏化。
# l2范数，元素平方之和。L2避免过拟合
sp.normalize(array, norm='l1')

4. 二值化：图像边缘识别

# 给出阈值, 获取二值化器
bin = sp.Binarizer(threshold=阈值)
# 调用transform方法对原始样本矩阵进行二值化预处理操作
result = bin.transform(原始样本矩阵)

5. 独热编码：针对离散值进行全样本按列编码

只有0，1的编码类型。

ohe = sp.OneHotEncoder(sparse=是否采用紧缩格式, dtype=数据类型)
# 对原始样本矩阵进行处理，返回独热编码后的样本矩阵。
result = ohe.fit_transform(原始样本矩阵)

6. 标签编码：针对一列字符串特征进行处理

将红，蓝，绿转化为0，1，2就是标签编码。

lbe = sp.LabelEncoder()
# 调用标签编码器的fit_transform方法训练并且为原始样本矩阵进行标签编码
result = lbe.fit_transform(原始样本数组)
# 根据标签编码的结果矩阵反查字典 得到原始数据矩阵
samples = lbe.inverse_transform(result)

四、回归模型

1. 线性回归

多元函数在某一点的梯度是一个非常特殊的向量，其由多元函数对每个变量的偏导数组成，其方向为函数在该点增加最快的方向，大小为函数在该点的最大变化率。

找到最佳的w0和w1来描述输入和输出的关系。如何确定最佳直线呢。我们就需要用总体样本误差最小的方法来判断。样本误差就是这个点的y值与预测函数对应y值的差的平方。将所有样本误差加在一起求和再乘以1/2。可以将预测函数y用w0和w1来表示，表示后就是该直线方程的损失函数。当损失函数取最小值时就是最佳直线。

梯度下降就是不断更新参数去找出最低点。参数更新公式：
$$w_n=w_{n-1}-\alpha \ast \frac{\partial y}{\partial x}$$

import sklearn.linear_model as lm
# 创建模型
model = lm.LinearRegression()
# 训练模型
# 输入为一个二维数组表示的样本矩阵
model.fit(输入, 输出)   #训练模型
# 预测输出  
# 输入array是一个二维数组，每一行是一个样本，每一列是一个特征。
result = model.predict(array)

2. 误差评估：r2得分

import sklearn.metrics as sm

#平均绝对值误差：1/m∑|实际输出-预测输出|     
sm.mean_absolute_error(y, pred_y)
# 平均平方误差：1/mΣ(实际输出-预测输出)
sm.mean_squared_error(y, pred_y)
# 中位绝对值误差：MEDIAN(|实际输出-预测输出|)
sm.median_absolute_error(y, pred_y)
# R2得分，(0,1]区间的分值。分数越高，误差越小。
sm.r2_score(y, pred_y)

3. 模型的保存于读取

import pickle
# 将训练好的模型对象保存到磁盘文件中
with open('../../data/linear.pkl', 'wb') as f:
    pickle.dump(model, f)
# 从磁盘文件中加载模型对象
with open('../../data/linear.pkl', 'rb') as f:
    model = pickle.load(f)
# 根据输入预测输出
pred_y = model.predict(x)

4. 岭回归

通过添加正则项来调整损失函数的占比，从而达到提高多数正常样本拟合精度。

import sklearn.linear_model as lm
# 创建模型
model=lm.Ridge(正则强度，fit_intercept=True)
# fit_intercept为是否训练截距，y轴上的值。
model.fit(输入, 输出)
# 预测输出  
# 输入array是一个二维数组，每一行是一个样本，每一列是一个特征。
result = model.predict(array)

5. 多项式回归

是将一次项特征进行扩展得到高次项。然后将高次项看做一个变量，进行多元线性回归。使用sklearn提供的数据管线实现两个步骤的顺序执行。

import sklearn.pipeline as pl
import sklearn.preprocessing as sp
import sklearn.linear_model as lm
model = pl.make_pipeline(
   sp.PolynomialFeatures(10),  # 多项式特征扩展器
   lm.LinearRegression())     # 线性回归器

6. 决策树：CART分类回归树

相似的输入必会产生相似的输出。为了防止过拟合，可以做适当剪枝操作。

针对集合S，遍历每一个特征的每一个分割value，用该value将原数据集S分裂成2个集合：左集合left(<=value的样本)、右集合right(>value的样本)，分别计算这2个集合的MSE均方误差，找到使（left_mse+right_mse）最小的那个value，记录下此时的特征名称和value，这个就是最佳分割特征以及最佳分割值；

import sklearn.tree as st
# 创建决策树回归器模型
model=st.DecisionTreeRegressor(max_depth=4, min_samples_split=2)
model.fit(train_x, train_y)
# 预测
pred_test_y = model.predict(test_x)

特征重要性：决策树副产品

决策树在划分子表时选择特征的顺序就标志了该特征的重要程度，通过feature_importances_获取特征。

model.fit(train_x, train_y)
cl=trainx.columns  #获取列名
mi=model.feature_importances_  #获取特征
sortimp=mi.argsort()[::-1]  #特征值进行排序

7. 集合算法：天生防止过拟合

根据多个弱分类器给出的预测结果，利用平均值(回归)或者投票(分类)的方法，得出最终预测结果。

Boosting(提升)类模型：先训练一个弱分类器

AdaBoost模型（正向激励）

将原始样本随机分配初始权重构建弱分类器决策树，然后将训练样本带入模型，根据权重预测其输出（回归就用平均值，分类就用投票）。然后对预测值与实际值误差大的样本，提高其权重重构决策树。再循环带入、预测、对比、修改权重值。最终通过不同权重值来创建线性回归模型。

import sklearn.tree as st
import sklearn.ensemble as se
# model: 决策树模型（一颗）
tree=st.DecisionTreeRegressor(max_depth=4)
# n_estimators：构建400棵不同权重的决策树训练模型
model=se.AdaBoostRegressor(tree,n_estimators=400 #最大400棵树 ,random_state=7 #随机权重)

GBDT（梯度提升树）：先构建一棵cart决策树

先产生一个弱分类器，将训练样本带入模型算出预测值，将实际值与预测值的残差作为一个新的y，**每个样本残差构成了损失函数，**通过梯度下降寻求损失函数最小值的模型参数。

**通过残差构建第二课树，对残差进行预测。**如果预测值等于残差值，那么结果就是多棵树预测结果之和。

import sklearn.tree as st
import sklearn.ensemble as se
# 自适应增强决策树回归模型	
# n_estimators：构建400棵不同权重的决策树，训练模型
model=se.GradientBoostingRegressor(max_depth=10,n_estimators=1000,
                                   min_samples_split=2)

Bagging（打包）类模型：随机一个弱分类器

随机森林

自助聚合的基础上，随机选择样本和特征，不仅规避了强势样本的影响，也削弱了强势特征的影响，使模型的预测能力更加泛化。

import sklearn.ensemble as se
# 随机森林回归模型	
model=se.RandomForestRegressor(max_depth=10 #最大深度为10, 
                               n_estimators=100 #一共构建100棵树, 
                               min_samples_split=2 ) #子表拆分到2个样本后就不再拆分了

五、分类模型

1. 数据集划分

每类选取固定比例作为训练样本。

import sklearn.model_selection as ms
训练输入, 测试输入, 训练输出, 测试输出 = ms.train_test_split(输入集, 输出集, test_size=测试集占比, random_state=随机种子)
# 划分训练集和测试集
train_x,test_x,train_y,test_y=ms.train_test_split( x, y, test_size=0.25, random_state=7)

2. 样本类别均衡化

每个类样本差别不能太大！可以通过下采样、上采样。

# 基于线性核函数的支持向量机分类器
model=svm.SVC(kernel='linear',class_weight='balanced')
model.fit(train_x, train_y)

3. 逻辑回归分类模型

通过决策边界上的点划分到所有类别的概率是相等的，推导出决策边界函数为：$w^T+b=0$。所以逻辑回归的决策边界是线性的，逻辑回归是线性分类器！！！

变量通过线性函数和逻辑函数后将值变为概率。通过多个二元分类器解决多元分类问题，一个类别为1，其他类别都为0.

通过线型回归方程返回的是连续值，不可以直接用于分类业务模型，所以把连续的预测值变为离散的预测值。逻辑函数（sigmoid）：将样本线性回归的输出作为sigmoid函数的输入进行映射，输出为0-1的概率值。
$$y=\frac{1}{1+e^{-x}}$$

import sklearn.linear_model as lm
# 构建逻辑回归器 
# C：参数代表正则强度。
model= lm.LogisticRegression(C=正则强度)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aEmQU6ks-1652190528177)(.\ml_images\lrlc.png)]

目标函数：极大似然估计函数，什么样的参数w，b跟我们的数据x组合后恰好是真实值。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c6ieWnv3-1652190528178)(.\ml_images\ljhgmbhs01.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ir1beh4f-1652190528179)(.\ml_images\ljhgmbhs02.png)]

4. 模型评价标准：交叉验证、F1得分

避免特殊样本的影响。将样本n等分，组合不同的训练集和测试集训练模型，最后输出各次指标得分。

import sklearn.model_selection as ms
Score = ms.cross_val_score(模型, 输入集, 输出集, cv=折叠数, scoring=指标名)

精确度(accuracy)：分类正确的样本数/总样本数

查准率(precision_weighted)：针对每一个类别，预测正确的样本数比上预测出来的样本数

召回率(recall_weighted)：针对每一个类别，预测正确的样本数比上实际存在的样本数

f1得分(f1_weighted)： 2x查准率x召回率/(查准率+召回率)

**AUC：**AUC被定义为ROC曲线下与坐标轴围成的面积，显然这个面积的数值不会大于1。又由于ROC曲线一般都处于y=x这条直线的上方，所以AUC的取值范围在0.5和1之间。AUC越接近1.0，检测方法真实性越高;等于0.5时，则真实性最低，无应用价值。

import sklearn.model_selection as ms
# 交叉验证
# 精确度
ac = ms.cross_val_score( model, train_x, train_y, cv=5, scoring='accuracy')
print(ac.mean())
# 查准率
pw = ms.cross_val_score( model, train_x, train_y, cv=5, scoring='precision_weighted')
print(pw.mean())
# 召回率
rw = ms.cross_val_score( model, train_x, train_y, cv=5, scoring='recall_weighted')
print(rw.mean())
# f1得分
fw = ms.cross_val_score( model, train_x, train_y, cv=5, scoring='f1_weighted')
print(fw.mean())

5. 参数优化

超参优化：验证曲线

train_scores,test_scores = ms.validation_curve(model,# 模型 
												输入集, 输出集, 
    											'n_estimators', 		#超参数名
    											np.arange(50, 550, 50),	#超参数序列
												cv=5 #折叠数 )

样本参数优化：学习曲线

_,train_scores,test_scores=ms.learning_curve(model,		# 模型 
    										输入集, 输出集, 
   											train_sizes=[0.9, 0.8],  #训练集大小序列
    										cv=5		# 折叠数 )

6. 网格搜索：寻求最优超参数组合

import sklearn.model_selection as ms
params = [{'kernel':['linear'], 'C':[1, 10, 100, 1000]},
		{'kernel':['poly'], 'C':[1], 'degree':[2, 3]}, 
		{'kernel':['rbf'], 'C':[1,10,100], 'gamma':[1, 0.1, 0.01]}]
model= ms.GridSearchCV(模型, params, cv=5)
model.fit(train_x, train_y)
# 获取网格搜索每个参数组合
model.cv_results_['params']
# 获取网格搜索每个参数组合所对应的平均测试分值
model.cv_results_['mean_test_score']
# 获取最好的参数，训练后才能拿到！！！
model.best_params_
model.best_score_
model.best_estimator_

# 实际运用
clf = GridSearchCV(lr,params,cv=5)
clf.fit(x_train,y_train)
clf.score(x_test,y_test)
print(clf.best_params_)

7. 预测后评价指标

混淆矩阵

行表示实际类别，列表示预测类别。

import sklearn.metrics as sm
混淆矩阵 = sm.confusion_matrix(实际输出, 预测输出)

分类报告

可以得到交叉验证查准率、召回率、f1得分的结果。

# 获取分类报告
cr = sm.classification_report(实际输出, 预测输出)

8. 决策树分类

决策树分类模型会找到与样本特征匹配的叶子节点然后以投票的方式进行分类。分类算法是根据基尼系数构建树。不纯度，越小越纯！！！

计算当前每个特征的各个特征value对数据集D的基尼系数，选择最小的特征A和特征值a将数据划分为两个部分D1，D2。最后通过投票的方式进行分类！！！

对样本D计算基尼系数：
$$Gini(D)=1-((\frac{A类个数}{总个数}{)}^2+(\frac{B类个数}{总个数}{)}^2)$$

$$例如：Gini(D)=1-((\frac{40}{100}{)}^2+(\frac{60}{100}{)}^2)$$

对于A条件下D计算基尼系数：
$$Gini(D)=\frac{|D_1|}{|D|}\ast Gini(D_1)+\frac{|D_2|}{|D|}\ast Gini(D_2)$$

import sklearn.ensemble as se
model=se.RandomForestClassifier(max_depth=6, n_estimators=200, random_state=7)

GBDT分类：将预测值经过逻辑函数映射到概率上，然后优化概率残差。

AdaBoost分类：加权投票。

9. 支持向量机

svm输出置信概率，需要在构建模型时设置probability=True，否则报错。

选取距离最近的两个点作为两个支持向量，过两个点做两条平行线，中间的点进行软间隔处理映射到边界上，过两点中间点再做一条平行于上两条的平行线，可以尽可能多的将样本划分开，并且保证两个平行线之间的距离最大，两个向量到直线的距离相等。

1.寻求最优分类边界：简化公正

正确：对大部分样本可以正确地划分类别。

泛化：最大化支持向量间距。

公平：与支持向量等距。

简单：线性，直线或平面，分割超平面。

2.基于核函数的升维变换：将无法分割的低维度特征，转换到高维度再进行划分。

import sklearn.svm as svm
线性核函数：linear 
model = svm.SVC(kernel='linear')
多项式核函数：poly
model = svm.SVC(kernel='poly', degree=3)
正态分布核函数：
model=svm.SVC(kernel='rbf',C=600,
gamma=0.01) 
#gamma越大，标准差越小，容易过拟合。
model.fit(x, y)
probs = model.predict_proba(test_data)

1. Liner SVM

Hard Constraint

目标就是最大化安全区间距。

中间线为$w^{T}x+b=0$这条直线，上下平行线随意选取标准化的$w^{T}x+b=1$与$w^{T}x+b=-1$两条边界线（可以通过参数的线性缩放来上下移动）。根据已知可以得到四个条件关系：
$$(1)w^{T}x+b=1，(2)w^{T}x+b=-1，(3)x_{+}=x_{-}+\lambda w，(4)w\perp w^T$$
化简求得$\lambda =\frac{2}{w^{T}w}$，目标函数就是：$maxmize|x_{+}-x_{-}|$，化简后得到$maxmize\frac{2}{||w||}$。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iMy6qabL-1652190528179)(.\ml_images\svm01.png)]

根据理想分类结果，得出目标函数$maxmize\frac{2}{||w||}$，转化后得出目标函数及条件：
$$\begin{gathered} 目标函数：minmize||w|{|}^2 \\ 条件：w^T{x}_i+b>=1if{y}_i=1 \\ {w}^T{x}_i+b<=-1if{y}_i=-1 \end{gathered}$$
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-58W7JSuD-1652190528180)(.\ml_images\svm02.png)]

Soft Constraint

对于大多数情况下会有一些点落在安全区内或者对方区域内，这样就要考虑到模型分类的容错率，所以在目标函数中加入一个错误大小项${\epsilon }_i$，相当于条件宽松化，使得样本点可以落在安全区内或者对方区域内。得到目标函数与条件为：目标函数中加入每个样本错误量的和${\sum }_{i=1}^n{\epsilon }_i$，条件中加入容错项后$1-{\epsilon }_i$，相当于允许点在安全区内或者对方区域内出现进行分类。
$$\begin{gathered} 目标函数：minmize||w|{|}^2+\lambda \sum _{i=1}^n{\epsilon }_i \\ 条件：(w^T{x}_i+b)y_i>=1-{\epsilon }_i{\epsilon }_i>=0 \end{gathered}$$
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8WmbB4Ol-1652190528180)(.\ml_images\svm03.png)]

Hinge Loss

通过条件可以得出${\epsilon }_i>=1-(w^T{x}_i+b)y_i$，而目标函数是需要最小化${\epsilon }_i$，所以${\epsilon }_i=1-(w^T{x}_i+b)y_i$，从而得出目标函数为：$max(0,{\epsilon }_i=1-(w^T{x}_i+b)y_i)$为Hinge Loss，意思是取两个值中最大者。
$$目标函数：minmize||w|{|}^2+\lambda \sum _{i=1}^{n}max(0,{\epsilon }_i=1-(w^T{x}_i+b)y_i)$$
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZFSUsAu8-1652190528181)(.\ml_images\svm04.png)]

再运用梯度下降法对目标函数就行优化，求出参数w和b。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mUjKGpQW-1652190528181)(.\ml_images\svm05.png)]

2. SVM的KKT条件

将Hard Constraint中的目标函数和条件进行转换，将不等于条件转化为小于等于，得到SVM的KKT条件如下：
$$\begin{gathered} 目标函数：minmize\frac{||w|{|}^2}{2}+\sum _{i=1}^n{\lambda }_i[1-y_i(w^T{x}_i+b)] \\ 条件：{\lambda }_i>=0\forall i \\ {\lambda }_i[1-y_i(w^T{x}_i+b)]=0\forall i \\ 1-y_i(w^T{x}_i+b)<=0\forall i \end{gathered}$$
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PmauA3Gt-1652190528181)(.\ml_images\svm07.png)]

3. 高维映射

由于数据从低维映射到高维时，映射时所需的时间复杂度变大，同时模型复杂度也会变大，当维度无穷时候所需要的时间复杂度会变得非常大，这样显然不可行。所有就出现了核函数！！！

在设计高维映射核函数的时候，升维后的两个向量的内积，只与原始两个向量内积有关系，这样复杂度就不会变化。主要是需要设计正好满足升维后内积是原始内积n次方的函数关系。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ouxDEnqi-1652190528182)(.\ml_images\gwys01.png)]

六、文本分类

1. 文本分词

import nltk.tokenize as tk
# 把样本按句子进行拆分  sent_list:句子列表
sent_list = tk.sent_tokenize(text)
# 把样本按单词进行拆分  word_list:单词列表
word_list = tk.word_tokenize(text)
#  把样本按单词进行拆分 punctTokenizer：分词器对象
punctTokenizer = tk.WordPunctTokenizer() 
word_list = punctTokenizer.tokenize(text)

2. 词袋模型

所有可能出现的单词作为特征名，每一个句子为一个样本，单词在句子中出现的次数为特征值构建数学模型。

This hotel is very bad. The toilet in this hotel smells bad. The environment of this hotel is very good.

1 This hotel is very bad.
2 The toilet in this hotel smells bad.
3 The environment of this hotel is very good.

This	hotel	is	very	bad	The	toilet	in	smells	environment	of	good
1	1	1	1	1	0	0	0	0	0	0	0
2	0	0	0	1	1	1	1	1	0	0	0
1	1	1	1	0	1	0	0	0	1	1	1

import sklearn.feature_extraction.text as ft
# 构建词袋模型对象
cv = ft.CountVectorizer()
# 训练模型，把句子中所有可能出现的单词作为特征名，每一个句子为一个样本，单词在句子中出现的次数为特征值。
bow = cv.fit_transform(sentences).toarray()
print(bow)
# 获取所有特征名
words = cv.get_feature_names()

3. TF-IDF

$$词频=\frac{单词在样本中出现次数}{样本总词数}$$

$$文档频率=\frac{含有某个单词的文档样本数}{总文档样本数}$$

$$逆文档频率=log(\frac{总样本数}{1+含有某个单词的样本数})$$

$词频逆文档频率(TFIDF)=词频\ast 逆文档频率$，值越大对语句越重要。

# 获取词袋模型
cv = ft.CountVectorizer()
bow = cv.fit_transform(sentences).toarray()
# 获取TF-IDF模型训练器
tt = ft.TfidfTransformer()
tfidf = tt.fit_transform(bow).toarray()

# 直接转化为TFIDF向量
from sklearn.feature_extraction.text import TfidfVectorizer
vectorizer = TfidfVectorizer()
x_train = vectorizer.fit_transform(x_train)
x_test = vectorizer.transform(x_test)

4. 朴素贝叶斯分类

先通过最大似然定义目标函数：
$$\begin{gathered} P(D)=\prod _{i=1}^{n}P(x^i,y^i)最大似然法产生生成模型 \\ =\prod _{i=1}^{n}P(x^i|y^i).P(y^i)通过chainrule将联合概率转化为条件概率 \\ =\prod _{i=1}^{n}P(x_1^i,x_2^i...x_n^i|y^i).P(y^i)将每篇文章x^i进行分词后展开 \\ =argmax(\theta )\prod _{i=1}^n\prod _{j=1}^{m}P(x_j^i|y^i).P(y^i)根据条件独立假说生成朴素贝叶斯的目标函数，\theta 是全部参数。 \\ =argmax(\theta )\log [\prod _{i=1}^n\prod _{j=1}^{v}P(w_j|y^i{)}^{n_{ij}}.P(y^i)]转化为词典库大小相关的条件概率表示 \end{gathered}$$
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d92mBbn4-1652190528182)(.\ml_images\psbys01.png)]

继续将目标函数向着参数θ方向转化：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lbf3lwsb-1652190528182)(.\ml_images\psbys02.png)]

**贝叶斯定理：P(A|B)=P(B|A)P(A)/P(B) **

根据条件独立假设，特征值之间没有因果关系

P(高兴|晴天,休闲,没约) = P(晴天,休闲,没约|高兴) P(高兴) / P(晴天,休闲,没约)————》可以统计得到  
P(郁闷|晴天,休闲,没约) = P(晴天,休闲,没约|郁闷) P(郁闷) / P(晴天,休闲,郁闷)————》可以统计得到

即比较：
P(晴天,休闲,没约|高兴) P(高兴) 
P(晴天,休闲,没约|郁闷) P(郁闷)

朴素：根据条件独立假设，特征值之间没有因果关系，则：
P(晴天|高兴) P(休闲|高兴) P(没约|高兴)P(高兴)
P(晴天|郁闷) P(休闲|郁闷) P(没约|郁闷)P(郁闷)

import sklearn.naive_bayes as nb
# 创建多项式贝叶斯分类器
clf = nb.MultinomialNB()
# 创建高斯分布朴素贝叶斯分类器
model = nb.GaussianNB() 
# 传入的tfidf不能是稀疏矩阵
model.fit(x, y)
result = model.predict(samples)

用朴素贝叶斯解决邮件分类
$$\begin{gathered} 贝叶斯公式：P(正常|内容)=\frac{P(内容|正常)P(正常)}{P(内容)}其中P(内容)可以约分掉 \\ 朴素贝叶斯(条件独立性假设)：P(内容|正常)P(正常)=P(购买,物品,不是,广告|正常)P(正常) \\ =P(购买|正常)P(物品|正常)P(不是|正常)P(广告|正常)P(正常) \end{gathered}$$

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aaNWdgeA-1652190528183)(.\ml_images\psbye.png)]

5. 置信概率评判指标

根据样本与分类边界的距离远近，对其预测类别的可信程度进行量化，离边界越近的样本，置信概率越低，反之，离边界越远的样本，置信概率高。

# 在获取模型时，给出超参数probability=True
model = svm.SVC(kernel='rbf', C=600, gamma=0.01, probability=True)
预测结果 = model.predict(输入样本矩阵)
# 调用model.predict_proba(样本矩阵)可以获取每个样本的置信概率矩阵
置信概率矩阵 = model.predict_proba(输入样本矩阵)

七、聚类

1. K均值算法

聚类中心不一定是实际样本值。

随机选择k个样本作为聚类中心，计算每个样本到各个聚类中心的欧氏距离，将样本划分到距离最近的中心所在样本。根据划分的类计算几何中心，然后再计算的几何中心为新的聚类中心，重复上面的操作。

直到几何中心与聚类中心重合！！！

import sklearn.cluster as sc
# n_clusters: 聚类数
model = sc.KMeans(n_clusters=4)
# 不断调整聚类中心，知道最终聚类中心稳定则聚类完成
model.fit(x)
# 获取训练结果的聚类中心
labels=model.labels_  #所在的类
prey=model.predict(x)
centers = model.cluster_centers_

2. 均值漂移算法

样本需要符合正态分布。

用不同的概率密度函数拟合样本统计直方图，直到找到最佳拟合效果。这些密度函数的峰值点就是聚类中心。再求各个样本点到聚类中心的距离，并就近到所属类。

# 量化带宽，决定每次调整概率密度函数的步进量
# n_samples：样本数量
# quantile：量化宽度（直方图一条的宽度）
bw = sc.estimate_bandwidth(x, n_samples=len(x), quantile=0.1)
# 均值漂移聚类器
model = sc.MeanShift(bandwidth=bw, bin_seeding=True)  # True一个量化带宽进行一次移动拟合
model.fit(x)

3. DBSCAN算法

找主要的类，忽略次要的类。

任选一点，给定半径画圆，圈住的就是一个类，再以圈住的样本点做圆，直到没有一个新样本加入。

孤立样本：聚类中的样本数低于所设定的下限，则不称其为聚类，反之称其为孤立样本。类别标签为-1。

外周样本：被其它样本聚集到某个聚类中，但无法再引入新样本的样本。

核心样本：除了外周样本和孤立样本以外的样本。

# DBSCAN聚类器
# eps：半径
# min_samples：聚类样本数的下限，若低于该数值，则称为孤立样本
model = sc.DBSCAN(eps=epsilon, min_samples=5)
model.fit(x)

4. 轮廓系数评判指标

轮廓系数为$\frac{(b-a)}{max(a,b)}$，b是样本到另一个距离最近聚类所有样本的平均距离。a是到所在聚类其他样本的平均距离。

轮廓系数的区间为：[-1, 1]，1为最好。

import sklearn.metrics as sm
# v：平均轮廓系数
# metric：距离算法：使用欧几里得距离(euclidean)
v = sm.silhouette_score(输入集, 输出集, sample_size=样本数, metric=距离算法)

5. 用户画像推荐算法思路

1.以业务为指导结合用户基本信息、用户行为等设计用户标签。根据用户注册信息、购买记录、浏览记录、系统日志等由专人对1000用户各个标签设置权重。

2.以1000用户为基础，运用GBDT建立机器学习模型，对其他用户的标签权重进行预测。并建立用户标签仓库。

3.先根据KMeans聚类算法，结合商品实际情况将用户根据用户标签划分成16个类别。

4.根据客户标签先找到客户属于哪一类，再获取这类的所有用户，再通过pandas.corr函数获得这批用户相似矩阵。取到该用户相似用户，并对相似的排序。取前10位相似度最高用户。

5.计算当前用户与每位用户的欧氏距离得分作为推荐权重，以权重×10位用户商品浏览记录，再加上1×10位用户商品购买记录，再按照商品得分排序生成推荐商品清单(去掉重复)。