分割資料將資料分為訓練集和測試集，使用sklearn的model_selection庫裡面的 train_test_split

from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, train_size=0.7, random_state=1)

 

 

決策樹分類器，使用sklearn的tree庫裡面的DecisionTreeClassifier

model = DecisionTreeClassifier(criterion='entropy', max_depth=6)
 

 原函式：

sklearn.tree.DecisionTreeClassifier(criterion='gini', splitter='best', max_depth=None, min_samples_split=2,min_samples_leaf =1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None,class_weight=None, presort=False)

 criterion：衡量分類的質量，預設為"gini",支援的標準有"gini"，代表的是gini impurity（不純度）與"entropy"，代表的是information gain（資訊增益）

splitter：一種用來在選節點中選擇分類的策略，預設為"best"，代表選擇最好的分類，"random"代表選擇最好的隨機分類

max_features：分類時最大特徵數目，預設None表示最大特徵數目等於樣本特徵數目

max_depth：表示樹的最大深度，預設為None表示會一直分類到所有節點都是純節點或者滿足min_sample_leaf，忽視max_leaf_nodes是不是等於None

min_samples_split：區分一個內部節點所需要的最小樣本數，預設為2

min_weight_fraction_leaf：一個葉節點的輸入樣本所需要的最小加權分數

max_leaf_nodes：如果是None則對葉節點的數目沒有限制。如果不是None則不考慮max_depth.

 

 

 

隨機森林分類器，使用sklearn裡面ensemble庫裡面的RandomForestClassifer

clf = RandomForestClassifier(n_estimators=200, criterion='entropy', max_depth=3)

函式原型：

sklearn.ensemble.RandomForestClassifier(n_estimators=10, crite-rion=’gini’, max_depth=None,  
min_samples_split=2, min_samples_leaf=1,  
min_weight_fraction_leaf=0.0,  
max_features=’auto’,  
max_leaf_nodes=None, bootstrap=True,  
oob_score=False, n_jobs=1, ran-dom_state=None, verbose=0,  
warm_start=False, class_weight=None) 

verbose:(default=0) 是否顯示任務程序

n_estimators=10：決策樹的個數，越多越好，但是效能就會越差，至少100左右（具體數字忘記從哪裡來的了）可以達到可接受的效能和誤差率。

bootstrap=True：是否有放回的取樣

oob_score=False：oob（out of band，帶外）資料，即：在某次決策樹訓練中沒有被bootstrap選中的資料。多單個模型的引數訓練，我們知道可以用cross validation（cv）來進行，但是特別消耗時間，而且對於隨機森林這種情況也沒有大的必要，所以就用這個資料對決策樹模型進行驗證，算是一個簡單的交叉驗證。效能消耗小，但是效果不錯。

n_jobs=1：並行job個數。這個在ensemble演算法中非常重要，尤其是bagging（而非boosting，因為boosting的每次迭代之間有影響，所以很難進行並行化），因為可以並行從而提高效能。1=不併行；n：n個並行；-1：CPU有多少core，就啟動多少job 

warm_start=False：熱啟動，決定是否使用上次呼叫該類的結果然後增加新的。

class_weight=None：各個label的權重。

 

 

 

bagging分類器，使用sklearn裡面ensemble庫中的BaggingRegressor

從樣本集中重取樣(有重複的)選出n個樣本，在所有屬性上，對這n個樣本建立分類器（ID3，ID4.5， CART，SVM）等等

重複建立m個分類器，將資料放在這m個分類器上，最後根據這m個分類器的選擇，決定資料屬於哪一分類。

決策樹是一個可讀性很強、分類快，同時不需要對資料進行歸一化還有縮放的處理。但是決策樹有個不足的地方就是非常容易過

擬合，所以必須要採取一些方法進行剪枝。而bagging方法的出現，可以完美地解決了決策樹過擬合的問題，同時bagging的使用

也會使分類器分類效果得到了顯著的提高

bagging_ridged = BaggingRegressor(ridged, n_estimators=100, max_samples=0.3)

函式原型 

sklearn.ensemble.BaggingRegressor(base_estimator=None, n_estimators=10, max_samples=1.0, max_features=1.0, bootstrap=True, bootstrap_features=False, oob_score=False, warm_start=False, n_jobs=None, random_state=None, verbose=0)

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) 意義同上個api

 

 

 

機器學習中的資料預處理，使用sklearn preprocessing

scale 零均值單位方差

from sklearn import preprocessing 
import numpy as np  
X = np.array([[1., -1., 2.], [2., 0., 0.], [0., 1., -1.]])  
X_scaled = preprocessing.scale(X) 
#output :X_scaled = [[ 0.         -1.22474487  1.33630621]
 				 [ 1.22474487  0.         -0.26726124]
 				 [-1.22474487  1.22474487 -1.06904497]]
