Release Highlights for scikit-learn 0.24(翻譯)

tags: scikit-learn sklearn python machine learning Release Highlights 翻譯

原文連結

我們很高興宣佈scikit-learn 0.24的發布，其中包含許多bug的修復以及新功能!下面我們詳細說明這版本的一些主要功能。關於完整的修正清單，請參閱發行說明。

安裝最新版本(使用pip)：

pip install --upgrade scikit-learn

或者使用conda：

conda install -c conda-forge scikit-learn

Successive Halving estimators for tuning hyper-parameters

Successive Halving，當前最好的方法，現在可以用來探索參數空間並確定它們的最佳組合。HalvingGridSearchCV與HalvingRandomSearchCV可以直接拿來替代 GridSearchCVandRandomizedSearchCV。Successive Halving是一種迭代選擇的過程，如下圖所示。第一次的迭代會用少許的資源來執行，通常資源取決於訓練樣本的數量，但也可以是任意整數參數，像是隨機森林中的n_estimators。只會選擇候選參數的子集來用於下一次的迭代，而下一次的迭代會在分配資源增加的情況下執行。只會有一部份的候選參數會持續到迭代過程的最後，而最佳參數候選就會是在最後一次迭代中得分最高的那一個。

更多可參閱使用者指南(注意到，Successive Halving estimators仍然是實驗性質的。)

圖片來自Scikit-learn官方

import numpy as np

from scipy.stats import randint

from sklearn.experimental import enable_halving_search_cv  # noqa

from sklearn.model_selection import HalvingRandomSearchCV

from sklearn.ensemble import RandomForestClassifier

from sklearn.datasets import make_classification



rng = np.random.RandomState(0)



X, y = make_classification(n_samples=700, random_state=rng)



clf = RandomForestClassifier(n_estimators=10, random_state=rng)



param_dist = {"max_depth": [3, None],

              "max_features": randint(1, 11),

              "min_samples_split": randint(2, 11),

              "bootstrap": [True, False],

              "criterion": ["gini", "entropy"]}



rsh = HalvingRandomSearchCV(estimator=clf, param_distributions=param_dist,

                            factor=2, random_state=rng)

rsh.fit(X, y)

rsh.best_params_

Native support for categorical features in HistGradientBoosting estimators

HistGradientBoostingClassifier與HistGradientBoostingRegressor現在對類別屬性的特徵有原生支援：它們可以考慮對無序的分類資料做拆分。更多請參考使用者指南。

圖片來自Scikit-learn官方

此圖說明了對類別屬性的特徵新的原生支援對比處理過的(像是簡單的序數編碼)類別屬性特徵所導致的擬合時間。原生支援比起one-hot encoding與ordinal encoding表現更好。但是，要使用新的參數categorical_features之前，不免的還需要對pipeline裡面的資料做前置預處理，見範例說明。

Improved performances of HistGradientBoosting estimators

ensemble.HistGradientBoostingRegressor與ensemble.HistGradientBoostingClassifier的記憶體耗用量在呼叫fit期間明顯的改善。此外，現在直方圖的初始化可以並行完成，速度有些許的提升。更多請參閱基準頁面。

New self-training meta-estimator

一種新的self-training實現，基於Yarowski’s algorithm，可以搭配任意的分類器(該分類器必需有實作predict_proba)。子分類器會表現的像是一個半監督的分類器(semi-supervised classifier)，允許從未標記資料中學習。更多請參閱使用者指南。

import numpy as np

from sklearn import datasets

from sklearn.semi_supervised import SelfTrainingClassifier

from sklearn.svm import SVC



rng = np.random.RandomState(42)

iris = datasets.load_iris()

random_unlabeled_points = rng.rand(iris.target.shape[0]) < 0.3

iris.target[random_unlabeled_points] = -1

svc = SVC(probability=True, gamma="auto")

self_training_model = SelfTrainingClassifier(svc)

self_training_model.fit(iris.data, iris.target)

New SequentialFeatureSelector transformer

