顯示具有 機器學習 標籤的文章。 顯示所有文章
顯示具有 機器學習 標籤的文章。 顯示所有文章

2018年4月21日 星期六

機器學習_ML_feature_selection_SelectKBest

機器學習_ML_feature_selection_SelectKBest

tags: ML KNN
官方說明
手上的特徵很多,有什麼方法可以讓我們快速的了解能用的有多少?一般來說我們希望相關性愈高的愈好,除了利用相關矩陣來了解之外還有其它實用的sklearn套件可以用,一起來了解其中的SelectKBest如何選擇特徵。
  • 定義K:K所指同KNN,要選擇K個最好的
  • 選擇演算法:需選擇配合的演算法來計算特徵相關性
    • For regression: f_regression, mutual_info_regression
    • For classification: chi2, f_classif, mutual_info_classif
    • If you use sparse data (i.e. data represented as sparse matrices), chi2, mutual_info_regression, mutual_info_classif will deal with the data without making it dense.
      • 稀疏矩陣的話採行上述三種演算法可保持它的稀疏性
很重要的一點是,不要將適用分類的演算法拿來計算迴歸,這將取得沒用的結果
pvalue與卡方都是統計上的一個手法,這部份如果有興趣的話可以尋找相關文獻來閱讀。

IMPORT

from sklearn.feature_selection import SelectKBest

CLASS

class sklearn.feature_selection.SelectKBest(score_func=<function f_classif>, k=10)

參數說明

score_func

演算法設置,記得誤將適用於迴歸的用於分類
  • f_classif
  • mutual_info_classif
  • chi2
  • f_regression
  • mutual_info_regression
  • SelectPercentile
  • SelectFpr
  • SelectFdr
  • SelectFwe
  • GenericUnivariateSelect

k : int or ‘all’, optional, default=10

選擇的特徵數

屬性說明

scores_

特徵分數

pvalues_

特徵分數p值,如果只回傳分數的話就不會有值,取決於演算法。

方法說明

fit(X, y)

擬合、訓練數據

fit_transform(X[, y])

擬合、訓練數據並且轉換
fit+transform

get_params([deep])

取得模型參數

get_support([indices])

取得特徵索引遮罩(像pandas做過濾的時候使用)

inverse_transform(X)

回傳特徵陣列,但會將get_support為false的部份以0呈現

set_params(**params)

設置模型參數

transform(X)

轉換數據

範例

範例預計利用chi2(卡方檢驗_中興大學說明)來選擇特徵
案例取自sklearn官方
#  import需求套件
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2

#  讀入資料集,賦值資料與類別
#  這是一個分類的範例
iris = load_iris()
X, y = iris.data, iris.target
#  取得X的維度
X.shape
結果如下:
(150, 4)
#  利用KBest選擇2個特徵
kbest = SelectKBest(chi2, k=2)
X_new = kbest.fit_transform(X, y)
X_new.shape
結果如下:
(150, 2)
利用特徵選擇,我們保留了K(2)個特徵
接下來,我們來觀察幾個方法的回傳值。
#  取得參數可以看到我們使用的是chi2(卡方)演算法
>>>kbest.get_params()
{'k': 2,
 'score_func': <function sklearn.feature_selection.univariate_selection.chi2>}