＃scaled之後的資料零均值，單位方差
X_scaled.mean(axis=0)  # column mean: array([ 0.,  0.,  0.])  
X_scaled.std(axis=0)  #column standard deviation: array([ 1.,  1.,  1.])

處理過後的資料，在列上均值為0方差為1 

 

 

 

StandardScaler計算訓練集的平均值和標準差，以便測試資料集使用相同的變換。

scaler = preprocessing.StandardScaler().fit(X) #out: StandardScaler(copy=True, with_mean=True, with_std=True)
scaler.mean_  #out: array([ 1.,  0. ,  0.33333333])  
scaler.std_ #out: array([ 0.81649658,  0.81649658,  1.24721913]) 
#測試將該scaler用於輸入資料，變換之後得到的結果同上
scaler.transform(X) #out: array([[ 0., -1.22474487,  1.33630621],        [ 1.22474487, 0. , -0.26726124],  [-1.22474487,1.22474487, -1.06904497]])  
scaler.transform([[-1., 1., 0.]])  #scale the new data, out: array([[-2.44948974,  1.22474487, -0.26726124]])

 

 

另外一種標準化方法是將資料縮放至給定的最小值與最大值之間，通常是０與１之間，可用MinMaxScaler實現。或者將最大的絕對值縮放至單位大小，可用MaxAbsScaler實現。
使用這種標準化方法的原因是，有時資料集的標準差非常非常小，有時資料中有很多很多零（稀疏資料）需要儲存住０元素。

MinMaxScaler(最小最大值標準化) 

公式：X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0)) ;

X_scaler = X_std/ (max - min) + min，其中max，min是指定的最大最小值，預設1，0

#例子：將資料縮放至[0, 1]間。訓練過程: fit_transform()
X_train = np.array([[1., -1., 2.], [2., 0., 0.], [0., 1., -1.]])
min_max_scaler = preprocessing.MinMaxScaler() 
X_train_minmax = min_max_scaler.fit_transform(X_train)  
#out: array([[ 0.5       ,  0.        ,  1.        ], 
[ 1.        ,  0.5       ,  0.33333333],        
[ 0.        ,  1.        ,  0.        ]])
#將上述得到的scale引數應用至測試資料
X_test = np.array([[ -3., -1., 4.]])  
X_test_minmax = min_max_scaler.transform(X_test) #out: array([[-1.5 ,  0. , 1.66666667]])
#可以用以下方法檢視scaler的屬性
min_max_scaler.scale_        #out: array([ 0.5 ,  0.5,  0.33...])
min_max_scaler.min_         #out: array([ 0.,  0.5,  0.33...])

 

 

MaxAbsScaler（絕對值最大標準化） 

與上述標準化方法相似，但是它通過每個特徵值除以該特徵最大值將訓練集縮放至[-1,1]。這意味著資料已經以０為中心或者是含有非常非常多０的稀疏資料

X_train = np.array([[ 1., -1.,  2.],
                     [ 2.,  0.,  0.],
                    [ 0.,  1., -1.]])
max_abs_scaler = preprocessing.MaxAbsScaler()
X_train_maxabs = max_abs_scaler.fit_transform(X_train)
# doctest +NORMALIZE_WHITESPACE^, out: array([[ 0.5, -1.,  1. ], [ 1. , 0. ,  0. ],       [ 0. ,  1. , -0.5]])
X_test = np.array([[ -3., -1.,  4.]])
X_test_maxabs = max_abs_scaler.transform(X_test) #out: array([[-1.5, -1. ,  2. ]])
max_abs_scaler.scale_  #out: array([ 2.,  1.,  2.])

 

 

sklearn.pipeline 序列化

通過steps引數，設定資料處理流程。格式為('key','value')，key是自己為這一step設定的名稱，value是對應的處理類。最後通過list將這些step傳入。前n-1個step中的類都必須有transform函式，最後一步可有可無，一般最後一步為模型。pipe繼承了最後一個類的所有方法。 

Pipeline(steps=[('pca', PCA(copy=True, iterated_power='auto', n_components=None,
 random_state=None,
  svd_solver='auto', tol=0.0, whiten=False)), ('svc', SVC(C=1.0, cache_size=200,
 class_weight=None, coef0=0.0,
  decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False))])

訓練得到的是一個模型，可直接用來預測，預測時，資料會從step1開始進行轉換，避免了模型用來預測的資料還要額外寫程式碼實現。還可通過pipe.score(X,Y)得到這個模型在X訓練集上的正確率。

make_pipeline函式是Pipeline類的簡單實現，只需傳入每個step的類例項即可，不需自己命名，自動將類的小寫設為該step的名。

