标签：-- train print API test import model data sklearn
划分数据集
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()
标签：--,train,print,API,test,import,model,data,sklearn 来源： https://blog.csdn.net/qq_42102546/article/details/120181483
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。