一個用於選擇特徵的迭代轉換器閃亮亮登場：SequentialFeatureSelector。Sequential Feature Selector可以一次增加一個特徵(前向選擇)或從可用特徵列表中移除一個特徵(反向選擇)，基於交叉驗證分數最大化。見使用者指南。

from sklearn.feature_selection import SequentialFeatureSelector

from sklearn.neighbors import KNeighborsClassifier

from sklearn.datasets import load_iris



X, y = load_iris(return_X_y=True, as_frame=True)

feature_names = X.columns

knn = KNeighborsClassifier(n_neighbors=3)

sfs = SequentialFeatureSelector(knn, n_features_to_select=2)

sfs.fit(X, y)

print("Features selected by forward sequential selection: "

      f"{feature_names[sfs.get_support()].tolist()}")

Out: Features selected by forward sequential selection: [‘petal length (cm)’, ‘petal width (cm)’]

New PolynomialCountSketch kernel approximation function

新的PolynomialCountSketch近似特徵空間的多項式擴展(與線性模型搭配使用的時候)，但記憶體用量較PolynomialFeatures還要少。

from sklearn.datasets import fetch_covtype

from sklearn.pipeline import make_pipeline

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import MinMaxScaler

from sklearn.kernel_approximation import PolynomialCountSketch

from sklearn.linear_model import LogisticRegression



X, y = fetch_covtype(return_X_y=True)

pipe = make_pipeline(MinMaxScaler(),

                     PolynomialCountSketch(degree=2, n_components=300),

                     LogisticRegression(max_iter=1000))

X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=5000,

                                                    test_size=10000,

                                                    random_state=42)

pipe.fit(X_train, y_train).score(X_test, y_test)

Out: 0.7336

做為比較，這邊給出使用相同資料情況下，其線性基線的分數：

linear_baseline = make_pipeline(MinMaxScaler(),

                                LogisticRegression(max_iter=1000))

linear_baseline.fit(X_train, y_train).score(X_test, y_test)

Out: 0.7137

Individual Conditional Expectation plots

一種新的部份相依圖(PDP)：個體條件期望圖(ICE)(顯示對於每一個樣本實例，當改變某一個特徵值的時候，預測結果會如何改變。)。ICE圖各別可視化在特徵上對每一個樣本預測的相依性，每個樣本一行。見使用者指南。

from sklearn.datasets import fetch_california_housing

from sklearn.inspection import plot_partial_dependence



X, y = fetch_california_housing(return_X_y=True, as_frame=True)

features = ['MedInc', 'AveOccup', 'HouseAge', 'AveRooms']

est = RandomForestRegressor(n_estimators=10)

est.fit(X, y)

display = plot_partial_dependence(

       est, X, features, kind="individual", subsample=50,

       n_jobs=3, grid_resolution=20, random_state=0

)

display.figure_.suptitle(

    'Partial dependence of house value on non-location features\n'

    'for the California housing dataset, with BayesianRidge'

)

display.figure_.subplots_adjust(hspace=0.3)

圖片來自Scikit-learn官方

New Poisson splitting criterion for DecisionTreeRegressor

The integration of Poisson regression estimation continues from version 0.23.

DecisionTreeRegressor現在支援一個新的poisson分割標準。如果你的目標是計數或頻率，那設置criterion="poisson"也許是一個不錯的選擇。

from sklearn.tree import DecisionTreeRegressor

from sklearn.model_selection import train_test_split

import numpy as np



n_samples, n_features = 1000, 20

rng = np.random.RandomState(0)

X = rng.randn(n_samples, n_features)

# positive integer target correlated with X[:, 5] with many zeros:

y = rng.poisson(lam=np.exp(X[:, 5]) / 2)

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=rng)

regressor = DecisionTreeRegressor(criterion='poisson', random_state=0)

regressor.fit(X_train, y_train)

New documentation improvements

為了不斷提升對機器學一得理解，我們已經著手增加新的範例與文件頁面：

• 新的章節關於常見陷阱與建議作法
• 範例說明如何統計比較使用GridSerchCV來評估模型效能
• 範例說明如何解釋線性模型的係數
• 範例比較Principal Component Regression(PCA，主成份回歸)與Partial Least Squares(PLS，偏最小平方法)

