划分数据集

import sklearn.model_selection as ms #模型选择,训练集测试集划分
#整理测试集和训练集 : 训练集输入,测试集输入,训练集输出,测试集输出
train_x,test_x,train_y,test_y = ms.train_test_split(x, #输入数据
													                                                    y,  #输出数据
													                                                    test_size=0.1, #测试集占比
													                                                    random_state=7)#随机种子
													                                                    # stratify=y   让类别等比划分

线性回归

# 利用LinearRegression实现线性回归
import numpy as np
import sklearn.linear_model as lm  # 线性模型
import sklearn.metrics as sm  # 模型性能评价模块
import matplotlib.pyplot as mp

train_x = np.array([[0.5], [0.6], [0.8], [1.1], [1.4]])  # 输入集
train_y = np.array([5.0, 5.5, 6.0, 6.8, 7.0])  # 输出集

# 创建线性回归器
model = lm.LinearRegression()
# 用已知输入、输出数据集训练回归器
# 注意：ｘ是二维的，ｙ是一维　使用pd.DataFrame(x)表结构默认就是将1维变2维　
model.fit(train_x, train_y)
# 根据训练模型预测输出
pred_y = model.predict(train_x)

print("coef_:", model.coef_)  # 系数
print("intercept_:", model.intercept_)  # 截距

# 可视化回归曲线
mp.figure('Linear Regression', facecolor='lightgray')
mp.title('Linear Regression', fontsize=20)
mp.xlabel('x', fontsize=14)
mp.ylabel('y', fontsize=14)
mp.tick_params(labelsize=10)
mp.grid(linestyle=':')

# 绘制样本点
mp.scatter(train_x, train_y, c='blue', alpha=0.8, s=60, label='Sample')

# 绘制拟合直线
mp.plot(train_x,  # x坐标数据
        pred_y,  # y坐标数据
        c='orangered', label='Regression')

mp.legend()
mp.show()

lasso回归与岭回归

import sklearn.linear_model as lm #线性模型
# lasso回归
model_3 = lm.Lasso(alpha=0.5,  # L1范数相乘的系数
                   max_iter=1000)  # 最大迭代次数
model_3.fit(x, y)  # 训练
pred_y3 = model_3.predict(x)  # 预测
print('Ridge_Score:-->',sm.r2_score(test_y,pred_test_y))  # 评估

#使用岭回归模型拟合
model_ridge = lm.Ridge(alpha=100,max_iter=1000)  # 正则强度，最大迭代次数
model_ridge.fit(train_x,train_y)
pred_test_y = model_ridge.predict((test_x))
print('Ridge_Score:-->',sm.r2_score(test_y,pred_test_y))  # 评估

多项式回归

# 多项式回归
# 1. 将一元N次的多项式 ---> N元一次线性回归
# 2. 使用线性模型拟合当前数据
import matplotlib.pyplot as plt
import pandas as pd
import sklearn.pipeline as pl  # 数据管线
import sklearn.preprocessing as sp  # 数据预处理
import sklearn.linear_model as lm  # 线性模型

data = pd.read_csv('./Salary_Data.csv')
x, y = data['YearsExperience'], data['Salary']
train_x = pd.DataFrame(x)
train_y = y
# 构建多项式回归模型
model = pl.make_pipeline(sp.PolynomialFeatures(4),  # 进行特征扩展 最高次幂为4
                         lm.LinearRegression())  # 扩展完交给线性模型处理
# 训练
model.fit(train_x, train_y)
# 预测
pred_train_y = model.predict(train_x)
# 指定线形
plt.grid(linestyle=':')
plt.scatter(x, y)  # 散点图
plt.plot(x, pred_train_y, color='orangered')
plt.show()

决策树

Boosting（提升）类：
Adaboost正向激励 和 GBDT（梯度提升树–残差）

