機器學習實用代碼匯總（你想要的這里都有）

文章目錄

• 機器學習實用代碼匯總（你想要的這里都有）
• 前言
• 一、數據導入
• • 1.數據文件讀取
  • 2.提取特征和標簽
  • 3.數據分布及關系圖（ProfileReport）
• 二、數據預處理
• • 1.數據的查看、去重、異常值刪除
  • 2.數據的無量綱化
  • 3.缺失值處理
  • 4.處理分類型特征：編碼與啞變量
  • 5.處理連續型特征：二值化與分段
  • 6.數據集制造
  • 7.樣本不均衡處理
  • 8.訓練集、測試集劃分
• 三、特征選擇
• • 1.Filter過濾法
  • 2.Embedded嵌入法
  • 3. Wrapper包裝法
  • 4.PCA與LDA降維
  • 5.特征選擇經驗技巧
• 四、模型搭建及優化
• • 1.模型評估
  • • 1.1回歸模型評估(平均絕對誤差、平均方差、R平方值)
    • 1.2分類模型評估(分類報告、混淆矩陣、ROC曲線、交叉驗證)
    • 1.3聚類模型評估(ARI、輪廓系數)
  • 2.機器學習常用回歸模型
  • • 2.1 線性回歸
    • 2.2 決策樹回歸
    • 2.3 支持向量機回歸
    • 2.4 K近鄰回歸
    • 2.5 隨機森林回歸
    • 2.6 Adaboost 回歸
    • 2.7 梯度增強隨機森林回歸
    • 2.8 Bagging 回歸
    • 2.9 ExtraTree 回歸
    • 2.10 Xgboost回歸
  • 3.機器學習常用分類模型
  • • 3.1 決策樹分類
    • 3.2 隨機森林分類
    • 3.3 Adaboost分類
    • 3.4 GBDT分類
    • 3.5 CatBoost分類
    • 3.6 ExtraTress分類
    • 3.7 KNN分類
    • 3.8 SVM分類
    • 3.9 XGBoost分類
    • 3.10 樸素貝葉斯分類
    • 3.11 LightGBM分類
    • 3.12 融合模型分類
  • 4.機器學習常用聚類模型
  • • 4.1 Kmeans，DBSCAN, SpectralClustering, Birch, MeanShift, AgglomerativeClustering
• 四、參數調整
• • 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) - iqrprint('val_low:',val_low)val_up = data_ser.quantile(0.75) + iqrprint('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_regfillc = 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] = Ypredictreturn 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 = xd_y = ytrain_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 vectorylim : 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各路大佬的分享，讓小弟受益匪淺，后面會慢慢補上參考文章的）

總結

以上是生活随笔為你收集整理的机器学习实用代码汇总（你想要的这里都有）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。