Release Highlights for scikit-learn 0.22(翻譯)

原文連結

我們很高興宣佈scikit-learn 0.22的發布，其中包含許多bug的修復以及新功能!下面我們詳細說明這版本的一些主要功能。關於完整的修正清單，請參閱發行說明。

使用pip安裝最新版本：

pip install --upgrade scikit-learn

或使用conda：

conda install scikit-learn

New plotting API

新的plotting API可用於建立可視化。這個新的API允許在不涉及任何重新計算情況下快速調整繪圖的視覺效果。也可以在同一個圖(figure)上加入不同圖形。下面範例說明plot_roc_curve，但支援其它繪圖工具，像是plot_partial_dependence、plot_precision_recall_curve與plot_confusion_matrix。關於這個API可參閱使用者指南。

from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import plot_roc_curve
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
import matplotlib.pyplot as plt

# 生成測試資料
X, y = make_classification(random_state=0)
# 資料集分為訓練與測試資料集
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

svc = SVC(random_state=42)
svc.fit(X_train, y_train)

rfc = RandomForestClassifier(random_state=42)
rfc.fit(X_train, y_train)

# 利用plot_roc_curve計算roc
svc_disp = plot_roc_curve(svc, X_test, y_test)
rfc_disp = plot_roc_curve(rfc, X_test, y_test, ax=svc_disp.ax_)
rfc_disp.figure_.suptitle("ROC curve comparison")

plt.show()

plot_roc_curve很快速的幫我們計算出ROC曲線，並且將兩個不同模型的結果繪製在同一張圖(figure)上，這對我們瞭解不同模型的比較非常實用。

Stacking Classifier and Regressor

StackingClassifier與StackingRegressor允許你有一個帶有最終分類器或回歸器的估計器堆疊。堆疊概括包括堆疊各別估計器的輸出，並使用一個分類器來完全最終的預測。堆疊允許使用每個各別估計器的強度，透過使用它們的輸出做為最終估計器的輸入。基礎估計器在完整的X上擬合，而最終估計器的訓練則使用cross_val_predict對基礎估計器做交叉驗證的預測。

更多資訊可參閱使用者指南

from sklearn.datasets import load_iris
from sklearn.svm import LinearSVC
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.ensemble import StackingClassifier
from sklearn.model_selection import train_test_split

X, y = load_iris(return_X_y=True)

# 利用list加入多個分類器，分類器中一樣可以設置pipeline
estimators = [
    ('rf', RandomForestClassifier(n_estimators=10, random_state=42)),
    ('svr', make_pipeline(StandardScaler(),
                          LinearSVC(random_state=42)))
]

# 實作StackingClassifier，指定最終分類器
clf = StackingClassifier(
    estimators=estimators, final_estimator=LogisticRegression()
)
# 分割資料集
X_train, X_test, y_train, y_test = train_test_split(
    X, y, stratify=y, random_state=42
)

clf.fit(X_train, y_train).score(X_test, y_test)

Permutation-based feature importance

對任一個擬合的估計器，inspection.permutation_importance可以用來得到每一個特徵的重要性的估計。

from sklearn.ensemble import RandomForestClassifier
from sklearn.inspection import permutation_importance

# 取得測試資料
X, y = make_classification(random_state=0, n_features=5, n_informative=3)

# 實作estimator
rf = RandomForestClassifier(random_state=0).fit(X, y)
# 實作permutation_importance
result = permutation_importance(rf, X, y, n_repeats=10, random_state=0,
                                n_jobs=-1)

# 定義圖表 
fig, ax = plt.subplots()
# 取得重要性均值排序
sorted_idx = result.importances_mean.argsort()
# 繪製圖表
ax.boxplot(result.importances[sorted_idx].T,
           vert=False, labels=range(X.shape[1]))
# 細部調整圖表
ax.set_title("Permutation Importance of each feature")
ax.set_ylabel("Features")
fig.tight_layout()
plt.show()

Native support for missing values for gradient boosting