import sklearn.metrics as sm #模型评估
from sklearn import tree #决策树
#使用Adaboost正向激励 构建模型
model = tree.DecisionTreeRegressor(max_depth=4)  # 最大深度
model_ada = se.AdaBoostRegressor(model,
                                 n_estimators=400,#弱模型数量
                                 random_state=7) # 随机种子
model_ada.fit(train_x,train_y)
pred_test_y = model_ada.predict(test_x)
print('Ada_Score-->:',sm.r2_score(test_y,pred_test_y))

import sklearn.ensemble as se #集合模型
#使用GBDT训练模型
model_GBDT = se.GradientBoostingRegressor(max_depth=4,
                                          n_estimators=400,
                                          min_samples_split=5)  # 最小分割数量
model_GBDT.fit(train_x,train_y)
pred_test_y = model_GBDT.predict(test_x)
print('GBDT_Score-->:',sm.r2_score(test_y,pred_test_y))

Bagging （打包）类：

import sklearn.ensemble as se #集合模型
#随机森林(回归Regressor、分类Classifier)
model_forest = se.RandomForestRegressor(max_depth=10,
                                        n_estimators=1000,
                                        min_samples_split=7)
model_forest.fit(train_x,train_y)
pred_test_y = model_forest.predict(test_x)
print('Forest_Score-->:',sm.r2_score(test_y,pred_test_y))

分类

逻辑回归（鸢尾花）

import sklearn.datasets as sd #数据集
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import sklearn.model_selection as sm
import sklearn.linear_model as lm # 线性模型,做逻辑回归
#加载鸢尾花数据
Iris = sd.load_iris()
# print(Iris.keys())
# print(Iris.DESCR) # 4个特征,150个样本  每个类别有50个  3个类别
# print(Iris.data) #输入数据
# print(Iris.target) #输出数据
#将数据整合在一起
data = pd.DataFrame(Iris.data,
                    columns=Iris.feature_names)
data['target'] = Iris.target
#绘制数据的散点图
# #花瓣
# data.plot.scatter(x='petal length (cm)',y='petal width (cm)',
#                   c='target',cmap='brg',s=50)
# #萼片
# data.plot.scatter(x='sepal length (cm)',y='sepal width (cm)',
#                   c='target',cmap='brg',s=50)

# plt.show()
#拿到1类别和2类别
sub_data = data.tail(100)
# print(sub_data)
#逻辑函数图像
# xs = np.linspace(-10,10,200)
# ys = 1 / (1+np.exp(-xs))
# plt.plot(xs,ys)
# plt.show()
# print(sub_data)
#整理输入集和输出集
x = sub_data.iloc[:,:-1]
y = sub_data['target']
#整理训练集和测试集
train_x,test_x,train_y,test_y = sm.train_test_split(x,
                                                    y,
                                                    test_size=0.1,
                                                    random_state=7)
#构建逻辑回归模型
model = lm.LogisticRegression()
model.fit(train_x,train_y)
pred_test_y = model.predict(test_x)
# print(test_y.tolist()) #真实的类别
# print(pred_test_y.tolist())
#打印预测的准确率
print('准确率:',(pred_test_y==test_y).sum() / test_y.size)

决策树

import sklearn.tree as st
# 模型(回归Regressor、分类Classifier)
model = st.DecisionTreeRegressor(max_depth=4)  # 决策树回归器
# 训练
model.fit(train_x, train_y)
# 预测
pre_test_y = model.predict(test_x)

性能度量

import sklearn.metrics as sm
#召回率
print("recall:", sm.recall_score(test_y,  # 真实值
					                                 pred_test_y,  # 预测值
					                                 average="macro"))  # 计算平均值，不考虑样本权重
# 查准率
print("precision:", sm.precision_score(test_y,  # 真实值
							                                       pred_test_y,  # 预测值
							                                       average="macro"))  # 计算平均值，不考虑样本权重
# F1得分
print("F1:", sm.f1_score(test_y, pred_test_y,average="macro"))

