机器学习实用代码汇总（你想要的这里都有）
机器学习实用代码汇总（你想要的这里都有）文章目录机器学习实用代码汇总（你想要的这里都有）前言一、数据导入1.数据文件读取2.提取特征和标签二、数据预处理1.数据的无量纲化2.缺失值处理3.处理分类型特征：编码与哑变量4.处理连续型特征：二值化与分段总结前言这里记录了自己在学习和实践中，记录下来的常用代码块。非常适合小白来学习和实践，在实践过程中找到你想要的某些功能，不断的复制粘贴就可以，有助于你早
机器学习实用代码汇总（你想要的这里都有）
文章目录
前言
这里记录了自己在学习和实践中， 记录下来的常用代码块。非常适合小白来学习和实践，在实践过程中找到你想要的某些功能，不断的复制粘贴就可以，有助于你早日成为CV工程师。
（后面会慢慢完善BP、CNN、RNN、LSTM、GRU、Transorformer、BERT、GAN、YOLOV、Q-learning、QMIX、MAPPO等网络结构结合任务场景的快速使用）
一、数据导入
1.数据文件读取
代码如下（示例）：
#读取CSV文件
import pandas as pd
str="文件路径"#您可以右键您的文件来复制路径
data = pd.read_csv(str,header=None)#str：要打开的文件路径，header=：布尔类型，等于None时，可以自己给特征和标签取名字。names=：列表类型，传入你想给特征和标签取的名字。
#读取TXT文件
#按行读取，放入列表即可
data = []
for line in open("文件路径","r"): #设置文件对象并读取每一行文件
data.append(line) #将每一行文件加入到list中
2.提取特征和标签
代码如下（示例）：
#X为你要取的特征，y为你要取的标签
X=data.iloc[a:b,m:n]#a,b为你要取a-1行到b-1行的数据。m,n为你要取第m-1列到n-1列的数据。
y=data.iloc[:,-1]#一般标签在最后一列
3.数据分布及关系图（ProfileReport）
用于数据分析报告，可以查看相关性，样本分布关系等
代码如下（示例）：
import seaborn as sns
import pandas as pd
import pandas_profiling as pp
import matplotlib.pyplot as plt
data=pd.read_csv("data.csv")
report = pp.ProfileReport(data)
report
二、数据预处理
1.数据的查看、去重、异常值删除
代码如下（示例）：
#查看部分数据
print(data.head(m))#m为多少条数据
#描述性统计
print(data.describe([0.01,0.1,0.25,.5,.75,.9,.99]).T)#查看数据大致分布
#查看数据基本信息
print(data.info())
#查看数据数量统计信息
for cate in sample.columns:#sample为你导入的数据样本
print(sample[cate].value_counts())
#查看每个特征与标签的分布关系
m,n=sample.shape()#这里查看所有样本和每一个特征，如果想查看个别特征修改循环值就行，想查看部分样本，直接修改m。
for i in range(0,n-1):
X_=np.arange(m)
y_=pd.DataFrame(sample.iloc[0:m,i])
z_=sample.iloc[0:m,0]
plt.scatter(X_,y_,c=z_)
plt.xlabel("sample")
plt.ylabel("feature")
plt.show()
数据去重
#按某些列去重、raw_data为你的数据集
reviews=raw_data.copy()
reviews=reviews[['content', 'content_type']]#选取你要去重的列
reviews=reviews.drop_duplicates()
#数据整体去除重复值
data.drop_duplicates(inplace=True)#inplace=True表示替换原数据
#删除之后千万不要忘记，恢复索引
data.index = range(data.shape[0])
#按照索引为subset列去重
data=data.drop_duplicates(subset=1, ignore_index=True, inplace=True)
箱线图公式处理异常值：删除需谨慎，除非是根据先验知道数据确实异常，否则随意删除很容易改变数据分布。并且只能对训练集删除，测试集不能删。
def outliers_proc(data, col_name, scale=1.5):
"""
用于清洗异常值，默认用 box_plot（scale=1.5）进行清洗（scale=1.5表示异常值，scale=3表示极端值）
:param scale: 尺度
"""
def box_plot_outliers(data_ser, box_scale):
"""
利用箱线图去除异常值
:param data_ser: 接收 pandas.Series 数据格式
:param box_scale: 箱线图尺度，
:return:
"""
iqr = box_scale * (data_ser.quantile(0.75) - data_ser.quantile(0.25))
val_low = data_ser.quantile(0.25) - iqr
print('val_low:',val_low)
val_up = data_ser.quantile(0.75) + iqr
print('val_up:',val_up)
rule_low = (data_ser < val_low) # 下离群点
rule_up = (data_ser > val_up) # 上离群点
return (rule_low, rule_up), (val_low, val_up)
data_n = data.copy()
data_series = data_n[col_name]
rule, value = box_plot_outliers(data_series, box_scale=scale)
index = np.arange(data_series.shape[0])[rule[0] | rule[1]]
print("Delete number is: {}".format(len(index)))
data_n = data_n.drop(index)
data_n.reset_index(drop=True, inplace=True)
print("Now row number is: {}".format(data_n.shape[0]))
index_low = np.arange(data_series.shape[0])[rule[0]]
outliers = data_series.iloc[index_low]
print('\n',"Description of data less than the lower bound is:")
print(pd.Series(outliers).describe())
index_up = np.arange(data_series.shape[0])[rule[1]]
outliers = data_series.iloc[index_up]
print('\n',"Description of data larger than the upper bound is:")
print(pd.Series(outliers).describe())
fig, ax = plt.subplots(1, 2, figsize=(10, 7))
sns.boxplot(y=data[col_name], data=data, palette="Set3", ax=ax[0])
sns.boxplot(y=data_n[col_name], data=data_n, palette="Set3", ax=ax[1])
return data_n
2.数据的无量纲化
无量纲化可以帮我们提升模型精度，避免某一个取值范围特别大的特征对距离计算造成影响。（一个特例是决策树和树的集成算法们，对决策树我们不需要无量纲化，决策树可以把任意数据都处理得很好。）
常用的数据无量纲化代码有数据归一化和数据标准化。大多数机器学习算法中，会选择数据标准化来进行特征缩放，因为数据标准化对异常值非常敏感。在PCA，聚类，逻辑回归，支持向量机，神经网络这些算法中，数据标准化往往是最好的选择。数据归一化在不涉及距离度量、梯度、协方差计算以及数据需要被压缩到特定区间时使用广泛，比如数字图像处理中量化像素强度时，都会使用数据归一化将数据压缩于[0,1]区间之中。
代码如下（示例）：
数据归一化
#数据归一化
from sklearn.preprocessing import MinMaxScaler
#实现归一化
scaler = MinMaxScaler() #实例化
result = scaler.fit_transform(data) #训练和导出结果一步达成
data=scaler.inverse_transform(result) #将归一化后的结果逆转
数据标准化
#数据标准化
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler() #实例化
x_std =scaler.fit_transform(data) #训练和导出结果一步达成
data=scaler.inverse_transform(x_std) #使用标准化后的结果逆转
数据归一化和标准化接口汇总
3.缺失值处理
代码如下（示例）：
用均值、中位数、特定值来填补缺失值
#常用的sklearn内置填补缺失值方法
from sklearn.impute import SimpleImputer
#以特征age为例子
Age=X["age"]#取出你要填补的特征
imp_mean = SimpleImputer() #实例化，默认均值填补
imp_mean = imp_mean.fit_transform(Age) #将缺失值用均值填补
imp_median = SimpleImputer(strategy="median") #用中位数填补
imp_median = imp_median.fit_transform(Age)
imp_0 = SimpleImputer(strategy="constant",fill_value=0) #用0填补
imp_0 = imp_0.fit_transform(Age)
X["age"]=imp_0#别忘记填补完进行特征更新
用随机森林算法来填补缺失值
#用随机森林算法来填补缺失值，仅供参考
from sklearn.ensemble import RandomForestRegressor
def RandomForestImputer(X_missing):#传入你要填补的特征，返回已经填补好的
X_missing_reg = X_missing.copy()
#找出数据集中，缺失值从小到大排列的特征们的顺序，并且有了这些的索引
sortindex = np.argsort(X_missing_reg.isnull().sum(axis=0)).values#np.argsort()返回的是从小到大排序的顺序所对应的索引
for i in sortindex:
#构建我们的新特征矩阵（没有被选中去填充的特征 + 原始的标签）和新标签（被选中去填充的特征）
df = X_missing_reg
fillc = df.iloc[:,i]#新标签
df = pd.concat([df.iloc[:,df.columns != i],pd.DataFrame(y_full)],axis=1)#新特征矩阵
#在新特征矩阵中，对含有缺失值的列，进行0的填补
df_0 =SimpleImputer(missing_values=np.nan,strategy='constant',fill_value=0).fit_transform(df)
#找出我们的训练集和测试集
Ytrain = fillc[fillc.notnull()]# Ytrain是被选中要填充的特征中（现在是我们的标签），存在的那些值：非空值
Ytest = fillc[fillc.isnull()]#Ytest 是被选中要填充的特征中（现在是我们的标签），不存在的那些值：空值。注意我们需要的不是Ytest的值，需要的是Ytest所带的索引
Xtrain = df_0[Ytrain.index,:]#在新特征矩阵上，被选出来的要填充的特征的非空值所对应的记录
Xtest = df_0[Ytest.index,:]#在新特征矩阵上，被选出来的要填充的特征的空值所对应的记录
#用随机森林回归来填补缺失值
rfc = RandomForestRegressor(n_estimators=100)#实例化
rfc = rfc.fit(Xtrain, Ytrain)#导入训练集进行训练
Ypredict = rfc.predict(Xtest)#用predict接口将Xtest导入，得到我们的预测结果（回归结果），就是我们要用来填补空值的这些值
#将填补好的特征返回到我们的原始的特征矩阵中
X_missing_reg.loc[X_missing_reg.iloc[:,i].isnull(),i] = Ypredict
return X_missing_reg
4.处理分类型特征：编码与哑变量
在现实中，许多标签和特征在数据收集完毕的时候，都不是以数字来表现的。比如说，学历的取值可以是[“小 学”，“初中”，“高中”，“大学”]，付费方式可能包含[“支付宝”，“现金”，“微信”]等等。在这种情况下，为了让数据适应算法和库，我们必须将数据进行编码，即是说，将文字型数据转换为数值型。
代码如下（示例）：
对标签进行编码
#对标签进行编码
from sklearn.preprocessing import LabelEncoder
y = data.iloc[:,-1] #要输入的是标签，不是特征矩阵，所以允许一维
le = LabelEncoder() #实例化
lable=le.fit_transform(y) #也可以直接fit_transform一步到位
data.iloc[:,-1]=lable
le.inverse_transform(label) #使用inverse_transform可以逆转
#如果不需要教学展示的话我会这么写：
from sklearn.preprocessing import LabelEncoder
data.iloc[:,-1] = LabelEncoder().fit_transform(data.iloc[:,-1])
对特征进行编码
#对特征进行编码
from sklearn.preprocessing import OrdinalEncoder
#这个接口可以一次性对多个特征进行编码，如下是对第一行到倒数第二行的所有特征进行编码
data_ = data.copy()#复制一份数据
data_.iloc[:,1:-1] = OrdinalEncoder().fit_transform(data_.iloc[:,1:-1])#进行编码
独热编码（哑变量）
1、能够处理非连续型数值特征。
2、在一定程度上也扩充了特征。
#对特征进行哑变量
from sklearn.preprocessing import OneHotEncoder
X = data.iloc[:,1:-1]#这里取出你想进行哑变量的特征
enc = OneHotEncoder(categories='auto').fit(X)
result = enc.transform(X).toarray()
#依然可以直接一步到位，但为了给大家展示模型属性，所以还是写成了三步
result=OneHotEncoder(categories='auto').fit_transform(X).toarray()
5.处理连续型特征：二值化与分段
代码如下（示例）：
二值化
#二值化、根据阈值将数据二值化（将特征值设置为0或1），用于处理连续型变量
from sklearn.preprocessing import Binarizer
X = data_2.iloc[:,0].values.reshape(-1,1) #选出你想二值化的特征，类为特征专用，所以不能使用一维数组
transformer = Binarizer(threshold=30).fit_transform(X)#进行二值化转化
多值化
#分段、将连续型变量划分为分类变量的类，能够将连续型变量排序后按顺序分箱后编码。
from sklearn.preprocessing import KBinsDiscretizer
X = data.iloc[:,0].values.reshape(-1,1)
est = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='uniform')#分成三段，进行等宽分箱，具体可以看下面参数。
est.fit_transform(X)
6.数据集制造
代码如下（示例）：
#用于制造学习来用的分类数据集
def tensorGenCla(num_examples=500, num_inputs=2, num_class=3, deg_dispersion=[4, 2], bias=False):
"""分类数据集创建函数。
:param num_examples: 每个类别的数据数量
:param num_inputs: 数据集特征数量
:param num_class：数据集标签类别总数
:param deg_dispersion：数据分布离散程度参数，需要输入一个列表，其中第一个参数表示每个类别数组均值的参考、第二个参数表示随机数组标准差。
:param bias：建立模型逻辑回归模型时是否带入截距
:return: 生成的特征张量和标签张量，其中特征张量是浮点型二维数组，标签张量是长正型二维数组。
"""
cluster_l = torch.empty(num_examples, 1) # 每一类标签张量的形状
mean_ = deg_dispersion[0] # 每一类特征张量的均值的参考值
std_ = deg_dispersion[1] # 每一类特征张量的方差
lf = [] # 用于存储每一类特征张量的列表容器
ll = [] # 用于存储每一类标签张量的列表容器
k = mean_ * (num_class - 1) / 2 # 每一类特征张量均值的惩罚因子（视频中部分是+1，实际应该是-1）
for i in range(num_class):
data_temp = torch.normal(i * mean_ - k, std_, size=(num_examples, num_inputs)) # 生成每一类张量
lf.append(data_temp) # 将每一类张量添加到lf中
labels_temp = torch.full_like(cluster_l, i) # 生成类一类的标签
ll.append(labels_temp) # 将每一类标签添加到ll中
features = torch.cat(lf).float()
labels = torch.cat(ll).long()
if bias == True:
features = torch.cat((features, torch.ones(len(features), 1)), 1) # 在特征张量中添加一列全是1的列
return features, labels
x,y=tensorGenCla(num_examples=100,num_inputs=19,num_class=3)#制造100个特征为19，有3分类的数据集
7.样本不均衡处理
过采样（over-sampling）：通过增加分类中少数类样本的数量来实现样本均衡，比较好的方法有SMOTE算法。
import pandas as pd
from imblearn.over_sampling import SMOTE #过度抽样处理库SMOTE
df=pd.read_table('data.txt')
x=df.iloc[:,:-1]#取出特征
y=df.iloc[:,-1]#取出标签
groupby_data_orginal=df.groupby('label').count() #根据标签label分类汇总
model_smote=SMOTE() #建立smote模型对象
x_smote_resampled,y_smote_resampled=model_smote.fit_resample(x,y)#进行过采样
smote_resampled=pd.concat([pd.DataFrame(x_smote_resampled),pd.DataFrame(y_smote_resampled)],axis=1)#合并，得到过采样的数据集
groupby_data_smote=smote_resampled.groupby('label').count()#再次统计分类汇总
欠采样（under-sampling）：通过减少分类中多数类样本的数量来实现样本均衡
import pandas as pd
from imblearn.under_sampling import RandomUnderSampler
model_RandomUnderSampler=RandomUnderSampler() #建立RandomUnderSample模型对象
x_RandomUnderSample_resampled,y_RandomUnderSample_resampled=model_RandomUnderSampler.fit_resample(x,y) #进行欠采样
RandomUnderSampler_resampled=pd.concat([pd.DataFrame(x_RandomUnderSample_resampled),pd.DataFrame(y_RandomUnderSample_resampled)],axis=1)#合并，得到欠采样的数据集
8.训练集、测试集划分
from sklearn.model_selection import train_test_split
#导入你要分的数据特征X，标签Y
Xtrain, Xtest, Ytrain, Ytest = train_test_split(X,Y,test_size=0.3,random_state=420)
三、特征选择
特征工程主要包括特征提取、特征创造和特征选择。特征提取针对不同的数据有不同的方法，例如，从文字，图像，声音等其他非结构化数据中提取新信息作为特征。比如说，从淘宝宝贝的名称中提取出产品类别、产品颜色，是否是网红产品等等。往往特征提取是科研中的重要一环节，这个后面单独写文章来总结。特征创造是把现有特征进行组合，或互相计算，得到新的特征。比如说，我们有一列特征是速度，一列特征是距离，我们就可以通过让两列相处，创造新的特征：通过距离所花的时间。特征创造 在机器学习竞赛中用的较多，后面单独写文章来讲解。特征选择是从所有的特征中，选择出有意义，对模型有帮助的特征，以避免必须将所有特征都导入模型去训练的情况
1.Filter过滤法
通常来说，我会建议，先使用方差过滤，然后使用互信息法来捕捉相关性，不过了解各种各样的过滤方式也是必要的。
代码如下（示例）：
方差过滤：根据特征的方差大小，设置阈值来过滤
#方差过滤、根据特征的方差大小，设置阈值来过滤
from sklearn.feature_selection import VarianceThreshold
selector = VarianceThreshold() #实例化，不填参数默认方差为0
X_var0 = selector.fit_transform(X) #获取删除不合格特征之后的新特征矩阵
X = VairanceThreshold().fit_transform(X)#也可以直接写成这样，一步到位
X_fsvar = VarianceThreshold(np.median(X.var().values)).fit_transform(X)#用特征方中位数为阈值过滤
卡方过滤：卡方检验类feature_selection.chi2计算每个非负特征和标签之间的卡方统计量(特征和标签的相关性)，并依照卡方统计量由高到低为特征排名
#卡方过滤，卡方检验类feature_selection.chi2计算每个非负特征和标签之间的卡方统计量(特征和标签的相关性)，并依照卡方统计量由高到低为特征排名
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
#假设在这里我一直我需要300个特征
X_fschi = SelectKBest(chi2, k=300).fit_transform(X, y)
互信息法：互信息法是用来捕捉每个特征与标签之间的任意关系（包括线性和非线性关系）的过滤方法
#互信息法，互信息法是用来捕捉每个特征与标签之间的任意关系（包括线性和非线性关系）的过滤方法
from sklearn.feature_selection import mutual_info_classif as MIC
result = MIC(X_fsvar,y)
k = result.shape[0] - sum(result <= 0)
2.Embedded嵌入法
嵌入法是一种让算法自己决定使用哪些特征的方法，即特征选择和算法训练同时进行。在使用嵌入法时，我们先使用某些机器学习的算法和模型进行训练，得到各个特征的权值系数，根据权值系数从大到小选择特征。这些权值系数往往代表了特征对于模型的某种贡献或某种重要性.
代码如下（示例）：
#通过设置模型重要程度阈值来筛选特征
from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import RandomForestClassifier as RFC
RFC_ = RFC(n_estimators =10,random_state=0)#利用随机森林来筛选特征
X_embedded = SelectFromModel(RFC_,threshold=0.05).fit_transform(X,y)
#这里设置贡献度为0.05作为阈值，这个阈值跟你的特征数量有关，正常情况下我们会通过学习曲线来确定阈值。
#RFC_.feature_importances_用来查看特征重要程度
#我们也可以画学习曲线来找最佳阈值
import numpy as np
import matplotlib.pyplot as plt
RFC_.fit(X,y).feature_importances_
threshold = np.linspace(0,(RFC_.fit(X,y).feature_importances_).max(),20)
score = []
for i in threshold:
X_embedded = SelectFromModel(RFC_,threshold=i).fit_transform(X,y)
once = cross_val_score(RFC_,X_embedded,y,cv=5).mean()
score.append(once)
plt.plot(threshold,score)
plt.show()
3. Wrapper包装法
包装法也是一个特征选择和算法训练同时进行的方法，与嵌入法十分相似，它也是依赖于算法自身的选择，比如coef_属性或者特征重要性来完成特征选择。但不同的是，我们往往使用一个目标函数作为黑盒来帮助我们选取特征，而不是自己输入某个评估指标或统计量的阈值。
代码如下（示例）：
from sklearn.feature_selection import RFE
RFC_ = RFC(n_estimators =10,random_state=0)
selector = RFE(RFC_, n_features_to_select=340, step=50).fit(X, y)
#n_features_to_select是想要选择的特征个数，step表示每次迭代中希望移除的特征个数。
X_wrapper = selector.transform(X)
#包装法学习曲线，来确定最佳参数
score = []
for i in range(1,751,50):
X_wrapper = RFE(RFC_,n_features_to_select=i, step=50).fit_transform(X,y)
once = cross_val_score(RFC_,X_wrapper,y,cv=5).mean()
score.append(once)
plt.figure(figsize=[20,5])
plt.plot(range(1,751,50),score)
plt.xticks(range(1,751,50))
plt.show()
4.PCA与LDA降维
降维算法不能简单的称为特征选择，它能减少特征的数量，又保留大部分有效信息，可以简单理解成一种特征压缩的手段，其本质是对矩阵的分解。
代码如下（示例）：
#PCA降维
from sklearn.decomposition import PCA
X_dr = PCA(2).fit_transform(X)#输入你要降到的维度数量，这里为2
#如果你不确定你的超参数，你可以用最大似然估计来选取你要压缩到的维度，当然你也可以绘制学习曲线来确定你的参数
pca_mle = PCA(n_components="mle")
X_mle = pca_mle.fit_transform(X)
#LDA降维
from sklearn.lda import LDA
#参数n_components为降维后的维数
X=LDA(n_components=2).fit_transform(X, y)
5.特征选择经验技巧
1.经验来说，过滤法更快速，但更粗糙。
2.包装法和嵌入法更精确，比较适合具体到算法去调整，但计算量比较大，运行时间长。
3.当数据量很大的时候，优先使用方差过滤和互信息法调整，再上其他特征选择方法。
4.使用逻辑回归时，优先使用嵌入法。使用支持向量机时，优先使用包装法。迷茫的时候，从过滤法走起，看具体数据具体分析。
5.其实特征选择只是特征工程中的第一步。真正的高手，往往使用特征创造或特征提取来寻找高级特征。在Kaggle之类的算法竞赛中，很多高分团队都是在高级特征上做文章，而这是比调参和特征选择更难的，提升算法表现的高深方法。特征工程非常深奥，虽然我们日常可能用到不多，但其实它非常美妙。若大家感兴趣，也可以自己去网上搜一搜，多读多看多试多想，技术逐渐会成为你的囊中之物。
四、模型搭建及优化
1.模型评估
建模的评估一般可以分为回归、分类和聚类的评估。
1.1回归模型评估(平均绝对误差、平均方差、R平方值)
代码如下（示例）：
#sklearn的调用，回归常用评估函数，输入测试标签、模型预测标签
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_squared_error
from sklearn.metrics import r2_score
mean_absolute_error(y_test,y_predict)#平均绝对误差
mean_squared_error(y_test,y_predict)#平均方差
r2_score(y_test,y_predict)#R平方值
1.2分类模型评估(分类报告、混淆矩阵、ROC曲线、交叉验证)
代码如下（示例）：
分类报告
#sklearn的调用，分类常用评估函数，输入你的测试集
#分类报告：输出包括了precision/recall/fi-score/均值/分类个数
from sklearn.metrics import classification_report
y_true = y_test #测试集标签
y_pred = model.predict(x_test)#测试集预测值
target_names = ['class 0', 'class 1', 'class 2']#写入你标签的类别名，有几个就写几个
print(classification_report(y_true, y_pred, target_names=target_names))
混淆矩阵
#sklearn的调用，混淆矩阵 输入你的测试集
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
y_true = y_test #测试集标签
y_pred = model.predict(x_test)#测试集预测值
confusion_mat = confusion_matrix(y_true, y_pred)
print(confusion_mat) #看看混淆矩阵长啥样
#sklearn的调用，混淆矩阵可视化
def plot_confusion_matrix(confusion_mat):
'''''将混淆矩阵画图并显示出来'''
plt.imshow(confusion_mat, interpolation='nearest', cmap=plt.cm.gray)
plt.title('Confusion matrix')
plt.colorbar()
tick_marks = np.arange(confusion_mat.shape[0])
plt.xticks(tick_marks, tick_marks)
plt.yticks(tick_marks, tick_marks)
plt.ylabel('True label')
plt.xlabel('Predicted label')
plt.show()
plot_confusion_matrix(confusion_mat)
ROC曲线
#sklearn的调用，绘制ROC曲线，AUC就是ROC 曲线下的面积，通常情况下数值介于0.5-1之间，可以评价分类器的好坏，数值越大说明越好。
from sklearn.metrics import roc_curve as ROC
import matplotlib.pyplot as plt
#导入模型，测试集
def roc_auc_score_plot(clf,Xtest，Ytest):
FPR, Recall, thresholds = ROC(Ytest,clf.decision_function(Xtest),pos_label=1)
area = roc_auc_score(Ytest,clf.decision_function(Xtest))#计算auc的值
plt.figure()
plt.plot(FPR, Recall, color='red',
label='ROC curve (area = %0.2f)' % area)
plt.plot([0, 1], [0, 1], color='black', linestyle='--')
plt.xlim([-0.05, 1.05])
plt.ylim([-0.05, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('Recall')
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()
交叉验证
from sklearn.model_selection import cross_val_score
scores = cross_val_score(model,X, y,cv=3)#cv：默认是3折交叉验证，可以修改cv=5，变成5折交叉验证
1.3聚类模型评估(ARI、轮廓系数)
代码如下（示例）：
ARI：取值范围为[-1,1]，负数代表结果不好，值越大意味着聚类结果与真实情况越吻合。ARI可用于聚类算法之间的比较
#ARI接口
from sklearn import metrics
labels_true = [0,0,0,1,1,1]#真实标签
labels_pred = [0,0,1,1,2,2]#预测标签
print(metrics.adjusted_rand_score(labels_true,labels_pred))
轮廓系数：用于没有基准可用时的聚类质量评估，通过考察簇的分离情况和簇的紧凑度进行聚类评估。轮廓系数的值在-1到1之间，轮廓系数越接近于1，聚类效果越好。
#一个求轮廓系数的案例
import numpy as np
from sklearn.cluster import KMeans
from sklearn import metrics
from sklearn.metrics import silhouette_score
from sklearn.datasets import load_iris # 导入数据集iris
X = load_iris().data # 载入数据集
kmeans_model = KMeans(n_clusters=3,random_state=1).fit(X)
labels = kmeans_model.labels_
metrics.silhouette_score(X,labels,metric='euclidean')#得到轮廓系数
2.机器学习常用回归模型
2.1 线性回归
代码如下（示例）：
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
lin_reg = LinearRegression(fit_intercept=True, normalize=False, copy_X=True, n_jobs=None)
lin_reg.fit(X_train,y_train)#传入训练数据
print ('线性回归模型的均方误差为：',mean_squared_error(lin_reg.inverse_transform(y_test),lin_reg.inverse_tranform(lr_y_predict)))#均方误差，看模型效果
2.2 决策树回归
代码如下（示例）：
%matplotlib inline
from sklearn import tree
clf = tree.DecisionTreeRegressor()
clf = clf.fit(X_train,y_train)
参数说明
1、 criterion：特征选取方法，mse或mae，前者是均方差，后者是和均值的差的绝对值之和，一般用前者，因为前者通常更为精准，且方便计算
2、 splitter: 特征划分点选择方法，可以是best或random，前者是在特征的全部划分点中找到最优的划分点，后者是在随机选择的部分划分点找到局部最优的划分点，一般在样本量不大的时候，选择best，样本量过大，可以用random
3、 max_depth: 树的最大深度，默认可以不输入，那么不会限制子树的深度，一般在样本少特征也少的情况下，可以不做限制，但是样本过多或者特征过多的情况下，可以设定一个上限，一般取10~100
4、 min_samples_split:节点再划分所需最少样本数，如果节点上的样本树已经低于这个值，则不会再寻找最优的划分点进行划分，且以结点作为叶子节点，默认是2，如果样本过多的情况下，可以设定一个阈值，具体可根据业务需求和数据量来定
5、 min_samples_leaf: 叶子节点所需最少样本数，如果达不到这个阈值，则同一父节点的所有叶子节点均被剪枝，这是一个防止过拟合的参数，可以输入一个具体的值，或小于1的数（会根据样本量计算百分比）
6、 min_weight_fraction_leaf: 叶子节点所有样本权重和，如果低于阈值，则会和兄弟节点一起被剪枝，默认是0，就是不考虑权重问题。这个一般在样本类别偏差较大或有较多缺失值的情况下会考虑
7、 max_features: 划分考虑最大特征数，不输入则默认全部特征，可以选 log2N,sqrt(N),auto或者是小于1的浮点数（百分比）或整数（具体数量的特征）。如果特征特别多时如大于50，可以考虑选择auto来控制决策树的生成时间
8、 max_leaf_nodes:最大叶子节点数，防止过拟合，默认不限制，如果设定了阈值，那么会在阈值范围内得到最优的决策树，样本量过多时可以设定
9、min_impurity_decrease/min_impurity_split: 划分最需最小不纯度，前者是特征选择时低于就不考虑这个特征，后者是如果选取的最优特征划分后达不到这个阈值，则不再划分，节点变成叶子节点
10、presort: 是否排序，基本不用管
2.3 支持向量机回归
代码如下（示例）：
from sklearn.svm import LinearSVC
svm_clf=LinearSVC()
svm_clf.fit(X_train,y_train)
2.4 K近邻回归
代码如下（示例）：
from sklearn import neighbors
model_KNeighborsRegressor = neighbors.KNeighborsRegressor()
model_KNeighborsRegressor.fit(X_train,y_train)
2.5 随机森林回归
代码如下（示例）：
from sklearn import ensemble
model_RandomForestRegressor = ensemble.RandomForestRegressor(n_estimators=100)
model_RandomForestRegresso.fit(X_train,y_train)
重要参数
n_estimators：森林中基评估器的数量，即树的数量。n_estimators越大模型效果越好，但达到一定程度时，精确性趋于稳定。默认为100。
criterion：衡量标准。gini系数和信息熵2种。
max_depth:树的最大深度
mini_sample_leaf：min_samples_leaf=1,二叉树
mini_samples_split：mini_samples_split=2一个节点分成几类样本
max_features：树的特征个数
random_state ：随机种子，选42吧，宇宙终极奥秘。
2.6 Adaboost 回归
代码如下（示例）：
from sklearn import ensemble
model_AdaBoostRegressor = ensemble.AdaBoostRegressor(n_estimators=50)
model_AdaBoostRegressor.fit(X_train,y_train)
① criterion: 特征选取方法，分类是gini（基尼系数），entropy（信息增益），通常选择gini，即CART算法，如果选择后者，则是ID3和C4,.5；回归是mse或mae，前者是均方差，后者是和均值的差的绝对值之和，一般用前者，因为前者通常更为精准，且方便计算
② splitter: 特征划分点选择方法，可以是best或random，前者是在特征的全部划分点中找到最优的划分点，后者是在随机选择的部分划分点找到局部最优的划分点，一般在样本量不大的时候，选择best，样本量过大，可以用random
③ max_depth: 树的最大深度，默认可以不输入，那么不会限制子树的深度，一般在样本少特征也少的情况下，可以不做限制，但是样本过多或者特征过多的情况下，可以设定一个上限，一般取10~100
④ min_samples_split:节点再划分所需最少样本数，如果节点上的样本树已经低于这个值，则不会再寻找最优的划分点进行划分，且以结点作为叶子节点，默认是2，如果样本过多的情况下，可以设定一个阈值，具体可根据业务需求和数据量来定
⑤ min_samples_leaf: 叶子节点所需最少样本数，如果达不到这个阈值，则同一父节点的所有叶子节点均被剪枝，这是一个防止过拟合的参数，可以输入一个具体的值，或小于1的数（会根据样本量计算百分比）
⑥ min_weight_fraction_leaf: 叶子节点所有样本权重和，如果低于阈值，则会和兄弟节点一起被剪枝，默认是0，就是不考虑权重问题。这个一般在样本类别偏差较大或有较多缺失值的情况下会考虑
⑦ max_features: 划分考虑最大特征数，不输入则默认全部特征，可以选 log2N,sqrt(N),auto或者是小于1的浮点数（百分比）或整数（具体数量的特征）。如果特征特别多时如大于50，可以考虑选择auto来控制决策树的生成时间
⑧ max_leaf_nodes:最大叶子节点数，防止过拟合，默认不限制，如果设定了阈值，那么会在阈值范围内得到最优的决策树，样本量过多时可以设定
⑨min_impurity_decrease/min_impurity_split: 划分最需最小不纯度，前者是特征选择时低于就不考虑这个特征，后者是如果选取的最优特征划分后达不到这个阈值，则不再划分，节点变成叶子节点
2.7 梯度增强随机森林回归
代码如下（示例）：
from sklearn import ensemble
model_GradientBoostingRegressor = ensemble.GradientBoostingRegressor(n_estimators=100)
model_GradientBoostingRegressor.fit(X_train,y_train)
参数参考随机森林
2.8 Bagging 回归
代码如下（示例）：
from sklearn.ensemble import BaggingRegressor
model_BaggingRegressor = BaggingRegressor()
model_BaggingRegressor.fit(X_train,y_train)
重要参数
base_estimator：Object or None。None代表默认是DecisionTree，Object可以指定基估计器（base estimator）。
n_estimators：int, optional (default=10) 。 要集成的基估计器的个数。
max_samples： int or float, optional (default=1.0)。决定从x_train抽取去训练基估计器的样本数量。int 代表抽取数量，float代表抽取比例
max_features : int or float, optional (default=1.0)。决定从x_train抽取去训练基估计器的特征数量。int 代表抽取数量，float代表抽取比例
bootstrap : boolean, optional (default=True) 决定样本子集的抽样方式（有放回和不放回）
bootstrap_features : boolean, optional (default=False)决定特征子集的抽样方式（有放回和不放回）
oob_score : bool 决定是否使用包外估计（out of bag estimate）泛化误差
warm_start : bool, optional (default=False) true代表
n_jobs : int, optional (default=1)
random_state : 选42吧，宇宙终极奥秘。
2.9 ExtraTree 回归
代码如下（示例）：
from sklearn.tree import ExtraTreeRegressor
model_ExtraTreeRegressor = ExtraTreeRegressor()
model_ExtraTreeRegressor.fit(X_train,y_train)
2.10 Xgboost回归
代码如下（示例）：
from xgboost.sklearn import XGBRegressor
gsearch1 = GridSearchCV(estimator=XGBRegressor(scoring='ls',seed=27), param_grid=param_grid, cv=5)
gsearch1.fit(X_train, y_train)
重要参数
n_estimators（基本学习器的数量）：要拟合的弱学习器数量，该值越大，模型越复杂，越容易过拟合
max_depth（基本学习器的深度）： 树的最大深度，该值越大，模型越复杂，越容易拟合训练数据，越容易过拟合;树生长停止条件之一
learning_rate（学习率）：每个基模型的惩罚项，降低单个模型的影响，为了防止过拟合，该值越接近1越容易或拟合，越接近0精度越低
gamma（损失减少阈值）：在树的叶节点上进一步划分所需的最小损失减少，在模型训练过程中，只有损失下降的值超过该值，才会继续分裂节点，该值越小模型越复杂，越容易过拟合,树生长停止条件之一
reg_alpha（L1正则化）：L1正则化用于对叶子的个数进行惩罚,用于防止过拟合
reg_lambda（L2正则化）：L2正则化用于对叶子节点的得分进行惩罚，L1和L2正则化项共同惩罚树的复杂度,值越小模型的鲁棒性越高
min_child_weight（子集最小权重）：最小样本的权重之和，在树的生长过程中，如果样本的权重之和小于该值，将不再分裂；树生长停止条件之一
subsample（样本子采样）：训练集对样本实例的采样率,用于防止过拟合
colsample_bytree（列子采样）：每棵树对特征的采样率，用于防止过拟合
3.机器学习常用分类模型
3.1 决策树分类
代码如下（示例）：
from sklearn.tree import DecisionTreeClassifier as DTC
model=DTC(max_depth=8,random_state=42)
model.fit(X_train, y_train)
重要参数
1、 criterion: 特征选取方法，可以是gini（基尼系数），entropy（信息增益），通常选择gini，即CART算法，如果选择后者，则是ID3和C4,.5
2、 splitter: 特征划分点选择方法，可以是best或random，前者是在特征的全部划分点中找到最优的划分点，后者是在随机选择的部分划分点找到局部最优的划分点，一般在样本量不大的时候，选择best，样本量过大，可以用random
3、 max_depth: 树的最大深度，默认可以不输入，那么不会限制子树的深度，一般在样本少特征也少的情况下，可以不做限制，但是样本过多或者特征过多的情况下，可以设定一个上限，一般取10~100
4、 min_samples_split:节点再划分所需最少样本数，如果节点上的样本树已经低于这个值，则不会再寻找最优的划分点进行划分，且以结点作为叶子节点，默认是2，如果样本过多的情况下，可以设定一个阈值，具体可根据业务需求和数据量来定
5、 min_samples_leaf: 叶子节点所需最少样本数，如果达不到这个阈值，则同一父节点的所有叶子节点均被剪枝，这是一个防止过拟合的参数，可以输入一个具体的值，或小于1的数（会根据样本量计算百分比）
6、 min_weight_fraction_leaf: 叶子节点所有样本权重和，如果低于阈值，则会和兄弟节点一起被剪枝，默认是0，就是不考虑权重问题。这个一般在样本类别偏差较大或有较多缺失值的情况下会考虑
7、 max_features: 划分考虑最大特征数，不输入则默认全部特征，可以选 log2N,sqrt(N),auto或者是小于1的浮点数（百分比）或整数（具体数量的特征）。如果特征特别多时如大于50，可以考虑选择auto来控制决策树的生成时间
8、 max_leaf_nodes:最大叶子节点数，防止过拟合，默认不限制，如果设定了阈值，那么会在阈值范围内得到最优的决策树，样本量过多时可以设定
9、min_impurity_decrease/min_impurity_split: 划分最需最小不纯度，前者是特征选择时低于就不考虑这个特征，后者是如果选取的最优特征划分后达不到这个阈值，则不再划分，节点变成叶子节点
10、class_weight: 类别权重，在样本有较大缺失值或类别偏差较大时可选，防止决策树向类别过大的样本倾斜。可设定或者balanced，后者会自动根据样本的数量分布计算权重，样本数少则权重高，与min_weight_fraction_leaf对应
11、presort: 是否排序，基本不用管
3.2 随机森林分类
代码如下（示例）：
from sklearn.ensemble import RandomForestClassifier as RFC
model=RFC(n_estimators=100,random_state=42,n_jobs=8)
model.fit(X_train, y_train)
重要参数
n_estimators：森林中基评估器的数量，即树的数量。n_estimators越大模型效果越好，但达到一定程度时，精确性趋于稳定。默认为100。
criterion：衡量标准。gini系数和信息熵2种。
max_depth:树的最大深度
mini_sample_leaf：min_samples_leaf=1,二叉树
mini_samples_split：mini_samples_split=2一个节点分成几类样本
max_features：树的特征个数
random_state ：随机种子
3.3 Adaboost分类
代码如下（示例）：
from sklearn.ensemble import AdaBoostClassifier
model=AdaBoostClassifier_()
model.fit(X_train, y_train)
重要参数
base_estimator:基分类器，默认是决策树，在该分类器基础上进行boosting，理论上可以是任意一个分类器，但是如果是其他分类器时需要指明样本权重。
n_estimators:基分类器提升（循环）次数，默认是50次，这个值过大，模型容易过拟合；值过小，模型容易欠拟合。
learning_rate:学习率，表示梯度收敛速度，默认为1，如果过大，容易错过最优值，如果过小，则收敛速度会很慢；该值需要和n_estimators进行一个权衡，当分类器迭代次数较少时，学习率可以小一些，当迭代次数较多时，学习率可以适当放大。
algorithm:boosting算法，也就是模型提升准则，有两种方式SAMME, 和SAMME.R两种，默认是SAMME.R，两者的区别主要是弱学习器权重的度量，前者是对样本集预测错误的概率进行划分的，后者是对样本集的预测错误的比例，即错分率进行划分的，默认是用的SAMME.R。
random_state:随机种子设置。
3.4 GBDT分类
代码如下（示例）：
from sklearn.ensemble import GradientBoostingClassifier as GBDT
model=GBDT(n_estimators=100,random_state=1412)
model.fit(X_train, y_train)
重要参数
1) n_estimators: 也就是弱学习器的最大迭代次数，或者说最大的弱学习器的个数。一般来说n_estimators太小，容易欠拟合，n_estimators太大，又容易过拟合，一般选择一个适中的数值。默认是100。在实际调参的过程中，我们常常将n_estimators和下面介绍的参数learning_rate一起考虑。
2) learning_rate: 即每个弱学习器的权重缩减系数𝜈ν，也称作步长，在原理篇的正则化章节我们也讲到了，加上了正则化项，我们的强学习器的迭代公式为𝑓𝑘(𝑥)=𝑓𝑘−1(𝑥)+𝜈ℎ𝑘(𝑥)fk(x)=fk−1(x)+νhk(x)。𝜈ν的取值范围为0<𝜈≤10<ν≤1。对于同样的训练集拟合效果，较小的𝜈ν意味着我们需要更多的弱学习器的迭代次数。通常我们用步长和迭代最大次数一起来决定算法的拟合效果。所以这两个参数n_estimators和learning_rate要一起调参。一般来说，可以从一个小一点的𝜈ν开始调参，默认是1。
3) subsample: 即我们在原理篇的正则化章节讲到的子采样，取值为(0,1]。注意这里的子采样和随机森林不一样，随机森林使用的是放回抽样，而这里是不放回抽样。如果取值为1，则全部样本都使用，等于没有使用子采样。如果取值小于1，则只有一部分样本会去做GBDT的决策树拟合。选择小于1的比例可以减少方差，即防止过拟合，但是会增加样本拟合的偏差，因此取值不能太低。推荐在[0.5, 0.8]之间，默认是1.0，即不使用子采样。
4) init: 即我们的初始化的时候的弱学习器，拟合对应原理篇里面的𝑓0(𝑥)f0(x)，如果不输入，则用训练集样本来做样本集的初始化分类回归预测。否则用init参数提供的学习器做初始化分类回归预测。一般用在我们对数据有先验知识，或者之前做过一些拟合的时候，如果没有的话就不用管这个参数了。
5) loss: 即我们GBDT算法中的损失函数。分类模型和回归模型的损失函数是不一样的。
对于分类模型，有对数似然损失函数"deviance"和指数损失函数"exponential"两者输入选择。默认是对数似然损失函数"deviance"。在原理篇中对这些分类损失函数有详细的介绍。一般来说，推荐使用默认的"deviance"。它对二元分离和多元分类各自都有比较好的优化。而指数损失函数等于把我们带到了Adaboost算法。
对于回归模型，有均方差"ls", 绝对损失"lad", Huber损失"huber"和分位数损失“quantile”。默认是均方差"ls"。一般来说，如果数据的噪音点不多，用默认的均方差"ls"比较好。如果是噪音点较多，则推荐用抗噪音的损失函数"huber"。而如果我们需要对训练集进行分段预测的时候，则采用“quantile”。
6) alpha：这个参数只有GradientBoostingRegressor有，当我们使用Huber损失"huber"和分位数损失“quantile”时，需要指定分位数的值。默认是0.9，如果噪音点较多，可以适当降低这个分位数的值。
3.5 CatBoost分类
代码如下（示例）：
from catboost import Pool, CatBoostClassifier
train_data = [["summer", 1924, 44],
["summer", 1932, 37],
["winter", 1980, 37],
["summer", 2012, 204]]
eval_data = [["winter", 1996, 197],
["winter", 1968, 37],
["summer", 2002, 77],
["summer", 1948, 59]]
cat_features = [0]
train_label = ["France", "USA", "USA", "UK"]
eval_label = ["USA", "France", "USA", "UK"]
train_dataset = Pool(data=train_data,
label=train_label,
cat_features=cat_features)
eval_dataset = Pool(data=eval_data,
label=eval_label,
cat_features=cat_features)
# Initialize CatBoostClassifier
model = CatBoostClassifier(iterations=10,
learning_rate=1,
depth=2,
loss_function='MultiClass')
# Fit model
model.fit(train_dataset)
# Get predicted classes
preds_class = model.predict(eval_dataset)
# Get predicted probabilities for each class
preds_proba = model.predict_proba(eval_dataset)
# Get predicted RawFormulaVal
preds_raw = model.predict(eval_dataset,
prediction_type='RawFormulaVal')
重要参数
loss_function 损失函数，支持的有RMSE, Logloss, MAE, CrossEntropy, Quantile, LogLinQuantile, Multiclass, MultiClassOneVsAll, MAPE,Poisson。默认RMSE。
custom_metric 训练过程中输出的度量值。这些功能未经优化，仅出于信息目的显示。默认None。
eval_metric 用于过拟合检验（设置True）和最佳模型选择（设置True）的loss function，用于优化。
iterations 最大树数。默认1000。
learning_rate 学习率。默认0.03。
random_seed 训练时候的随机种子
l2_leaf_reg L2正则参数。默认3
bootstrap_type 定义权重计算逻辑，可选参数：Poisson (supported for GPU only)/Bayesian/Bernoulli/No，默认为Bayesian
bagging_temperature 贝叶斯套袋控制强度，区间[0, 1]。默认1。
subsample 设置样本率，当bootstrap_type为Poisson或Bernoulli时使用，默认66
sampling_frequency设置创建树时的采样频率，可选值PerTree/PerTreeLevel，默认为PerTreeLevel
random_strength 分数标准差乘数。默认1。
use_best_model 设置此参数时，需要提供测试数据，树的个数通过训练参数和优化loss function获得。默认False。
best_model_min_trees 最佳模型应该具有的树的最小数目。
depth 树深，最大16，建议在1到10之间。默认6。
ignored_features 忽略数据集中的某些特征。默认None。
one_hot_max_size 如果feature包含的不同值的数目超过了指定值，将feature转化为float。默认False
has_time 在将categorical features转化为numerical
nan_mode处理输入数据中缺失值的方法，包括Forbidden(禁止存在缺失)，Min(用最小值补)，Max(用最大值补)。默认Min。
fold_permutation_block_size数据集中的对象在随机排列之前按块分组。此参数定义块的大小。值越小，训练越慢。较大的值可能导致质量下降。
leaf_estimation_method 计算叶子值的方法，Newton/ Gradient。默认Gradient。
leaf_estimation_iterations 计算叶子值时梯度步数。
leaf_estimation_backtracking 在梯度下降期间要使用的回溯类型。
fold_len_multiplier folds长度系数。设置大于1的参数，在参数较小时获得最佳结果。默认2。
approx_on_full_history 计算近似值，False：使用1／fold_len_multiplier计算；True：使用fold中前面所有行计算。默认False。
class_weights 类别的权重。默认None。
scale_pos_weight 二进制分类中class 1的权重。该值用作class 1中对象权重的乘数。
allow_const_label 使用它为所有对象训练具有相同标签值的数据集的模型。默认为False
3.6 ExtraTress分类
代码如下（示例）：
from sklearn.ensemble import ExtraTreesClassifier
model = ExtraTreesClassifier(n_estimators=500,bootstrap=True,oob_score=True,random_state=666)
model.fit(X_train, y_train)
3.7 KNN分类
代码如下（示例）：
from sklearn.neighbors import KNeighborsClassifier as KNNC
model=KNNC(n_neighbors=10,n_jobs=8)
model.fit(X_train, y_train)
3.8 SVM分类
代码如下（示例）：
from sklearn.svm import SVC
model=SVC()
model.fit(X_train, y_train)
3.9 XGBoost分类
代码如下（示例）：
from xgboost.sklearn import XGBClassifier
model=XGBClassifier()
model.fit(X_train, y_train)
1. base_score:0.5
2. booster: ‘gbtree’ — 基分类器为树模型，默认值；‘gbliner’ — 基分类器为线性模型。
3. colsample_bylevel: 控制树的每一级的每一次分裂，对列数的采样比重，默认值为1.
4. colsample_bynode: 控制树的每一个节点的每一次分裂，对列数的采样比重，默认值为1.
5. colsample_bytree: 训练每棵树时，使用特征占全部特征的比例，默认值为1，典型值为0.5-1.调节该参数可以防止过拟合。
6. gamma: 惩罚项系数，制定节点斐裂所需的最小损失函数下降值，默认值为0。
7. learning_rate: 学习率，控制每次迭代更新权重时的步长，默认值为0.1。该参数可参考上篇AdaBoostClassifier。
8. max_delta_step: 限制每棵树权重改变的最大步长，默认值为0，即没有约束。如果为正值，则这个算法更加保守。通常不需要设置该参数，但是当样本十分不平衡时，对逻辑回归很有帮助。
9. max_depth: 树的深度，默认值是6，值过大容易过拟合，值过小容易欠拟合。该参数同AdaBoostClassifier和RandomForestClassifier的max_depth参数。
10. min_child_weight: 默认值为1，当值越大时，越容易欠拟合；当值越小时，越容易过拟合。
11. missing:
12. n_estimators: 基学习器的个数，默认值是100。该参数可参考上篇AdaBoostClassifier。
13. n_jobs: 有多少处理器可以使用。默认值为None，即1，即只有一个处理器可以使用，-1意味着没有限制。
14. objective: 目标函数。
回归：‘reg:linear’, ‘reg:logistic’;
二分类：‘binary:logistic’ 概率(默认值），'binary:logitraw’类别
多分类：multi:softmax num_class=n 返回类别，multi:softmax num_class=n 返回概率
rank:pairwise
15. random_state: 随机种子
16. reg_alpha: L1正则化，在高维度的情况下，调节该参数可以加快算法的速度。
17. reg_lambda: L2正则化，调节该参数可以减少过拟合，默认值为1.
18. scale_pos_weight: 正样本的权重，在二分类模型中，如果两个分类的样本比例失衡，可以设置该参数，模型效果会更好。比如，在研究疾病组和健康对照组分类时，postive：negative = 1:10，可以设置scale_pos_weight=10，来平衡样本。
19. seed: 随机数的种子，
20. silent: 默认值为=0，不输出中间过程；=1时，输出中间过程。
21. subsample: 训练每棵树时，子采样的样本比例，默认值为1，即全部样本用于训练。调节该参数可以防止过拟合。
3.10 朴素贝叶斯分类
代码如下（示例）：
from sklearn.naive_bayes import GaussianNB
model=GaussianNB()
model.fit(X_train, y_train)
重要参数
priors:先验概率大小，如果没有给定，模型则根据样本数据自己计算（利用极大似然法）
class_prior_:每个样本的概率
class_count:每个类别的样本数量
theta_:每个类别中每个特征的均值
sigma_:每个类别中每个特征的方差
alpha:先验平滑因子，默认等于1，当等于1时表示拉普拉斯平滑。
fit_prior:是否去学习类的先验概率，默认是True
class_prior:各个类别的先验概率，如果没有指定，则模型会根据数据自动学习， 每个类别的先验概率相同，等于类标记总个数N分之一。
3.11 LightGBM分类
代码如下（示例）：
# -*- coding: utf-8 -*-
# author: Yu Sun
import pandas as pd
import lightgbm as lgb
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
params = {
'task': 'train',
'boosting_type': 'gbdt', # GBDT算法为基础
'objective': 'binary', # 因为要完成预测用户是否买单行为，所以是binary，不买是0，购买是1
'metric': 'auc', # 评判指标
'max_bin': 255, # 大会有更准的效果,更慢的速度
'learning_rate': 0.1, # 学习率
'num_leaves': 64, # 大会更准,但可能过拟合
'max_depth': -1, # 小数据集下限制最大深度可防止过拟合,小于0表示无限制
'feature_fraction': 0.8, # 防止过拟合
'bagging_freq': 5, # 防止过拟合
'bagging_fraction': 0.8, # 防止过拟合
'min_data_in_leaf': 21, # 防止过拟合
'min_sum_hessian_in_leaf': 3.0, # 防止过拟合
'header': True # 数据集是否带表头
}
# 训练模型并预测
def train_predict_model(x,y):
d_x = x
d_y = y
train_X, valid_X, train_Y, valid_Y = train_test_split(
d_x, d_y, test_size=0.2, random_state=2) # 将训练集分为训练集+验证集
lgb_train = lgb.Dataset(train_X, label=train_Y)
lgb_eval = lgb.Dataset(valid_X, label=valid_Y, reference=lgb_train)
print("Training...")
bst = lgb.train(
params,
lgb_train,
categorical_feature=list(range(1, 17)), # 指明哪些特征的分类特征
valid_sets=[lgb_eval],
num_boost_round=500,
early_stopping_rounds=200)
print("Saving Model...")
bst.save_model(model_file) # 保存模型
print("Predicting...")
predict_result = bst.predict(d_future_x) # 预测的结果在0-1之间，值越大代表预测用户购买的可能性越大
return predict_result
# 评估选取的各特征的重要度（画图显示）
def plot_feature_importance(dataset, model_bst):
list_feature_name = list(dataset.columns[2:])
list_feature_importance = list(model_bst.feature_importance(
importance_type='split', iteration=-1))
dataframe_feature_importance = pd.DataFrame(
{'feature_name': list_feature_name, 'importance': list_feature_importance})
print(dataframe_feature_importance)
x = range(len(list_feature_name))
plt.xticks(x, list_feature_name, rotation=90, fontsize=14)
plt.plot(x, list_feature_importance)
for i in x:
plt.axvline(i)
plt.show()
if __name__ == "__main__":
train_predict_model(X_trian,Y_trian)
3.12 融合模型分类
代码如下（示例）：
#常用工具库
import re
import pandas as pd
import numpy as np
import matplotlib as mlp
import matplotlib.pyplot as plt
import time
#算法辅助
import sklearn
from sklearn.model_selection import KFold,cross_validate
from sklearn.model_selection import train_test_split
#算法
from sklearn.neighbors import KNeighborsClassifier as KNNC
from sklearn.tree import DecisionTreeClassifier as DTC
from sklearn.linear_model import LogisticRegression as LogiR
from sklearn.ensemble import RandomForestClassifier as RFC
from sklearn.ensemble import GradientBoostingClassifier as GBDT
from sklearn.naive_bayes import GaussianNB
from xgboost import XGBClassifier as XGBC
import xgboost as xgb
#模型融合
from sklearn.ensemble import StackingClassifier
from sklearn.ensemble import VotingClassifier
from sklearn.metrics import classification_report
#导入数据
sample= pd.read_csv('data//all.csv', header=None)#原始文件
X=sample.iloc[:,3:]
print(X.head())
y=sample.iloc[:,2]
print(y.head())
# 训练集 、测试集划分
Xtrain, Xtest, Ytrain, Ytest = train_test_split(X,y,test_size=0.3)
#设置集成学习器
def fusion_estima(clf):
cv=KFold(n_splits=5,shuffle=True,random_state=1412)
results=cross_validate(clf,Xtrain,Ytrain,
cv=cv,scoring="accuracy",
n_jobs=-1,return_train_score=True,
verbose=False)
test=clf.fit(Xtrain,Ytrain).score(Xtest,Ytest)
print("集成模型")
print("训练集打分：", results["train_score"].mean())
print("交叉验证打分：", results["test_score"].mean())
print("测试集打分：", test)
#设置一个单分类器逐一训练的函数
def in_estimators(clfs):
for clf in clfs:
cv = KFold(n_splits=5, shuffle=True, random_state=1412)
results = cross_validate(clf[1], Xtrain, Ytrain,
cv=cv, scoring="accuracy",
n_jobs=-1, return_train_score=True,
verbose=False)
test = clf[1].fit(Xtrain, Ytrain).score(Xtest, Ytest)
print(clf[0])
print("训练集打分：",results["train_score"].mean())
print("交叉验证打分：",results["test_score"].mean())
print("测试集打分：",test)
#个体学习器定义，需要什么模型在这里加
clf1=LogiR(max_iter=3000,random_state=1412,n_jobs=8)
clf2=RFC(n_estimators=100,random_state=1412,n_jobs=8)
clf3=GBDT(n_estimators=100,random_state=1412)
clf4=XGBC(n_estimators=100,subsample=0.9,reg_alpha=100)
clf5=DTC(max_depth=8,random_state=1412)
clf6=KNNC(n_neighbors=10,n_jobs=8)
clf7=GaussianNB()
final_clf=RFC(n_estimators=100,random_state=420,n_jobs=8)
estimators=[("逻辑回归",clf1),("随机森林",clf2),("GBC",clf3)]#在这里你可以加你想要集成的模型，例如我想要加决策树，在后面加("决策树"，clf5)
clf=StackingClassifier(estimators=estimators,final_estimator=final_clf,n_jobs=8)#用stacking方法集成，最后叠加了一层随机森林
clf_1=VotingClassifier(estimators=estimators,voting="soft")#直接用投票法
in_estimators(estimators)#训练你的单个模型效果
fusion_estima(clf_1)#训练得出你集成模型效果，投票法
fusion_estima(clf)#stacking集成
4.机器学习常用聚类模型
4.1 Kmeans，DBSCAN, SpectralClustering, Birch, MeanShift, AgglomerativeClustering
代码如下（示例）：
一次罗列了，聚类就不一一写了
from sklearn.datasets import make_circles
import matplotlib.pyplot as plt
import numpy as np
from sklearn.cluster import KMeans, DBSCAN, SpectralClustering, Birch, MeanShift, AgglomerativeClustering
from sklearn.decomposition import PCA
import pandas as pd
#数据集制造
x = make_blobs(n_samples=1000, n_features=2, centers = 4, cluster_std=2.0)[0]
pca = PCA(n_components=2)
pca_result = pca.fit_transform(x)
fig = plt.figure(figsize=(15,10))
model = AgglomerativeClustering(n_clusters = 4)
y_pred = model.fit_predict(x)
fig.add_subplot(2,3,1)
plt.scatter(pca_result[:,0], pca_result[:,1], marker='.', c=y_pred)
plt.title('AgglomerativeClustering')
model = KMeans(n_clusters = 4, random_state=10)
y_pred = model.fit_predict(x)
fig.add_subplot(2,3,2)
plt.scatter(pca_result[:,0], pca_result[:,1], marker='.', c=y_pred)
plt.title('KMeans')
model = DBSCAN(eps=0.1)
model.fit(x)
y_pred = model.labels_
fig.add_subplot(2,3,3)
plt.scatter(pca_result[:,0], pca_result[:,1], marker='.', c=y_pred)
plt.title('DBSCAN')
model = SpectralClustering(n_clusters = 4, random_state=10)
y_pred = model.fit_predict(x)
fig.add_subplot(2,3,4)
plt.scatter(pca_result[:,0], pca_result[:,1], marker='.', c=y_pred)
plt.title('SpectralClustering')
model = Birch(n_clusters=4)
model.fit(x)
y_pred = model.labels_
fig.add_subplot(2,3,5)
plt.scatter(pca_result[:,0], pca_result[:,1], marker='.', c=y_pred)
plt.title('Birch')
model = MeanShift()
model.fit(x)
y_pred = model.labels_
fig.add_subplot(2,3,6)
plt.scatter(pca_result[:,0], pca_result[:,1], marker='.', c=y_pred)
plt.title('MeanShift')
四、参数调整
通常通过学习曲线来确定某个参数的作用及其变化，在确定参数的最佳组合的保证和计算时间之间总是存在权衡。如果超参数空间(超参数个数)非常大，则使用随机搜索找到超参数的潜在组合，然后在该局部使用网格搜索(超参数的潜在组合)选择最优特征。
1.通用学习曲线
代码如下（示例）：
缺点：没办法确保得到最佳的参数组合。
from sklearn.svm import LinearSVC#举例子
from sklearn.learning_curve import learning_curve
#绘制学习曲线，以确定模型的状况
def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,
train_sizes=np.linspace(.1, 1.0, 5)):
"""
画出data在某模型上的learning curve.
参数解释
----------
estimator : 你用的分类器。
title : 表格的标题。
X : 输入的feature，numpy类型
y : 输入的target vector
ylim : tuple格式的(ymin, ymax), 设定图像中纵坐标的最低点和最高点
cv : 做cross-validation的时候，数据分成的份数，其中一份作为cv集，其余n-1份作为training(默认为3份)
"""
plt.figure()
train_sizes, train_scores, test_scores = learning_curve(
estimator, X, y, cv=5, n_jobs=1, train_sizes=train_sizes)
train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
train_scores_mean + train_scores_std, alpha=0.1,
color="r")
plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
test_scores_mean + test_scores_std, alpha=0.1, color="g")
plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
label="Training score")
plt.plot(train_sizes, test_scores_mean, 'o-', color="g",
label="Cross-validation score")
plt.xlabel("Training examples")
plt.ylabel("Score")
plt.legend(loc="best")
plt.grid("on")
if ylim:
plt.ylim(ylim)
plt.title(title)
plt.show()
#少样本的情况情况下绘出学习曲线
plot_learning_curve(LinearSVC(C=10.0), "LinearSVC(C=10.0)",
X, y, ylim=(0.8, 1.01),
train_sizes=np.linspace(.05, 0.2, 5))
2.网格调参
代码如下（示例）：
缺点：由于它尝试了超参数的每一个组合，并根据交叉验证得分选择了最佳组合，这使得GridsearchCV非常慢。
#以随机森林为例，调整max_depth,criterion
from sklearn.model_selection import GridSearchCV
param_grid = {'max_depth':np.arange(1, 20, 1),
'criterion':['gini', 'entropy']}#写入你的参数及范围
rfc = RandomForestClassifier(n_estimators=39
,random_state=90
)
GS = GridSearchCV(rfc,param_grid,cv=10)#网格搜索，放入你的模型及参数范围
GS.fit(X_trian,Y_trian)#放入训练数据
print(GS.best_params_)#显示调整出来的最佳参数
print(GS.best_score_)#返回调整好的最佳参数对应的准确率
3.随机搜索
代码如下（示例）：
缺点：随机搜索的问题是它不能保证给出最好的参数组合。
from sklearn.model_selection import RandomizedSearchCV
knn = KNeighborsClassifier()
grid_param = { 'n_neighbors' : list(range(2,11)) ,
'algorithm' : ['auto','ball_tree','kd_tree','brute'] }
rand_ser = RandomizedSearchCV(knn,grid_param,n_iter=10)
rand_ser.fit(X_train,y_train)
#best parameter combination
rand_ser.best_params_
#score achieved with best parameter combination
rand_ser.best_score_
#all combinations of hyperparameters
rand_ser.cv_results_['params']
#average scores of cross-validation
rand_ser.cv_results_['mean_test_score']
4.贝叶斯搜索
代码如下（示例）：
缺点：要在2维或3维的搜索空间中得到一个好的代理曲面需要十几个样本，增加搜索空间的维数需要更多的样本。
from skopt import BayesSearchCV
import warnings
warnings.filterwarnings("ignore")
# parameter ranges are specified by one of below
from skopt.space import Real, Categorical, Integer
knn = KNeighborsClassifier()
#defining hyper-parameter grid
grid_param = { 'n_neighbors' : list(range(2,11)) ,
'algorithm' : ['auto','ball_tree','kd_tree','brute'] }
#initializing Bayesian Search
Bayes = BayesSearchCV(knn , grid_param , n_iter=30 , random_state=14)
Bayes.fit(X_train,y_train)
#best parameter combination
Bayes.best_params_
#score achieved with best parameter combination
Bayes.best_score_
#all combinations of hyperparameters
Bayes.cv_results_['params']
#average scores of cross-validation
Bayes.cv_results_['mean_test_score']
五、常用绘图
自己画的图太丑，推荐网站在线绘图：https://echarts.apache.org/examples/en/index.html#chart-type-bar
六、参考文章
如何解决样本不均衡问题
菜菜机器学习
Lgb模型搭建
Sklearn参数详解—贝叶斯
决策树③——决策树参数介绍（分类和回归）
机器学习 4 个常用超参数调试方法！
（参考的文章有点多，感谢CSDN各路大佬的分享，让小弟受益匪浅，后面会慢慢补上参考文章的）
华为开发者空间，是为全球开发者打造的专属开发空间，汇聚了华为优质开发资源及工具，致力于让每一位开发者拥有一台云主机，基于华为根生态开发、创新。
更多推荐
70
2- 0
已为社区贡献1条内容
所有评论(0)