ensemble.HistGradientBoostingClassifier與ensemble.HistGradientBoostingRegressor現在對缺失值(NaNs)有本機支援。這意味著在訓練或預測的時候不需要再做缺值插補。

from sklearn.experimental import enable_hist_gradient_boosting  # noqa
from sklearn.ensemble import HistGradientBoostingClassifier
import numpy as np

# 故意放一個缺值
X = np.array([0, 1, 2, np.nan]).reshape(-1, 1)
y = [0, 0, 1, 1]

gbdt = HistGradientBoostingClassifier(min_samples_leaf=1).fit(X, y)
print(gbdt.predict(X))

Precomputed sparse nearest neighbors graph

大多基於最近鄰圖的估計器現在接受預先計算的稀疏圖做為輸入，以便重覆使用同一圖進行多個估計器擬合。要在pipeline中使用這個功能，可以使用記憶體參數，以及兩個新的轉換器neighbors.KNeighborsTransformer與neighbors.RadiusNeighborsTransformer。預先計算也可以透過自定義估計器來執行做為替代的實現，像是近似最近鄰方法。更多資訊可參閱使用者指南。

from tempfile import TemporaryDirectory
from sklearn.neighbors import KNeighborsTransformer
from sklearn.manifold import Isomap
from sklearn.pipeline import make_pipeline

X, y = make_classification(random_state=0)

with TemporaryDirectory(prefix="sklearn_cache_") as tmpdir:
    estimator = make_pipeline(
        KNeighborsTransformer(n_neighbors=10, mode='distance'),
        Isomap(n_neighbors=10, metric='precomputed'),
        memory=tmpdir)
    estimator.fit(X)

    # We can decrease the number of neighbors and the graph will not be
    # recomputed.
    estimator.set_params(isomap__n_neighbors=5)
    estimator.fit(X)

KNN Based Imputation

我們現在支援使用KNN來做缺值插補。

每個樣本的缺失值都用訓練集中發現的n_neighbors個最近鄰的平均值來插補。如果兩個不缺值的特徵都很接近，則兩個樣本是接近的。預設情況下，使用支援缺失值nan_euclidean_distances的歐氏距離度量來找出最近鄰。

更多資訊可參閱使用者指南。

import numpy as np
from sklearn.impute import KNNImputer

# 故意插入空值
X = [[1, 2, np.nan], [3, 4, 3], [np.nan, 6, 5], [8, 8, 7]]
imputer = KNNImputer(n_neighbors=2)
print(imputer.fit_transform(X))

Tree pruning

在樹(tree)建構完成之後，現在可以修剪多數基於樹的估計器。修剪法是基於最小化成本複雜。更多資訊可參閱使用者指南。

X, y = make_classification(random_state=0)

rf = RandomForestClassifier(random_state=0, ccp_alpha=0).fit(X, y)
print("Average number of nodes without pruning {:.1f}".format(
    np.mean([e.tree_.node_count for e in rf.estimators_])))

rf = RandomForestClassifier(random_state=0, ccp_alpha=0.05).fit(X, y)
print("Average number of nodes with pruning {:.1f}".format(
    np.mean([e.tree_.node_count for e in rf.estimators_])))

Retrieve dataframes from OpenML

datasets.fetch_openml現在可以回傳pandas dataframe，從而正確處理帶有異質資料的資料集。

from sklearn.datasets import fetch_openml

titanic = fetch_openml('titanic', version=1, as_frame=True)
print(titanic.data.head()[['pclass', 'embarked']])

Checking scikit-learn compatibility of an estimator

開發人員可以使用check_estimator檢查他們的scikit-learn相容估計器的相容性。例如，check_estimator(LinearSVC)通過。

我們現在提供一個pytest特定的裝飾器，它允許pytest獨立執行所有檢查並報告失敗的檢查。

from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.utils.estimator_checks import parametrize_with_checks


@parametrize_with_checks([LogisticRegression, DecisionTreeRegressor])
def test_sklearn_compatible_estimator(estimator, check):
    check(estimator)

ROC AUC now supports multiclass classification

