这里记录了自己在学习和实践中, 记录下来的常用代码块。非常适合小白来学习和实践,在实践过程中找到你想要的某些功能,不断的复制粘贴就可以,有助于你早日成为CV工程师。
(后面会慢慢完善BP、CNN、RNN、LSTM、GRU、Transorformer、BERT、GAN、YOLOV、Q-learning、QMIX、MAPPO等网络结构结合任务场景的快速使用)
代码如下(示例):
#读取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中
代码如下(示例):
#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]#一般标签在最后一列
用于数据分析报告,可以查看相关性,样本分布关系等
代码如下(示例):
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
代码如下(示例):
#查看部分数据
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
无量纲化可以帮我们提升模型精度,避免某一个取值范围特别大的特征对距离计算造成影响。(一个特例是决策树和树的集成算法们,对决策树我们不需要无量纲化,决策树可以把任意数据都处理得很好。)
常用的数据无量纲化代码有数据归一化和数据标准化。大多数机器学习算法中,会选择数据标准化来进行特征缩放,因为数据标准化对异常值非常敏感。在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) #使用标准化后的结果逆转
数据归一化和标准化接口汇总
代码如下(示例):
用均值、中位数、特定值来填补缺失值
#常用的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
在现实中,许多标签和特征在数据收集完毕的时候,都不是以数字来表现的。比如说,学历的取值可以是[“小 学”,“初中”,“高中”,“大学”],付费方式可能包含[“支付宝”,“现金”,“微信”]等等。在这种情况下,为了让数据适应算法和库,我们必须将数据进行编码,即是说,将文字型数据转换为数值型。
代码如下(示例):
对标签进行编码
#对标签进行编码
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()
代码如下(示例):
二值化
#二值化、根据阈值将数据二值化(将特征值设置为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)
代码如下(示例):
#用于制造学习来用的分类数据集
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分类的数据集
过采样(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)#合并,得到欠采样的数据集
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)
特征工程主要包括特征提取、特征创造和特征选择。特征提取针对不同的数据有不同的方法,例如,从文字,图像,声音等其他非结构化数据中提取新信息作为特征。比如说,从淘宝宝贝的名称中提取出产品类别、产品颜色,是否是网红产品等等。往往特征提取是科研中的重要一环节,这个后面单独写文章来总结。特征创造是把现有特征进行组合,或互相计算,得到新的特征。比如说,我们有一列特征是速度,一列特征是距离,我们就可以通过让两列相处,创造新的特征:通过距离所花的时间。特征创造 在机器学习竞赛中用的较多,后面单独写文章来讲解。特征选择是从所有的特征中,选择出有意义,对模型有帮助的特征,以避免必须将所有特征都导入模型去训练的情况
通常来说,我会建议,先使用方差过滤,然后使用互信息法来捕捉相关性,不过了解各种各样的过滤方式也是必要的。
代码如下(示例):
方差过滤:根据特征的方差大小,设置阈值来过滤
#方差过滤、根据特征的方差大小,设置阈值来过滤
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)
嵌入法是一种让算法自己决定使用哪些特征的方法,即特征选择和算法训练同时进行。在使用嵌入法时,我们先使用某些机器学习的算法和模型进行训练,得到各个特征的权值系数,根据权值系数从大到小选择特征。这些权值系数往往代表了特征对于模型的某种贡献或某种重要性.
代码如下(示例):
#通过设置模型重要程度阈值来筛选特征
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()
包装法也是一个特征选择和算法训练同时进行的方法,与嵌入法十分相似,它也是依赖于算法自身的选择,比如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()
降维算法不能简单的称为特征选择,它能减少特征的数量,又保留大部分有效信息,可以简单理解成一种特征压缩的手段,其本质是对矩阵的分解。
代码如下(示例):
#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)
1.经验来说,过滤法更快速,但更粗糙。
2.包装法和嵌入法更精确,比较适合具体到算法去调整,但计算量比较大,运行时间长。
3.当数据量很大的时候,优先使用方差过滤和互信息法调整,再上其他特征选择方法。
4.使用逻辑回归时,优先使用嵌入法。使用支持向量机时,优先使用包装法。迷茫的时候,从过滤法走起,看具体数据具体分析。
5.其实特征选择只是特征工程中的第一步。真正的高手,往往使用特征创造或特征提取来寻找高级特征。在Kaggle之类的算法竞赛中,很多高分团队都是在高级特征上做文章,而这是比调参和特征选择更难的,提升算法表现的高深方法。特征工程非常深奥,虽然我们日常可能用到不多,但其实它非常美妙。若大家感兴趣,也可以自己去网上搜一搜,多读多看多试多想,技术逐渐会成为你的囊中之物。
建模的评估一般可以分为回归、分类和聚类的评估。
代码如下(示例):
#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平方值
代码如下(示例):
分类报告
#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折交叉验证
代码如下(示例):
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')#得到轮廓系数
代码如下(示例):
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)))#均方误差,看模型效果
代码如下(示例):
%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: 是否排序,基本不用管
代码如下(示例):
from sklearn.svm import LinearSVC
svm_clf=LinearSVC()
svm_clf.fit(X_train,y_train)
代码如下(示例):
from sklearn import neighbors
model_KNeighborsRegressor = neighbors.KNeighborsRegressor()
model_KNeighborsRegressor.fit(X_train,y_train)
代码如下(示例):
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吧,宇宙终极奥秘。
代码如下(示例):
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: 划分最需最小不纯度,前者是特征选择时低于就不考虑这个特征,后者是如果选取的最优特征划分后达不到这个阈值,则不再划分,节点变成叶子节点
代码如下(示例):
from sklearn import ensemble
model_GradientBoostingRegressor = ensemble.GradientBoostingRegressor(n_estimators=100)
model_GradientBoostingRegressor.fit(X_train,y_train)
参数参考随机森林
代码如下(示例):
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吧,宇宙终极奥秘。
代码如下(示例):
from sklearn.tree import ExtraTreeRegressor
model_ExtraTreeRegressor = ExtraTreeRegressor()
model_ExtraTreeRegressor.fit(X_train,y_train)
代码如下(示例):
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(列子采样):每棵树对特征的采样率,用于防止过拟合
代码如下(示例):
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: 是否排序,基本不用管
代码如下(示例):
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 :随机种子
代码如下(示例):
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:随机种子设置。
代码如下(示例):
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,如果噪音点较多,可以适当降低这个分位数的值。
代码如下(示例):
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
代码如下(示例):
from sklearn.ensemble import ExtraTreesClassifier
model = ExtraTreesClassifier(n_estimators=500,bootstrap=True,oob_score=True,random_state=666)
model.fit(X_train, y_train)
代码如下(示例):
from sklearn.neighbors import KNeighborsClassifier as KNNC
model=KNNC(n_neighbors=10,n_jobs=8)
model.fit(X_train, y_train)
代码如下(示例):
from sklearn.svm import SVC
model=SVC()
model.fit(X_train, y_train)
代码如下(示例):
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,即全部样本用于训练。调节该参数可以防止过拟合。
代码如下(示例):
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分之一。
代码如下(示例):
# -*- 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)
代码如下(示例):
#常用工具库
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集成
代码如下(示例):
一次罗列了,聚类就不一一写了
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')
通常通过学习曲线来确定某个参数的作用及其变化,在确定参数的最佳组合的保证和计算时间之间总是存在权衡。如果超参数空间(超参数个数)非常大,则使用随机搜索找到超参数的潜在组合,然后在该局部使用网格搜索(超参数的潜在组合)选择最优特征。
代码如下(示例):
缺点:没办法确保得到最佳的参数组合。
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))
代码如下(示例):
缺点:由于它尝试了超参数的每一个组合,并根据交叉验证得分选择了最佳组合,这使得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_)#返回调整好的最佳参数对应的准确率
代码如下(示例):
缺点:随机搜索的问题是它不能保证给出最好的参数组合。
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']
代码如下(示例):
缺点:要在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各路大佬的分享,让小弟受益匪浅,后面会慢慢补上参考文章的)