# 分类报告 （真实值，预测值）
print(sm.classification_report(y, pred_test_y))

# 计算并打印模型预测的混淆矩阵
print("\n Confusion Matrix:")
cm = sm.confusion_matrix(test_y, pred_test_y)
print(cm)

混淆矩阵

	A类别	B类别	C类别
A类别	3	1	1
B类别	0	4	2
C类别	0	0	7

混淆矩阵也称误差矩阵，是表示精度评价的一种标准格式，用n行n列的矩阵形式来表示。每一行（数量之和）表示一个真实类别的样本，每一列（数量之和）表示一个预测类别的样本。
根据混淆矩阵，查准率、召回率也可表示为：
查准率 = 主对角线上的值 / 该值所在列的和
召回率 = 主对角线上的值 / 该值所在行的和
例子：A类别=5（行），预测A类别=3（列）。
查准率=3/3，召回率=3/5
交叉验证

import sklearn.model_selection as ms
#做5次交叉验证
scores = ms.cross_val_score(model,  # 模型
										                            x,y,  # 数据-标签
										                            cv=5,  # 5次
										                            scoring='f1_weighted')  #  指定返回的指标（当前为：打印F1得分）

验证曲线（训练之前做）
先交叉验证，在绘制验证曲线评估模型。使用自定义的参数进行测试，用画图的方式来看好坏，决定参数。（一次只能验证一个参数）

import sklearn.model_selection as ms
import matplotlib.pyplot as plt
#使用验证曲线评估模型超参数n_estimators
params = np.arange(50,551,50)
train_score,test_score = ms.validation_curve(model,
															                                             x, #训练集输入
															                                             y,#训练集输出
															                                             'n_estimators', #模型参数（这是随机森林的弱模型数量，可使用其他的）
															                                             params,#参数列表
															                                             cv=5)#验证次数
mean_score = test_score.mean(axis=1)  # 计算行均值，因为交叉验证5次，求5次的均值
print(mean_score) #验证曲线5次交叉验证的结果
#绘制验证曲线
plt.grid(linestyle=':')
plt.plot(params,
         mean_score,
         'o-',  # 连点成线
         color='dodgerblue',
         label='n_ensamble')
plt.legend()
plt.show()

学习曲线（训练之前做）

import sklearn.model_selection as ms
# 使用学习曲线,选取训练集和测试集的最优占比
params = np.arange(0.1,1.1,0.1)
_,train_score,test_score = ms.learning_curve(model,
															                                             x,
															                                             y,
															                                             train_sizes=params,
															                                             cv=5)
mean_score = test_score.mean(axis=1)
#学习曲线可视化
plt.grid(linestyle=':')
plt.plot(params,mean_score,'o-')
plt.xticks(params)
plt.show()

支持向量机

import sklearn.svm as svm
# 线性核函数支持向量机分类器
model = svm.SVC(kernel="linear")  # 线性核函数
model = svm.SVC(kernel="poly", degree=3)  # 多项式核函数

# 径向基核函数支持向量机分类器
model = svm.SVC(kernel="rbf",
                gamma=0.01, # 概率密度标准差
                C=600)  # 概率强度，该值越大对错误分类的容忍度越小，分类精度越高，但泛化能力越差；该值越小，对错误分类容忍度越大，但泛化能力强

网格搜索

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, 1000],
     "gamma": [1, 0.1, 0.01, 0.001]
     }
]
# 网格搜索
model = ms.GridSearchCV(svm.SVC(), params, cv=5)
model.fit(train_x,train_y)
pred_test_y = model.predict(test_x)
# print(sm.classification_report(test_y,pred_test_y))
print('最优的模型参数:',model.best_params_)
print('最优的得分:',model.best_score_)

实现朴素贝叶斯分类器

在sklearn中，提供了三个朴素贝叶斯分类器，分别是：