函數roc_auc_score也可以應用在多類別的分類。目前支援兩種平均策略：一對一演算法計算成對的ROC AUC分數的平均值，一對多演算法計算每個類別相對於其它類別的ROC AUC分數的平均值。這兩種情況下，多類別的ROC AUC分數都是根據模型從樣本屬於特定類別的機率估計計算而來。OvO與OvR演算法皆支援均勻加權(average='macro')，與依盛行率加權(average='weighted')。

更多資訊可參閱使用者指南。

from sklearn.datasets import make_classification
from sklearn.svm import SVC
from sklearn.metrics import roc_auc_score

X, y = make_classification(n_classes=4, n_informative=16)
clf = SVC(decision_function_shape='ovo', probability=True).fit(X, y)
print(roc_auc_score(y, clf.predict_proba(X), multi_class='ovo'))

機器學習_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],
       .....

機器學習_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()

機器學習_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

說明

官方文件
在另篇中我們說明了插補，資料插補完了以後，要面對的第二個問題就是文字特徵，甚至我們的類別都有可能是文字，怎麼辦?
這時候我們要透過編碼轉置，將文字轉成數值，讓我們往下看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)

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

機器學習_ML_樹的特徵重要性如何來的?

tags: python scikit-learn feature_importances DecisionTreeClassifier

官方程式碼

在執行決策樹或隨機森林、極限樹…等演算法之後，總是會透過feature_importances來取得特徵重要性，但是這個特徵重要性是如何來的?
程式碼是cython，從這邊可以看到，計算方式是取根的樣本權重乘上熵(或gini)減掉左右枝葉一樣計算的值，以此確認資料的不確定性消除了多少。

資訊熵是資料不確定性的度量標準，愈大代表混亂程度愈大

利用花的資料集來做驗證，如果不出樹狀圖再註解掉出圖的語法就好。

#  Import lib
from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import export_graphviz
from sklearn.datasets import load_iris
import pydotplus
import pandas as pd
import numpy as np
import random
#  載入資料
iris = load_iris()
X = iris.data
y = iris.target

#  資料轉入pandas
df = pd.DataFrame(data=X, columns=iris.feature_names)

#  確認資料狀況
df.head()

#  檢查dataframe資訊
df.info()

#  訓練模型
tree = DecisionTreeClassifier(criterion='entropy',
                                splitter='best',
                                random_state=150)
tree.fit(X, y)

#  產生樹狀圖
dot_data = export_graphviz(tree, out_file=None, 
                         feature_names=iris.feature_names,  
                         class_names=iris.target_names,  
                         filled=True, rounded=True,  
                         special_characters=True) 
graph = pydotplus.graph_from_dot_data(dot_data)
#  產生png檔
graph.write_png('sample_tree.png')

#  將特徵權重排序之後寫入dict
feature_importances_ = {}
_feat_labels = iris.feature_names
_importances = tree.feature_importances_

# 取得特徵權重排序的索引值
indices = np.argsort(_importances)[::-1]

for f in range(X.shape[1]):
    feature_importances_.update({_feat_labels[indices[f]]: _importances[indices[f]]})

#  確認特徵權重
feature_importances_

#  寫入excel，手動試算一次
writer = pd.ExcelWriter('output.xlsx')
df.to_excel(writer,'Sheet1')
writer.save()

先看一下特徵權重的數值

利用excel我們手動試算



依序計算之後，再總計特徵權重值



當然這種方式不是唯一，文獻上還是有很多不同方法來計算特徵的重要性(平均精度降低)，只是在scikit-learn上即是以此方式來處理。
以上，這樣子對樹最後產生的資訊就會有更進一步的了解了。

機器學習_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是浪費時間
• 減少正規項$\lambda$數值
  • high bias有效
• 增加正規項$\lambda$數值
  • 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()

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

機器學習_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

原文連結
適用性：Classification metrics

各種的數值計算都跟上面這張圖有關。(取自(維基百科))
$PPV=\frac{TP}{TP+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

原文連結
適用性：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
所以微觀來說，我們得到的數字意義在於總結對真假的真正預測性為何。
而宏觀來說即是平均性。