In [50]: make_pipeline(StandardScaler(),GaussianNB())
Out[50]: Pipeline(steps=[('standardscaler', StandardScaler(copy=True, with_mean=
True, with_std=True)), ('gaussiannb', GaussianNB(priors=None))])
 
In [51]: p=make_pipeline(StandardScaler(),GaussianNB())
 
In [52]: p.steps
Out[52]:
[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True)),
 ('gaussiannb', GaussianNB(priors=None))]

 同時可以通過set_params重新設定每個類裡邊需傳入的引數，設定方法為step的name__parma名=引數值

In [59]: p.set_params(standardscaler__with_mean=False)
Out[59]: Pipeline(steps=[('standardscaler', StandardScaler(copy=True, with_mean=
False, with_std=True)), ('gaussiannb', GaussianNB(priors=None))])

 

 

 

網格搜尋GridSearchCV,用於系統地遍歷多種引數組合，通過交叉驗證確定最佳效果引數。

原函式：

classsklearn.model_selection.GridSearchCV(estimator,param_grid, scoring=None, fit_params=None, n_jobs=1, iid=True, refit=True,cv=None, verbose=0, pre_dispatch='2*n_jobs', error_score='raise',return_train_score=True)

estimator：

所使用的分類器，如estimator=RandomForestClassifier(min_samples_split=100,min_samples_leaf=20,max_depth=8,max_features='sqrt',random_state=10), 並且傳入除需要確定最佳的引數之外的其他引數。每一個分類器都需要一個scoring引數，或者score方法。

scoring :

準確度評價標準，預設None,這時需要使用score函式；或者如scoring=’roc_auc’，根據所選模型不同，評價準則不同。字串（函式名），或是可呼叫物件，需要其函式簽名形如：scorer(estimator, X, y)；如果是None，則使用estimator的誤差估計函式。

cv :

交叉驗證引數，預設None，使用三折交叉驗證。指定fold數量，預設為3，也可以是yield訓練/測試資料的生成器。

refit :

預設為True,程式將會以交叉驗證訓練集得到的最佳引數，重新對所有可用的訓練集與開發集進行，作為最終用於效能評估的最佳模型引數。即在搜尋引數結束後，用最佳引數結果再次fit一遍全部資料集。

iid:

預設True,為True時，預設為各個樣本fold概率分佈一致，誤差估計為所有樣本之和，而非各個fold的平均。

verbose：

日誌冗長度，int：冗長度，0：不輸出訓練過程，1：偶爾輸出，>1：對每個子模型都輸出。

n_jobs:

並行數，int：個數,-1：跟CPU核數一致, 1:預設值。

pre_dispatch：

指定總共分發的並行任務數。當n_jobs大於1時，資料將在每個執行點進行復制，這可能導致OOM，而設定pre_dispatch引數，則可以預先劃分總共的job數量，使資料最多被複制pre_dispatch次。

即便呼叫函式是param_grid已經填寫，也可以在後面，重新setparam

model = GridSearchCV(classification, param_grid={'alpha': alpha_can}, cv=5)
m = alpha_can.size
if hasattr(classification, 'alpha'):
    model.set_params(param_grid={'alpha': alpha_can})
    m = alpha_can.size
if hasattr(classification, 'n_neighbors'):
    neighbors_can = np.arange(1, 15)
    model.set_params(param_grid={'n_neighbors': neighbors_can})
    m = neighbors_can.size

使用best_params獲取最優超引數

 

 

 

支援向量機api使用svm庫的svc函式

from sklearn import svm
clf = svm.SVC(C=0.8, kernel='rbf', gamma=20, decision_function_shape='ovr')
clf.fit(x_train, y_train.ravel())

這裡kenel代表索要使用的核函式，rbf為徑向基函式，還有lin表示線性核

c代表的容錯率，c越大表示允許度越小，svm的緩衝區距離分割超平面越近。c特別小的時候容易造成過擬合。

gamma代表徑向基函式的類似彎曲程度，可以表示為負的方差分之一，gamma越大則方差越大，方差大的時候分割超平面近似於一條直線，方差小的時候，容易造成過擬合。

decision_function_shape有兩種ovo和ovr，主要是用於多分類問題，ovo代表多分類時採用一對一進行二分類，ovr代表採用1對剩下的所有進行二分類。

可以直接來檢視訓練模型的評分

clf.score(x_train, y_train)

 可以檢視每個樣本對應各個類別的大小數值：

print('decision_function:\n', clf.decision_function(x_train))

decision_function:
 [
   [ 2.45540648  0.80337522 -0.2587817 ]
   [-0.4368348   2.31950945  1.11732536]
   [-0.43793789  1.00917055  2.42876733]
 ]

[0. 1. 2.]