#  從回傳的特徵索引可以用來查看我們的特徵
>>>kbest.get_support()
array([False, False,  True,  True], dtype=bool)
#  回傳資料集,並且僅保留兩個特徵的值
>>>kbest.inverse_transform(X_new)
array([[ 0. ,  0. ,  1.4,  0.2],
       [ 0. ,  0. ,  1.4,  0.2],
       [ 0. ,  0. ,  1.3,  0.2],
       [ 0. ,  0. ,  1.5,  0.2],
       [ 0. ,  0. ,  1.4,  0.2],
       [ 0. ,  0. ,  1.7,  0.4],
       ......
#  查詢特徵卡方值(愈大愈好)
>>>kbest.scores_
array([  10.81782088,    3.59449902,  116.16984746,   67.24482759])
#  查詢pvalue,因為chi2有,所以有回傳值
>>>kbest.pvalues_ 
array([  4.47651499e-03,   1.65754167e-01,   5.94344354e-26,
         2.50017968e-15])
#  最後,確認下新特徵的矩陣
>>>X_new
array([[ 1.4,  0.2],
       [ 1.4,  0.2],
       [ 1.3,  0.2],
       [ 1.5,  0.2],
       [ 1.4,  0.2],
       [ 1.7,  0.4],
       [ 1.4,  0.3],
       [ 1.5,  0.2],
       [ 1.4,  0.2],
       .....

2018年3月27日 星期二

機器學習_ML_KNN_最近鄰居

機器學習_ML_KNN_最近鄰居

tags: ML KNN
官方連結
KNN是一種惰式學習器,它不會從訓練資料集中學出判別函數,而是把訓練資料集記憶起來。
在學習過程中是沒有成本的!
三步驟:
  1. 選定k值和一個距離度量
  2. 找出k個想要分類的最相近的鄰近樣本
  3. 以多數決方式來指定類別標籤
    根據選定的距離度量來針對某個新分類的點做判斷,多數決!
KNN對異常的容忍度高,畢竟是取最接近的K點來做多數決,但相對的,計算量也不小。預設情況下,都是相同權重,如果有需求也可以透過權重設置來對不同的鄰居做不同的權重設置。
還有一種為『RadiusNeighborsClassifier』,可以設置相鄰範圍,這對數據分佈不均的資料集有較好的效果,這部份我們另篇說明。
Warning
Regarding the Nearest Neighbors algorithms, if it is found that two neighbors, neighbor k+1 and k, have identical distances but different labels, the results will depend on the ordering of the training data.
官方說明到,如果兩個鄰居具有相同權重,具相同距離但不同label的話,其結果取決於訓練資料集的順序。

IMPORT

from sklearn.neighbors import KNeighborsClassifier

CLASS

sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, 
                weights='uniform', algorithm='auto',
                leaf_size=30, p=2, metric='minkowski', 
                metric_params=None, n_jobs=1, **kwargs)

參數說明

n_neighbors

int, optional (default = 5)
K值,以幾個點來決定預測點。

weights

str or callable, optional (default = ‘uniform’)
uniform:預設置,相同權重
distance:愈接近的權重愈高
也可以自定義

algorithm

{‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, optional
計算最近鄰居的演算法
auto:學習的時候會自動選擇(一般選擇此項)
brute:暴力解

leaf_size

int, optional (default = 30)
葉節點的大小,不影響結果,但影響速度以及結構樹的存儲空間。
結構樹的存儲空間需求記憶體用量為n_samples / leaf_size
一般取預設值即可。

p

integer, optional (default = 2)
default 2
1_曼哈頓距離(只能直角)
2_歐氏距離

metric

string or callable, default ‘minkowski’
『the distance metric to use for the tree』,樹的距離度量。
一般來說取預設值即可,如果有其它需求的話可以參考官方Distance metric
minkowski=sum(|x - y|^p)^(1/p)

metric_params

dict, optional (default = None)
如果有使用其它的Distance metric,相關特殊參數可由此設置。
更多情況使用預設值即可滿足。

n_jobs

int, optional (default = 1)
訓練時的cpu使用數
設置-1則火力全開

方法說明

fit(X, y)

擬合、訓練

get_params([deep])

取得模型參數

kneighbors([X, n_neighbors, return_distance])

找出輸入X的鄰居與距離,如果沒有給值的話會回傳訓練模型的資料。
每個點的最近鄰居都是自己,所以距離都為0。

kneighbors_graph([X, n_neighbors, mode])

回傳最近鄰居的矩陣圖,1是最近點,0非最近點。

predict(X)

回傳預測類別

predict_proba(X)

回傳機率

score(X, y[, sample_weight])

取得平均精準度(mean accuracy)

set_params(**params)

設置模型參數

範例

透過簡單的範例來了解部份method所產生的結果
X = [[0], [1], [3], [15], [7]]
from sklearn.neighbors import NearestNeighbors
nn = NearestNeighbors(n_neighbors=2)
nn.fit(X)
a = nn.kneighbors_graph(X)
a.toarray()
第1行:建置一個資料集
第2行:import套件,借用無監督式演算法
第3行:實作
第4行:擬合、訓練
第5行:回傳矩陣圖
第6行:將圖轉陣列
array([[ 1.,  1.,  0.,  0.,  0.],
       [ 1.,  1.,  0.,  0.,  0.],
       [ 0.,  1.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  1.,  1.],
       [ 0.,  0.,  1.,  0.,  1.]])

1是鄰居,0不是鄰居,自己跟自己一定是鄰居,n_neighbors設置為2,故有兩個1。最後一維來看,7跟3比跟15還要近,故7、3為1中間空了一個0。
nn.kneighbors(X)
第1行:回傳兩個資料,與鄰居距離與鄰居索引
(array([[ 0.,  1.],
        [ 0.,  1.],
        [ 0.,  2.],
        [ 0.,  8.],
        [ 0.,  4.]]), array([[0, 1],
        [1, 0],
        [2, 1],
        [3, 4],
        [4, 2]], dtype=int64))
第一部份是鄰居間的距離,自己最近的鄰居是自己,所以第一個值是0,第二個值是距離。
第二部份是自己跟鄰居的索引值,索引從0開始。
透過上面的簡單範例可以了解到method回傳的資料意函,上面的範例借用了無監督式的演算法,故沒有y,請不要在意,method的功能是相同的。
接下來,我們就可以來實作一個KNN的範例。
  • 手動自己產生資料集
#  產生資料集
from sklearn.datasets.samples_generator import make_blobs
centers = [[-1, -1], [0.5, 0.5], [2, 2]]
X,y = make_blobs(n_samples=60, centers=centers, random_state=0, cluster_std=0.5)
n_samples:樣本數
centers:中心點,數值會依中心點分佈
cluster_std:樣本的標準差,這影響到數值
  • 資料集設置完畢之後,記得先利用可視化方式確認資料集
#  查看資料集的分佈
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
cen = np.array(centers)
#  設置圖框大小
plt.figure(figsize=(16,9), dpi=100)
#  產生資料集散佈圖
plt.scatter(X[:, 0], X[:, 1], c=y)
#  繪製中心點
plt.scatter(cen[:, 0], cen[:, 1], s=100, marker='^', c='orange')
plt.show()

  • 訓練模型
#  在沒有特殊需求情況下,預設參數就可以有不錯的效果,我們單純的設置k
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X,y)
  • 預測
#  自己增加一個範本
X_test = [[1.5, 1]]
y_test = knn.predict(X_test)
#  單純回傳鄰居索引,不回傳距離
neighbors = knn.kneighbors(X_test, return_distance=False)
  • 查看y_test
array([1])
範本點被歸於1
  • 查看範本的各類別機率
array([[ 0. ,  0.6,  0.4]])
有三個中心點,所以有三類,y=1的機率最高。
  • 可視化
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
cen = np.array(centers)
plt.figure(figsize=(16,9), dpi=100)
plt.scatter(X[:, 0], X[:, 1], c=y)
plt.scatter(cen[:, 0], cen[:, 1], s=100, marker='^', c='orange')
#  加入預測點x
plt.scatter(X_test[0][0], X_test[0][1], marker='x', c=y_test, s=200)
#  產生於測點與鄰居的連接線
for i in neighbors[0]:
    plt.plot([X[i][0], X_test[0][0]], [X[i][1], X_test[0][1]], 'k--', linewidth=0.5)
plt.show()

2018年3月1日 星期四

機器學習_ML_OneHotEncoder_獨熱編碼

機器學習_ML_OneHotEncoder_獨熱編碼

說明

官方文件
在另篇中我們說明了標籤轉置,用於label(目標類別)的時候是萬無一失,但是用於特徵呢?
很遺憾的,即使是0,1,2,3…對於整個模型的計算還是會有影響,這時候我們就必需改透過獨熱編碼來處理,一起來看sklearn怎麼幫我們達成。

IMPORT

from sklearn.preprocessing import OneHotEncoder

範例

資料集如下:
類別 身高 體重 性別 年紀
胖 175 70 男 35
瘦 160 50 女 31
瘦 175 男 27
胖 180 80 女
胖 180 100 男 18
#  載入需求lib
import numpy as np
import pandas as pd
#  獨熱編碼套件
from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import LabelEncoder

#  手動寫入資料集,資料假裝透過插補完成了
ds = [
    ('胖',175,70,'男',35),
    ('瘦',160,50,'女',31),
    ('瘦',175,75,'男',27),
    ('胖',180,80,'女',27.5),
    ('胖',180,100,'男',18)]

columns = ['label','high','weight','sex','years']

#  假裝一下資料載入pandas,比較有fu
df = pd.DataFrame.from_records(ds,columns=columns)

#  確認資料是否載入pandas
df
#  資料拆分
X = df.iloc[:,1:].values
y = df.iloc[:,0].values
#  確認y的狀態
y
>>>array(['胖', '瘦', '瘦', '胖', '胖'], dtype=object)
#  標籤轉換
y_labelencoder = LabelEncoder()
y = y_labelencoder.fit_transform(y)
>>>array([1, 0, 0, 1, 1], dtype=int64)

X_labelencoder = LabelEncoder()
X[:,2] = X_labelencoder.fit_transform(X[:,2])
>>>array([1, 0, 1, 0, 1], dtype=int64)
#  獨熱編碼
#  需利用categorical_features來指定預執行獨熱編碼的index
onehotencoder = OneHotEncoder(categorical_features=[2])
X_hot = onehotencoder.fit_transform(X).toarray()
#  檢核X_hot
X_hot

使用Pandas

事實上,在轉獨熱編碼的時候,我還是習慣使用pandas。
pd.get_dummies(df[['high', 'weight', 'sex', 'years']])

機器學習_ML_LabelEncoder

機器學習_ML_LabelEncoder

說明

官方文件
在另篇中我們說明了插補,資料插補完了以後,要面對的第二個問題就是文字特徵,甚至我們的類別都有可能是文字,怎麼辦?
這時候我們要透過編碼轉置,將文字轉成數值,讓我們往下看sklearn怎麼幫我們做到這一點。

IMPORT

from sklearn.preprocessing import LabelEncoder

CLASS

class sklearn.preprocessing.LabelEncoder(array)

方法

fit

擬合

transform

轉換

fit_transform

擬合+轉換

inverse_transform

還原

範例

資料集如下:
類別 身高 體重 性別 年紀
胖 175 70 男 35
瘦 160 50 女 31
瘦 175 男 27
胖 180 80 女
胖 180 100 男 18
#  載入需求lib
import numpy as np
import pandas as pd
#  標籤轉換套件
from sklearn.preprocessing import LabelEncoder

#  手動寫入資料集,資料假裝透過插補完成了
ds = [
    ('胖',175,70,'男',35),
    ('瘦',160,50,'女',31),
    ('瘦',175,75,'男',27),
    ('胖',180,80,'女',27.5),
    ('胖',180,100,'男',18)]

columns = ['label','high','weight','sex','years']

#  假裝一下資料載入pandas,比較有fu
df = pd.DataFrame.from_records(ds,columns=columns)

#  確認資料是否載入pandas
df

#  資料拆分
X = df.iloc[:,1:].values
y = df.iloc[:,0].values
#  確認y的狀態
y
>>>array(['胖', '瘦', '瘦', '胖', '胖'], dtype=object)
#  標籤轉換
labelencoder = LabelEncoder()
y = labelencoder.fit_transform(y)
#  確認目標類別轉換狀況
y
>>>array([1, 0, 0, 1, 1], dtype=int64)
#  嚐試還原
labelencoder.inverse_transform(y)
>>>array(['胖', '瘦', '瘦', '胖', '胖'], dtype=object)

2018年2月27日 星期二

Python 機器學習_ML_Imputer

機器學習_ML_Imputer 資料插補

說明

在現實的資料處理中,我們常會遇到資料有缺的狀況,這邊一個,那邊缺一個,這時候我們有兩個選擇,一是放棄它,直接刪除,二是插補。
在sklearn中就有方便的lib可以協助我們直接處理這個問題!

IMPORT

from sklearn.preprocessing import Imputer

CLASS

class sklearn.preprocessing.Imputer(missing_values=’NaN’,
                                    strategy=’mean’, 
                                    axis=0, 
                                    verbose=0, 
                                    copy=True)

參數說明

missing_values

integer or ‘NaN’, optional (default=‘NaN’)
對於numpy的缺值部份,都是以NaN來表示,這部份在pandas亦然。

strategy

string, optional (default=‘mean’)
  • mean:以均值補
  • median:以中位數補
  • most_frequent:最常出現的來補

axis

integer, optional (default=0)
  • 0:column
  • 1:row
以column與row來表示,似乎比較好理解

verbose

default 0
過程是否輸出
0不輸出
1偶爾輸出
1就一定輸出

copy

boolean, optional (default=True)

範例

資料集如下:
類別 身高 體重 性別 年紀
胖 175 70 男 35
瘦 160 50 女 31
瘦 175 男 27
胖 180 80 女
胖 180 100 男 18
#  載入需求lib
import numpy as np
import pandas as pd
#  插補套件
from sklearn.preprocessing import Imputer

#  手動寫入資料集
ds = [
    ('胖',175,70,'男',35),
    ('瘦',160,50,'女',31),
    ('瘦',175,None,'男',27),
    ('胖',180,80,'女',None),
    ('胖',180,100,'男',18)]

columns = ['label','high','weight','sex','years']

#  假裝一下資料載入pandas,比較有fu
df = pd.DataFrame.from_records(ds,columns=columns)

#  確認資料是否載入pandas
df

#  資料拆分
X = df.iloc[:,1:].values
y = df.iloc[:,0].values

#  檢查X的資料,可以發現NULL的部份是NaN
X

#  做資料插補
imputer = Imputer(missing_values='NaN', axis=0, strategy='mean')
imputer.fit_transform(X[:,[1,3]])

#  驗證
print((70+50+80+100)/4)
# 75
print((35+31+27+18)/4)
# 27.75

2017年12月15日 星期五

機器學習_ML_驗證曲線

機器學習_ML_驗證曲線

API連結
官方文件
學習曲線與驗證曲線是在機器學習中很重要的兩條線,透過線的呈現可以明白模型究竟是高偏差(high bias)還是高方差(high variance)。
為什麼重要?
因為high bias and high variance在實務上的調校是不相同的!
你去對一個high bias的模型餵再多的資料,效果恐怕是有限的。
你去對一個high variance給了更多的特徵,那不是提汽油上場嗎?

high bias 代表 underfitting
high variance 代表 overfitting

學習來自吳恩達老師_機器學習_第六週課程

  • 更多的數據
    • high variance有效
    • high bias沒效
  • 嚐試用更少的特徵
    • high variance有效
  • 取得更有效的特徵
    • high bias有效
  • 用更高的多項式方式
    • high bias有效
    • high variance是浪費時間
  • 減少正規項λ數值
    • high bias有效
  • 增加正規項λ數值
    • high variance有效

學習曲線是以『訓練正確率』與『驗證正確率』來製圖,而驗證曲線是以改變參數來製圖。
像是改變正規化參數λ(在sklearn為反正規化參數C)
這方式類似於利用網格搜尋(GridSearc)來暴力求解,不過如同官方文件所說

However, 
it is sometimes helpful to plot the influence of a single hyperparameter 
on the training score 
and the validation score to find out whether the estimator 
is overfitting or underfitting for some hyperparameter values.

有時候利用單一超參數去做繪製影響是有幫助的,這可以找出分類器對某些超參數過適與否。

IMPORT

from sklearn.model_selection import validation_curve

CLASS

sklearn.model_selection.validation_curve( estimator, X, y, param_name, param_range, groups=None, cv=None, scoring=None, n_jobs=1, pre_dispatch=’all’, verbose=0)

參數說明

estimator

使用的分類器,但限制為需要有fit、predict兩個method!

X

訓練資料集

y

對應訓練資料集的label

param_name

參數
格式記得是"分類器__參數"

param_range

要被驗證的參數值
以list格式提供
[0.1, 0.001, 0.0001, 1.0, 10.0, 100.0]

groups

cv

default 3
定義拆分折數

scoring

模型評估
可參考官方關於模型評估的類型

n_jobs

default 1
使用多少CPU核心數
-1代表火力全開

pre_dispatch

verbose

default 0
過程是否輸出
0不輸出
1偶爾輸出
2一定輸出

屬性

train_scores

訓練資料集分數

test_scores

測試資料集分數

範例

下面是官方範例,我加上了註解說明。

print(__doc__) # 載入套件 import matplotlib.pyplot as plt import numpy as np from sklearn.datasets import load_digits from sklearn.svm import SVC from sklearn.model_selection import validation_curve # 讀入資料集 digits = load_digits() X, y = digits.data, digits.target # 設置參數區間 # np.logspace用來建立等比數列,以10為基數 param_range = np.logspace(-6, -1, 5) # 取得驗證曲線的訓練集得分與測試集得分 train_scores, test_scores = validation_curve( # 此例測試SVM的gamma值 SVC(), X, y, param_name="gamma", param_range=param_range, cv=10, scoring="accuracy", n_jobs=1) # 計算訓練集的平均 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.title("Validation Curve with SVM") plt.xlabel("$\gamma$") plt.ylabel("Score") plt.ylim(0.0, 1.1) lw = 2 # 繪製訓練集曲線 plt.semilogx(param_range, train_scores_mean, label="Training score", color="darkorange", lw=lw) # 繪製訓練集區域 plt.fill_between(param_range, train_scores_mean - train_scores_std, train_scores_mean + train_scores_std, alpha=0.2, color="darkorange", lw=lw) # 繪製驗證集曲線 plt.semilogx(param_range, test_scores_mean, label="Cross-validation score", color="navy", lw=lw) # 繪製驗證集區域 plt.fill_between(param_range, test_scores_mean - test_scores_std, test_scores_mean + test_scores_std, alpha=0.2, color="navy", lw=lw) # 顯示標籤,以最佳位置設置 plt.legend(loc="best") plt.show()

np.logspace用來建置等比數列
np.linspace用來建置等差數列

2017年11月28日 星期二

機器學習_ML_學習曲線

機器學習_ML_學習曲線

API連結
官方文件
學習曲線與驗證曲線是在機器學習中很重要的兩條線,透過線的呈現可以明白模型究竟是高偏差(high bias)還是高方差(high variance)。
為什麼重要?
因為high bias and high variance在實務上的調校是不相同的!
你去對一個high bias的模型餵再多的資料,效果恐怕是有限的。
你去對一個high variance給了更多的特徵,那不是拿提汽油上場嗎?

high bias 代表 underfitting
high variance 代表 overfitting

學習來自吳恩達老師_機器學習_第六週課程

  • 更多的數據
    • high variance有效
    • high bias沒效
  • 嚐試用更少的特徵
    • high variance有效
  • 取得更有效的特徵
    • high bias有效
  • 用更高的多項式方式
    • high bias有效
    • high variance是浪費時間
  • 減少正規項λ數值
    • high bias有效
  • 增加正規項λ數值
    • high variance有效

學習曲線的部份,從sklearn官方說明可以知道!

Determines cross-validated training and test scores for different training set sizes.

確定不同訓練集大小的交叉驗證訓練和測試分數。
我們可以從學習曲線了解到,我們增加了資料集之後所得的益處有多少!

IMPORT

from sklearn.learning_curve import learning_curve

CLASS

sklearn.model_selection.learning_curve(
    estimator, X, y, groups=None, 
    train_sizes=array([ 0.1, 0.33, 0.55, 0.78, 1. ]),
    cv=None, scoring=None, 
    exploit_incremental_learning=False, n_jobs=1,
    pre_dispatch=’all’, verbose=0, shuffle=False, 
    random_state=None)

參數說明

estimator

使用的分類器,但限制為需要有fit、predict兩個method!

X

訓練資料集

y

對應訓練資料集的label

groups

train_sizes

訓練資料集的使用,使用上可以給一個陣列
像上面的例子([0.1, 0.33, 0.55, 0.78, 1])
要一直大,限制在0-1之間!
或是透過np.linspace(0.1,1.0,n)來設置!
n的部份自行調整!

cv

default 3
定義拆分折數
預設使用分層K折交叉驗證。

scoring

exploit_incremental_learning

default False

n_jobs

default 1
使用多少CPU核心數
-1代表火力全開

pre_dispatch

verbose

default 0
過程是否輸出
0不輸出
1偶爾輸出
2一定輸出

shuffle

是否要亂數排序

random_state

default None
隨機數種子

屬性

回傳三個值!

train_sizes_abs

資料集的切割狀況
假如有1000,你設置了np.linspace(0.1,1.0,10)
那就會回傳100,200,…1000

train_scores

訓練資料集分數

test_scores

測試資料集分數

範例

下面是一個來自官方的範例

import numpy as np
import matplotlib.pyplot as plt
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.datasets import load_digits
from sklearn.model_selection import learning_curve
from sklearn.model_selection import ShuffleSplit


def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,
                        n_jobs=1, train_sizes=np.linspace(.1, 1.0, 5)):
    """
    Generate a simple plot of the test and training learning curve.

    Parameters
    ----------
    estimator : object type that implements the "fit" and "predict" methods
        An object of that type which is cloned for each validation.

    title : string
        Title for the chart.

    X : array-like, shape (n_samples, n_features)
        Training vector, where n_samples is the number of samples and
        n_features is the number of features.

    y : array-like, shape (n_samples) or (n_samples, n_features), optional
        Target relative to X for classification or regression;
        None for unsupervised learning.

    ylim : tuple, shape (ymin, ymax), optional
        Defines minimum and maximum yvalues plotted.

    cv : int, cross-validation generator or an iterable, optional
        Determines the cross-validation splitting strategy.
        Possible inputs for cv are:
          - None, to use the default 3-fold cross-validation,
          - integer, to specify the number of folds.
          - An object to be used as a cross-validation generator.
          - An iterable yielding train/test splits.

        For integer/None inputs, if ``y`` is binary or multiclass,
        :class:`StratifiedKFold` used. If the estimator is not a classifier
        or if ``y`` is neither binary nor multiclass, :class:`KFold` is used.

        Refer :ref:`User Guide <cross_validation>` for the various
        cross-validators that can be used here.

    n_jobs : integer, optional
        Number of jobs to run in parallel (default 1).
    """
    plt.figure()
    plt.title(title)
    if ylim is not None:
        plt.ylim(*ylim)
    plt.xlabel("Training examples")
    plt.ylabel("Score")
    train_sizes, train_scores, test_scores = learning_curve(
        estimator, X, y, cv=cv, n_jobs=n_jobs, 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.grid()

    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.legend(loc="best")
    return plt


digits = load_digits()
X, y = digits.data, digits.target


title = "Learning Curves (Naive Bayes)"
# Cross validation with 100 iterations to get smoother mean test and train
# score curves, each time with 20% data randomly selected as a validation set.
cv = ShuffleSplit(n_splits=100, test_size=0.2, random_state=0)

estimator = GaussianNB()
plot_learning_curve(estimator, title, X, y, ylim=(0.7, 1.01), cv=cv, n_jobs=4)

title = "Learning Curves (SVM, RBF kernel, $\gamma=0.001$)"
# SVC is more expensive so we do a lower number of CV iterations:
cv = ShuffleSplit(n_splits=10, test_size=0.2, random_state=0)
estimator = SVC(gamma=0.001)
plot_learning_curve(estimator, title, X, y, (0.7, 1.01), cv=cv, n_jobs=4)

plt.show()

結果如下

上圖的部份,可以明確的發現,資料集的增加並未對模型帶來好的效果,並且這是一個高偏差的模型,調整上增加再多的模型也沒有用。
而下圖的部份在資料集的增加情況下,是有明顯的讓驗證資料集也提升。

範例2

書名:Python Machine Learning
作者:Sebastian Raschka
ISBN:978-986-434-140-5

# import lib
import matplotlib.pyplot as plt
#  學習曲線
from sklearn.learning_curve import learning_curve
#  驗證曲線
from sklearn.learning_curve import validation_curve
#  標準化
from sklearn.preprocessing import StandardScaler
#  標籤編碼
from sklearn.preprocessing import LabelEncoder
#  資料分集
from sklearn.cross_validation import train_test_split
#  管道
from sklearn.pipeline import Pipeline
#  logistic
from sklearn.linear_model import LogisticRegression
import pandas as pd
import numpy as np

# get dateset
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/wdbc.data',header=None)
X = df.loc[:, 2:].values
y = df.loc[:, 1].values
#  將標籤編碼
le = LabelEncoder()
#  訓練之後直接轉換
y = le.fit_transform(y)
le.transform(['M', 'B'])

#  資料拆分
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)

學習曲線

#  設置pipeline
pipe_lr = Pipeline([
    ('scl', StandardScaler()),  #  標準化
    ('clf', LogisticRegression(  #  logistic , 正規方式為l2
                    penalty='l2', random_state=0))
])
#  訓練,learning_curve預設使用分層k折交叉驗證法
train_sizes, train_scores, test_scores = learning_curve(
                                estimator=pipe_lr,
                                X=X_train,
                                y=y_train,
                                train_sizes=np.linspace(0.1, 1.0, 10),
                                cv=10,
                                n_jobs=1)

繪製圖形

#  訓練曲線
train_mean = np.mean(train_scores, axis=1)
train_std = np.std(train_scores, axis=1)
#  設置x軸是資料集,而y軸是十折的平均得分
plt.plot(train_sizes,train_mean,color='blue',marker='o',markersize=5,label='Training accuracy')
#  設置訓練曲線的均值+-標準差的區塊呈現
plt.fill_between(train_sizes,train_mean + train_std, train_mean - train_std, alpha=0.15, color='blue')
#  驗證曲線
test_mean = np.mean(test_scores, axis=1)
test_std = np.std(test_scores, axis=1)
#  設置x軸是資料集,而y軸是十折的平均得分
plt.plot(train_sizes,test_mean,color='green',marker='s', linestyle='--',markersize=5,label='Validation accuracy')
#  設置驗證曲線的均值+-標準差的區塊呈現
plt.fill_between(train_sizes,test_mean + test_std, test_mean - test_std, alpha=0.15, color='green')
#  設置格線
plt.grid() 
#  設置x、y軸
plt.xlabel('Number of training samples')
plt.ylabel('Accuracy')
#  產生標識在右下
plt.legend(loc='lower right')
#  設置y軸間距
plt.ylim([0.8, 1.0])
plt.show()

從圖形可以看的出來,針對訓練資料集的部份,正負了標準差之後的區域差異不大,但在驗證資料集的部份卻並非如此,這代表著這個模型有著過適的問題。

2017年11月10日 星期五

機器學習_ML_模型指標_f1_score

機器學習_ML_模型指標_f1_score

原文連結
適用性:Classification metrics

各種的數值計算都跟上面這張圖有關。(取自(維基百科))

在資料集的正負比例相差太過極端,這種情況即稱為skewed data(偏斜)
在偏斜情況下,用精度(accaury)來做模型效能並不恰當,用召回率(recall)跟(查準率)precision配合做整理,會讓整個模型的效能更明確。
這時候f1_score就出現了!

F1 = 2 * (precision * recall) / (precision + recall)

IMPORT

from sklearn.metrics import f1_score

範例

from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score
from sklearn.metrics import confusion_matrix
y_true = [0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0 ,1]
y_pred = [0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1 ,1]
confusion_matrix(y_true=y_true, y_pred=y_pred)
precision_score(y_true, y_pred)
recall_score(y_true, y_pred)
f1_score(y_true, y_pred)

結果如下

>>> confusion_matrix(y_true=y_true, y_pred=y_pred)
array([[8, 2],
       [0, 3]], dtype=int64)
>>> precision_score(y_true, y_pred)
0.59999999999999998
>>> recall_score(y_true, y_pred)
1.0
>>> f1_score(y_true, y_pred)
0.74999999999999989

數據的部份我故意設定過,讓召回率變高,精隼率變低!
從這可以發現,高召回不代表有好的模型,因為精隼率是不高的,
透過f1_score可以更平均整個模型的效能評估。
調整一下

y_true = [0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0 ,1]
y_pred = [0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1 ,1]
confusion_matrix(y_true=y_true, y_pred=y_pred)
precision_score(y_true, y_pred)
recall_score(y_true, y_pred)
f1_score(y_true, y_pred)

上面的模型簡直完美!

>>> confusion_matrix(y_true=y_true, y_pred=y_pred)
array([[4, 1],
       [0, 8]], dtype=int64)
>>> precision_score(y_true, y_pred)
0.88888888888888884
>>> recall_score(y_true, y_pred)
1.0
>>> f1_score(y_true, y_pred)
0.94117647058823528

機器學習_ML_模型指標_precision_score

機器學習_ML_模型指標_precision_score

原文連結
適用性:Classification metrics

各種的數值計算都跟上面這張圖有關。(取自(維基百科))
PPV=TPTP+FP
在資料集的正負比例相差太過極端,這種情況即稱為skewed data(偏斜)
在偏斜情況下,用精度(accaury)來做模型效能並不恰當,用召回率(recall)跟(查準率)precision比較。

The precision is intuitively the ability of the classifier not to label as positive a sample that is negative.

查準率很直觀的表達了分類器無法標記負樣本的能力。

IMPORT

from sklearn.metrics import precision_score

範例

from sklearn.metrics import precision_score
from sklearn.metrics import confusion_matrix
y_true = [1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0 ,1]
y_pred = [0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1 ,1]
confusion_matrix(y_true=y_true, y_pred=y_pred)
precision_score(y_true, y_pred)

結果
5/(5+2)
TN FP
FN TP

array([[3, 2],
       [3, 5]], dtype=int64)
#  precision
0.7142857142857143

比對一下recall

from sklearn.metrics import recall_score
recall_score(y_true, y_pred)

結果為

>>> recall_score(y_true, y_pred)
0.625

機器學習_ML_模型指標_recall_score

機器學習_ML_模型指標_recall_score

原文連結
適用性:Classification metrics

各種的數值計算都跟上面這張圖有關。(取自(維基百科))
TP/(TP+FN)
TP/P
找到真真的的能力
召回率同意於真陽率
用意在於評估模型真的去預測到我們想要的那個部份有多好。
對於類別數據差異量很大的數據集,accuracy想必會非常漂亮,
這時候如果沒有特別的注意,會誤以為模型效能非常好。
這時候透過recall(召回)與precision(精確)來結合判斷產生f1,會是一個不錯的評估。

IMPORT

from sklearn.metrics import recall_score

範例

from sklearn.metrics import recall_score
from sklearn.metrics import confusion_matrix
y_true = [1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0 ,1]
y_pred = [0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1 ,1]
confusion_matrix(y_true=y_true, y_pred=y_pred)
recall_score(y_true, y_pred)
結果
5/(5+3)
TN FP
FN TP
array([[3, 2],
       [3, 5]], dtype=int64)
0.625
多標籤的話,就需要使用average參數
from sklearn.metrics import recall_score
y_true = [1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0 ,1]
y_pred = [0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1 ,1]
recall_score(y_true, y_pred, average='binary')  #  default 用於標籤數為2
recall_score(y_true, y_pred, average='macro')
recall_score(y_true, y_pred, average='micro')
recall_score(y_true, y_pred, average='weighted')
recall_score(y_true, y_pred, average='samples')
recall_score(y_true, y_pred, average=None)

結果
binary:0.625
macro:0.61250000000000004
micro:0.61538461538461542 
weighted:0.61538461538461542
samples:
None:[0.6, 0.625]  #  為None的時候會回傳所有LABEL的機率
micro average,微觀平均來說是取所有lable的加總計算,怎麼說,就是0與1的機率加總。
以0為主的話是3/(2+3)
以1為主的話是5/(5+3)
micro averave = (3+5)/(5+8) = 0.6153846xxxx
macro average,宏觀平均來說,就是label平均,怎麼說,當我們的average為None的時候已經幫我們算出來了,(0.6+0.625)/2,即為macro average
所以微觀來說,我們得到的數字意義在於總結對真假的真正預測性為何。
而宏觀來說即是平均性。

2017年10月23日 星期一

機器學習_ML-MLPClassifier

機器學習_ML-MLPClassifier

官方連結
This model optimizes the log-loss function using LBFGS or stochastic gradient descent.
這說明了,在sklearn中,MLP是利用隨機梯度或是LBFGS來做權重(參數)θ的計算。
神經網路是最近非常熱門的一門顯學,MLP意為多層類神經網路。何謂多層,即有輸入層、輸出層跟至少一個隱藏層。

借用了官網照片,X那層即為輸入層,OUPUT即為輸出層,中間的a即為隱藏層。
下層單元與上層各單位都會有交錯到!
一般的表示方式為a(2)代表第二層。
借用吳恩達老師上課的一個式子
a1(2)=g(Θ10(1)x0+Θ11(1)x1+Θ12(1)x2+Θ13(1)x3)
Θ的下標的部份,Θ10中的1所指為下一層所對應單元,0為這一層的對應單元。
所以a1(2)=Θ10(1)+....就是,第二層的第一個單元來自於第一層的第0+1+2+3單元的值。
注意到後面的啟動函式是Θ1。
而Θ即為權重(參數)
這邊主要談的是實用性,所以對於觀念性的部份就不多說,再另外補充。

優缺點

優點:
  • Capability to learn non-linear models.
  • Capability to learn models in real-time (on-line learning) using partial_fit.
    缺點:
  • MLP with hidden layers have a non-convex loss function where there exists more than one local minimum. Therefore different random weight initializations can lead to different validation accuracy.
  • MLP requires tuning a number of hyperparameters such as the number of hidden neurons, layers, and iterations.
  • MLP is sensitive to feature scaling.
sklearn官方說明中也提到兩個關於MLP的優點,第一點是可以學習非線性模型,第二點是可以做線上學習,所以它就會有partial_fit這個method可以使用。
缺點的部份在於,隱藏層有著non_convex的特性,所以不同的權重初始會有可能落入不同的局部最優,而非全域最優,以及MLP需調的參數很多很多,MLP對特徵縮放很敏感(記得做標準化StandardScaler(可參考官方說明搭配pipeline與gridsearchcv取alpha參數))。

IMPORT

from sklearn.neural_network import MLPClassifier

CLASS

MLPClassifier(hidden_layer_sizes=(100, ), 
              activation=’relu’, 
              solver=’adam’, 
              alpha=0.0001, 
              batch_size=’auto’, 
              learning_rate=’constant’, 
              learning_rate_init=0.001, 
              power_t=0.5, 
              max_iter=200, 
              shuffle=True, 
              random_state=None, 
              tol=0.0001, 
              verbose=False, 
              warm_start=False, 
              momentum=0.9, 
              nesterovs_momentum=True, 
              early_stopping=False, 
              validation_fraction=0.1, 
              beta_1=0.9, 
              beta_2=0.999, 
              epsilon=1e-08)

參數說明

hidden_layer_sizes=(100, 2)

default 100
隱藏層的數量

activation

default relu {identity, logistic, tanh, relu}
啟動函數
  • identity, no-op activation, useful to implement linear bottleneck, returns f(x) = x
  • logistic, the logistic sigmoid function, returns f(x) = 1 / (1 + exp(-x)).
  • tanh, the hyperbolic tan function, returns f(x) = tanh(x).
  • relu, the rectified linear unit function, returns f(x) = max(0, x)

solver

default adam {lbfgs, adam, sgd}
優化方式
官方建議,在小型的資料集中使用L-BFGS
資料集 方式
小 lbfgs
大 adam
sgd(隨機梯度下降,batch),如果學習效率(learning_rate)有調校好的話,那使用sgd的效果會較上述兩個佳。

alpha

default 0.0001
L2正規化參數

batch_size

default auto(200, n_samples)
如果solver是lbfgs,則不考慮

learning_rate

default constant {constant, invscaling, adaptive}
Only used when solver=‘sgd’.
constant:不變,依learning_rate_init
invscaling:逐漸減小,effective_learning_rate = learning_rate_init / pow(t, power_t)
adaptive:只要成本函數保持下降,那學習效率就會保持不變。但是當不能有效降低至tol,或當early_stopping=on,不能增加驗證分數的時候,那學習效率就會/5

learning_rate_init

default 0.001
Only used when solver=’sgd’ or ‘adam’.

power_t

default 0.5
Only used when solver=’sgd’.
反縮放學習效率的指數,當learning_rate=invscaling時用來更新學習效率用。

max_iter

default 200
最大迭代次數,看是先到tol還是先到max_iter。
但是在sgd與adam的時候似乎不是用於此?
For stochastic solvers (‘sgd’, ‘adam’), note that this determines the number of epochs (how many times each data point will be used), not the number of gradient steps.

shuffle

default True {True, False}
每次的迭次是否要亂數洗牌。
Only used when solver=’sgd’ or ‘adam’.

random_state

default None
隨機數種子

tol

default 0.0001
假如連續兩次的迭代無法降低成本函數,或是得分無法增加,除非learning_rate=‘adaptive’,不然就當做已經收斂完成而結束。

verbose

default 0
過程是否輸出
0不輸出
1偶爾輸出
2一定輸出

warm_start

default False {True, False}
官方說明
如果你想做更多的監控來了解模型走向的話,就可以自己寫for來配合使用。

momentum

default 0.9
配合sgd的一個動量設置,(0-1)
Δxt=ρΔxt−1−ηgt中的ρ

nesterovs_momentum

default True {True, False}
nesterovs_momentum是momentum的一個改良。
只用於sgd與momentum>0

early_stopping

default False {True, False}
設置用於當驗證得分沒有改善的時候是否要提早結束。
如果設置True的話,則會自動拿10%數據集來做驗證,當最後兩次的迭代都沒有改善的時候就會停止。
Only effective when solver=’sgd’ or ‘adam’

validation_fraction

default 0.1
驗證數據比例,early_stopping=True的時候有效。

beta_1

default 0.9(0-1)
Only used when solver=’adam’

beta_2

default 0.999(0-1)
Only used when solver=’adam’

epsilon

default 1e-8
Only used when solver=’adam’

方法

fit(X, y)

適合(訓練、擬合)資料集

get_params([deep])

取得參數

predict(X)

回傳預測分類

predict_log_proba(X)

回傳類別概率(機率、或然率)對數

predict_proba(X)

回傳類別概率(機率、或然率)

score(X, y[, sample_weight])

Returns the mean accuracy on the given test data and labels.

set_params(**params)

設置參數

partial_fit

線上適合(訓練、擬合)資料集

屬性

classes_

array or list of array of shape (n_classes,)
每個輸出的label

loss_

float
成本函數的值

coefs_

list, length n_layers - 1
第i個元素表示對應於第i層的權重矩陣。
a(j)=g(z(j))
z(j+1)=Θ(j)a(j)

intercepts_

list, length n_layers - 1
回傳第i個元素與層i+1相對應的偏置向量。
a(j)=g(z(j))
z(j+1)=Θ(j)a(j)

n_iter_

int
終止計算的時候做了幾次的迭代

n_layers_

int
這個多層神經網路有幾層

n_outputs_

int
輸出單元的數量

out_activation_

string
回傳啟動函數的名稱

範例

取自官方網站
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_mldata
from sklearn.neural_network import MLPClassifier

#  取手寫辨視的資料集
mnist = fetch_mldata("MNIST original")
# rescale the data, use the traditional train/test split
X, y = mnist.data / 255., mnist.target  #  /255的部份就單純的簡單的標準化
X_train, X_test = X[:60000], X[60000:]
y_train, y_test = y[:60000], y[60000:]

# mlp = MLPClassifier(hidden_layer_sizes=(100, 100), max_iter=400, alpha=1e-4,
#                     solver='sgd', verbose=10, tol=1e-4, random_state=1)
mlp = MLPClassifier(hidden_layer_sizes=(50,), max_iter=10, alpha=1e-4,
                    solver='sgd', verbose=10, tol=1e-4, random_state=1,
                    learning_rate_init=.1)

mlp.fit(X_train, y_train)
print("Training set score: %f" % mlp.score(X_train, y_train))
print("Test set score: %f" % mlp.score(X_test, y_test))

fig, axes = plt.subplots(4, 4)
# use global min / max to ensure all weights are shown on the same scale
vmin, vmax = mlp.coefs_[0].min(), mlp.coefs_[0].max()
for coef, ax in zip(mlp.coefs_[0].T, axes.ravel()):
    ax.matshow(coef.reshape(28, 28), cmap=plt.cm.gray, vmin=.5 * vmin,
               vmax=.5 * vmax)
    ax.set_xticks(())
    ax.set_yticks(())

plt.show()

補充說明

label over 2

如果label超過2個,那可以透過獨熱編碼轉換為輸出單位。

sklearn的MLP是那一種?

Class MLPClassifier implements a multi-layer perceptron (MLP) algorithm that trains using Backpropagation
官方說明中很清楚的表示是反向傳播。