• GaussianNB（高斯朴素贝叶斯分类器）：适合用于样本的值是连续的，数据呈正态分布的情况（比如人的身高、城市家庭收入、一次考试的成绩等等）
• MultinominalNB（多项式朴素贝叶斯分类器）：适合用于大部分属性为离散值的数据集
• BernoulliNB（伯努利朴素贝叶斯分类器）：适合用于特征值为二元离散值或是稀疏的多元离散值的数据集

# 使用朴素贝叶斯实现样本分类
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import sklearn.model_selection as ms#模型选择
import sklearn.naive_bayes as nb #朴素贝叶斯
import sklearn.metrics as sm #评估
data = pd.read_csv('../data_test/multiple1.txt',
                   header=None,
                   names=['x1','x2','y'])
#整理输入集和输出集
x = data.iloc[:,:-1]
y = data['y']
#划分训练集和测试集
train_x,test_x,train_y,test_y = ms.train_test_split(x,
                                                    y,
                                                    test_size=0.2,
                                                    random_state=7,
                                                    stratify=y)
#构建模型
model = nb.GaussianNB()
#训练模型
model.fit(train_x,train_y)
#预测测试集结果
pred_test_y = model.predict(test_x)
#评估模型
print(sm.classification_report(test_y,pred_test_y))
#分类效果可视化
xs = np.linspace(data['x1'].min(),data['x1'].max(),100)
ys = np.linspace(data['x2'].min(),data['x2'].max(),100)
poins = []
for x in xs:
    for y in ys:
        poins.append([x,y])
#构建完成后,是二维列表,二维列表中的每一个一维列表是一组坐标(输入数据)
points = np.array(poins)
points_labels = model.predict(points)
#绘制分类边界
plt.scatter(points[:,0],points[:,1],c=points_labels,cmap='gray')
plt.scatter(test_x['x1'],test_x['x2'],c=test_y)
plt.show()

K均值聚类（k-means）

#聚类算法   K-means
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
#加载数据
data = pd.read_csv('../data_test/multiple3.txt', header=None)
# print(data)
# 查看一下散点图
plt.scatter(data[0],data[1])
# plt.show()
#Kmeans算法
import sklearn.cluster as sc
model = sc.KMeans(n_clusters=4)  # 分4类
model.fit(data)
labels = model.labels_ #聚类结果
print('聚类结果:',labels)
centers = model.cluster_centers_
print('聚类中心:',centers)
#需求: 将所有的样本按照划分出的类别标签进行散点图绘制,并绘制每个聚类的聚类中心
plt.scatter(data[0],data[1],c=labels,cmap='brg')
center_x = centers[:,0]
center_y = centers[:,-1]
plt.scatter(center_x,center_y,c='black',marker='+',s=500)
plt.show()

密度聚类-噪声密度（DBSCAN）

model = sc.DBSCAN(eps,   # 半径
	                  min_samples) # 最小样本数

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import sklearn.metrics as sm
#加载数据
data = pd.read_csv('../data_test/multiple3.txt',  header=None)
# print(data)
# 查看一下散点图
plt.scatter(data[0],data[1])
# plt.show()
#DBSCAN算法
import sklearn.cluster as sc
# model = sc.DBSCAN(eps=0.5,min_samples=5)
params = np.arange(0.5,1,0.1) #选取最好的半径
params_list = []
model_list = []
score_list = []
for i in params:
    model = sc.DBSCAN(eps=i,min_samples=5)
    model.fit(data)
    labels = model.labels_  # 聚类结果
    #轮廓系数,评估指标
    score = sm.silhouette_score(data,
                                labels,#噪声点,孤立样本,没有聚类类别,类别为-1
                                sample_size=len(data))
    model_list.append(model)
    score_list.append(score)
    params_list.append(i)

# 拿到最优秀的模型
best_ind = np.argmax(score_list)
print(model_list[best_ind])
print(params_list[best_ind])
print(score_list[best_ind])
# plt.scatter(data[0],data[1],c=labels,cmap='brg')
#
# plt.show()