post Image
【翻訳】scikit-learn 0.18 User Guide 3.3. モデル評価:予測の質を定量化する

http://scikit-learn.org/0.18/modules/model_evaluation.html を google翻訳した

scikit-learn 0.18 ユーザーガイド 3. モデルの選択と評価 より



3.3. モデル評価:予測の質を定量化する

モデルの予測の質を評価する3つの異なるアプローチがあります。


  • 推定器スコアメソッド :推定器には、解決するように設計された問題の既定の評価基準を提供する scoreメソッドがあります。これはこのページではなく、各推定器のドキュメントに記載されています。

  • スコアリングパラメータクロスバリデーション を使用するモデル評価ツール( model_selection.cross_val_scoremodel_selection.GridSearchCV など)は、内部スコアリング戦略に依存します。これについては、スコアリングパラメータ:モデル評価ルールの定義 の節で説明します。

  • メトリック関数 :メトリックモジュールは、特定の目的のために予測エラーを評価する関数を実装します。これらのメトリックは、分類メトリック、マルチラベルランキングメトリック、回帰メトリック、およびクラスタリングメトリックに関するセクションで詳しく説明しています。

最後に、ダミー評価器は、ランダム予測のためのそれらのメトリックのベースライン値を得るのに便利です。


3.3.1. 得点パラメータ:モデル評価ルールの定義

model_selection.GridSearchCVmodel_selection.cross_val_score などのツールを使用したモデルの選択と評価では、評価指標に適用するメトリックを制御する scoring パラメータを使用します。


3.3.1.1. 一般的なケース:定義済みの値

最も一般的な使用例については、scoring パラメータを使用して得点オブジェクトを指定することができます。 以下の表はすべての可能な値を示しています。 すべてのスコアラーオブジェクトは、 より高い戻り値が低い戻り値よりも優れている という規則に従います。 したがって、 metrics.mean_squared_error のように、モデルとデータの間の距離を測定するメトリックは、メトリックの否定された値を返す neg_mean_squared_errorとして利用できます。

Scoring

Function

Comment

分類

‘accuracy’

metrics.accuracy_score

‘average_precision’

metrics.average_precision_score

‘f1’

metrics.f1_score

バイナリターゲットの場合

‘f1_micro’

metrics.f1_score

ミクロ平均化

‘f1_macro’

metrics.f1_score

マクロ平均化

‘f1_weighted’

metrics.f1_score

加重平均

‘f1_samples’

metrics.f1_score

マルチラベルサンプル

‘neg_log_loss’

metrics.log_loss

predict_proba サポートが必要です

‘precision’ etc.

metrics.precision_score

接尾辞は ‘f1’と同様に適用されます。

‘recall’ etc.

metrics.recall_score

接尾辞は ‘f1’と同様に適用されます。

‘roc_auc’

metrics.roc_auc_score

クラスタリング

‘adjusted_rand_score’

metrics.adjusted_rand_score

回帰

‘neg_mean_absolute_error’

metrics.mean_absolute_error

‘neg_mean_squared_error’

metrics.mean_squared_error

‘neg_median_absolute_error’

metrics.median_absolute_error

‘r2’

metrics.r2_score

Usage examples:

>>>

>>> from sklearn import svm, datasets
>>> from sklearn.model_selection import cross_val_score
>>> iris = datasets.load_iris()
>>> X, y = iris.data, iris.target
>>> clf = svm.SVC(probability=True, random_state=0)
>>> cross_val_score(clf, X, y, scoring='neg_log_loss')
array([-0.07..., -0.16..., -0.06...])
>>> model = svm.SVC()
>>> cross_val_score(model, X, y, scoring='wrong_choice')
Traceback (most recent call last):
ValueError: 'wrong_choice' is not a valid scoring value. Valid options are ['accuracy', 'adjusted_rand_score', 'average_precision', 'f1', 'f1_macro', 'f1_micro', 'f1_samples', 'f1_weighted', 'neg_log_loss', 'neg_mean_absolute_error', 'neg_mean_squared_error', 'neg_median_absolute_error', 'precision', 'precision_macro', 'precision_micro', 'precision_samples', 'precision_weighted', 'r2', 'recall', 'recall_macro', 'recall_micro', 'recall_samples', 'recall_weighted', 'roc_auc']


  • Note: ValueError例外によってリストされた値は、次のセクションで説明する予測精度を測定する関数に対応しています。これらの関数のスコアラーオブジェクトは、辞書sklearn.metrics.SCORERSに格納されます。


3.3.1.2. メトリック関数からスコアリング戦略を定義する

モジュール sklearn.metric はまた、実測値と予測を与えられた予測誤差を測定する単純な関数のセットを公開しています:


  • _score で終わる関数は、最大化する値を返します。

  • _error または _loss で終わる関数は、最小値に戻す値を返します。 make_scorer を使用してスコアラーオブジェクトに変換するときは、greater_is_better パラメーターをFalseに設定します(デフォルトではTrue、以下のパラメーターの説明を参照)。

    さまざまな機械学習タスクで使用できる指標については、以下のセクションで詳しく説明します。

多くのメトリックには、fbeta_score などの追加パラメータが必要な場合があるため、スコアリング値として使用する名前はありません。そのような場合は、適切なスコアリングオブジェクトを生成する必要があります。呼び出し可能なオブジェクトを生成する最も簡単な方法は、make_scorer を使用する方法です。この関数は、メトリックをモデル評価に使用できる呼び出し可能オブジェクトに変換します。

典型的な使用例の1つは、fbeta_score関数のベータパラメータなど、パラメータにデフォルト以外の値を使用してライブラリから既存のメトリック関数をラップすることです。

>>> from sklearn.metrics import fbeta_score, make_scorer

>>> ftwo_scorer = make_scorer(fbeta_score, beta=2)
>>> from sklearn.model_selection import GridSearchCV
>>> from sklearn.svm import LinearSVC
>>> grid = GridSearchCV(LinearSVC(), param_grid={'C': [1, 10]}, scoring=ftwo_scorer)

2番目のユースケースは、いくつかのパラメータを取ることができるmake_scorerを使用して単純なPython関数から完全にカスタムのscorerオブジェクトを構築することです:

– 使用するPython関数(下の例の my_custom_loss_func

– python関数がスコアを返すかどうか(デフォルト greater_is_better = True)、または損失( greater_is_better = False)を返します。 損失の場合は、scorerオブジェクトによって、python関数の出力が無効になり、スコアラーはより良いモデルに対して高い値を返します。

– 分類メトリクスのみ:あなたが提供したPython関数が継続的な意思決定の確実性を必要とするかどうか( needs_threshold = True ) デフォルト値はFalseです。

– ベータや f1_score のラベルなどの追加パラメータ。

カスタムスコアラーを作成し、greater_is_betterパラメーターを使用する例を次に示します。

>>> import numpy as np

>>> def my_custom_loss_func(ground_truth, predictions):
... diff = np.abs(ground_truth - predictions).max()
... return np.log(1 + diff)
...
>>> # loss_funcは、my_custom_loss_funcの戻り値を無効にします。
>>> # これは、ground_truthの値と下で定義された予測がある場合、np.log(2)、0.693になります。
>>> loss = make_scorer(my_custom_loss_func, greater_is_better=False)
>>> score = make_scorer(my_custom_loss_func, greater_is_better=True)
>>> ground_truth = [[1, 1]]
>>> predictions = [0, 1]
>>> from sklearn.dummy import DummyClassifier
>>> clf = DummyClassifier(strategy='most_frequent', random_state=0)
>>> clf = clf.fit(ground_truth, predictions)
>>> loss(clf,ground_truth, predictions)
-0.69...
>>> score(clf,ground_truth, predictions)
0.69...


3.3.1.3. 独自の採点オブジェクトの実装

make_scorer ファクトリを使用せずに、独自のスコアリングオブジェクトをゼロから構築することで、より柔軟なモデルスコアラーを生成することができます。呼び出し可能オブジェクトがスコアラーであるためには、以下の2つのルールで指定されたプロトコルを満たす必要があります。

(estimator, X, y)で呼び出すことができること。estimator は評価すべきモデルであり、X は検証データであり、 yX(教師ありの場合)または None(教師なしの場合)の実測値ターゲット。

y を参照して、X 上の estimator 予測品質を定量化する浮動小数点数を返すこと。繰り返しになりますが、慣例では数値が高いほど良いので、スコアラーが損失を返す場合は、その値を無効にする必要があります。


3.3.2. 分類メトリック

sklearn.metrics モジュールは、分類パフォーマンスを測定するいくつかの損失、スコア、およびユーティリティ関数を実装します。一部のメトリックでは、正のクラス、信頼値、またはバイナリ決定値の確率推定が必要な場合があります。ほとんどの実装では、 sample_weight パラメータを使用して、各サンプルがスコア全体に重み付けされた寄与をすることができます。

これら、バイナリ分類の場合に制限されています:

matthews_corrcoef(y_true、y_pred [、…])

バイナリクラスのMatthews相関係数(MCC)を計算する

precision_recall_curve(y_true、probas_pred)

さまざまな確率しきい値に対する適合率 – 再現率のペアを計算する

roc_curve(y_true、y_score [、pos_label、…])

受信機の動作特性(ROC)を計算する

これらはマルチクラスでも機能する:

cohen_kappa_score(y1、y2 [、labels、weights])

Cohen’s kappa:アノテータ間の合意を測定する統計。

confusion_matrix(y_true、y_pred [、labels、…])

分類の精度を評価するための混同行列を計算する

hinge_loss(y_true、pred_decision [、labels、…])

平均ヒンジ・ロス(非正規化)

これらはマルチラベルの場合にも機能する:

accuracy_score(y_true、y_pred [、normalize、…])

精度分類スコア。

classification_report(y_true、y_pred [、…])

主要分類メトリックを示すテキストレポートを作成します

f1_score(y_true、y_pred [、labels、…])

F1スコアを計算します。これはバランスFスコアまたはFメジャーとも呼ばれます

fbeta_score(y_true、y_pred、beta [、labels、…])

Fベータスコアを計算する

hamming_loss(y_true、y_pred [、labels、…])

平均ハミング損失を計算します。

jaccard_similarity_score(y_true、y_pred [、…])

Jaccard類似度スコア

log_loss(y_true、y_pred [、eps、normalize、…])

ログの損失、別名ロジスティック損失またはクロスエントロピー損失。

precision_recall_fscore_support(y_true、y_pred)

各クラスの適合率、再現率、F-measureおよびサポートを計算する

precision_score(y_true、y_pred [、labels、…])

適合率を計算する

recall_score(y_true、y_pred [、labels、…])

再現率を計算する

zero_one_loss(y_true、y_pred [、normalize、…])

ゼロの分類損。

これらは、バイナリとマルチラベル(マルチクラスではない)で機能する

average_precision_score(y_true、y_score [、…])

予測スコアから平均精度(AP)

roc_auc_score(y_true、y_score [、average、…])

予測スコアからの曲線下面積(AUC)

以下のサブセクションでは、これらの関数のそれぞれについて説明し、共通のAPIとメトリックの定義についていくつかの注意を先取りします。


3.3.2.1. バイナリからマルチクラス、マルチラベルまで

基本的に、バイナリ分類タスクのためにいくつかのメトリックが定義されています( f1_scoreroc_auc_score など)。このような場合、デフォルトではポジティブ・ラベルのみが評価され、ポジティブ・クラスは1とラベル付けされています( pos_label パラメータで構成可能ですが)。

バイナリメトリックをマルチクラスまたはマルチラベルの問題に拡張する場合、データはバイナリの問題のコレクションとして扱われます(クラスごとに1つ)。いくつかのシナリオでは有用な、クラスのセット全体でバイナリメトリック計算を平均化する方法はいくつかあります。可能であれば、average パラメータを使用してこれらの中から選択する必要があります。


  • "macro" はバイナリメトリックの平均を計算し、各クラスに等しい重みを与えます。それにもかかわらず、頻度の低いクラスが重要な問題では、マクロ平均化がパフォーマンスを強調する手段になる可能性があります。一方、すべてのクラスが同じように重要であるという前提は、しばしば真実ではないため、マクロ平均は、まれなクラスでは一般的に低いパフォーマンスを過度に強調することになります。

  • "weighted" 各クラスのスコアが真のデータサンプル内に存在することによって重み付けされたバイナリメトリックの平均を計算することによって、クラスの不均衡を「重み付け」する。

    "micro" は、各サンプルクラスのペアに、全体的なメトリックに等しく寄与します(サンプルウェイトの結果を除いて)。クラスごとのメトリックを合計するのではなく、クラスごとのメトリックを構成する配当および除数を合計して、全体の商を計算します。マイクロアベレージングは​​、多数クラスを無視するマルチクラス分類を含む、マルチラベル設定で優先される場合があります。

    "samples"はマルチラベル問題にのみ適用されます。代わりに、評価データの各サンプルの真のクラスと予測されたクラスのメトリックを計算し、その(sample_weight – weighted)平均を返します。

  • average = None を選択すると、各クラスのスコアを含む配列が返されます。

マルチクラス・データは、バイナリ・ターゲットのようにメトリックにクラス・ラベルの配列として提供されますが、マルチラベル・データは、サンプルiがラベルjを持つ場合はcell [i、j] が値1を、そうでない場合は0を返します 。


3.3.2.2. 精度スコア

accuracy_score 関数は、正確な予測の割合(デフォルト)またはカウント(normalize=False)のいずれかを計算します。

マルチラベル分類では、この関数はサブセットの精度を返します。 サンプルの予測ラベルのセット全体が実際のラベルセットと厳密に一致する場合、サブセット精度は1.0です。 それ以外の場合は0.0です。

\texttt{accuracy}(y, \hat{y}) = \frac{1}{n_\text{samples}} \sum_{i=0}^{n_\text{samples}-1} 1(\hat{y}_i = y_i)

ここで、 $1(x)$ は指標関数です。

>>> import numpy as np

>>> from sklearn.metrics import accuracy_score
>>> y_pred = [0, 2, 1, 3]
>>> y_true = [0, 1, 2, 3]
>>> accuracy_score(y_true, y_pred)
0.5
>>> accuracy_score(y_true, y_pred, normalize=False)
2

バイナリラベルインジケータを使用したマルチラベルの場合:

>>> accuracy_score(np.array([[0, 1], [1, 1]]), np.ones((2, 2)))

0.5


3.3.2.3. カッパ係数

関数 cohen_kappa_score は、カッパ係数 を計算します。この尺度は、異なる人間の注釈者によるラベリングを比較することを目的としています。

κスコア(docstring参照)は-1と1の間の数値です.8以上のスコアは一般的に良い一致とみなされます。ゼロ以下は、合意がないことを意味する(事実上ランダムなラベル)。

κスコアは、バイナリまたはマルチクラスの問題については計算できますが、マルチラベルの問題(ラベルごとのスコアを手動で計算する場合を除く)ではなく、2つ以上の注釈では計算できません。

>>> from sklearn.metrics import cohen_kappa_score

>>> y_true = [2, 0, 2, 2, 0, 1]
>>> y_pred = [0, 0, 2, 2, 0, 2]
>>> cohen_kappa_score(y_true, y_pred)
0.4285714285714286


3.3.2.4. 混同行列

confusion_matrix関数は、混同行列を計算することによって分類精度を評価します。

定義上、混同行列のエントリ $i,j$ は、グループ $i$ の実際の観測数ですが、グループ $j$ に属すると予測されます。 次に例を示します。

>>> from sklearn.metrics import confusion_matrix

>>> y_true = [2, 0, 2, 2, 0, 1]
>>> y_pred = [0, 0, 2, 2, 0, 2]
>>> confusion_matrix(y_true, y_pred)
array([[2, 0, 0],
[0, 0, 1],
[1, 0, 2]])

このような混同行列を視覚的に表したものです(この図は混同行列の例です)。

バイナリの問題については、以下のように、真陰性、偽陽性、偽陰性および真陽性のカウントを得ることができます。


3.3.2.5. 分類レポート

classification_report 関数は、主要分類メトリックを示すテキストレポートを作成します。 カスタム target_names と推定ラベルの小さな例を次に示します。

>>> from sklearn.metrics import classification_report

>>> y_true = [0, 1, 2, 2, 0]
>>> y_pred = [0, 0, 2, 1, 0]
>>> target_names = ['class 0', 'class 1', 'class 2']
>>> print(classification_report(y_true, y_pred, target_names=target_names))
precision recall f1-score support

class 0 0.67 1.00 0.80 2
class 1 0.00 0.00 0.00 1
class 2 1.00 0.50 0.67 2

avg / total 0.67 0.60 0.59 5


3.3.2.6. ハミング損失

hamming_lossは、2組のサンプル間の平均ハミング損失またはハミング距離を計算します。

$\hat{y}j$ が与えられたサンプルの $j$ 番目のラベルの予測値である場合、 $y_j$ は対応する真の値であり、$n\text{labels}$ はクラスまたはラベルの数であり、ハミング損失 $L_{Hamming}$ は、以下のように定義される。

L_{Hamming}(y, \hat{y}) = \frac{1}{n_\text{labels}} \sum_{j=0}^{n_\text{labels} - 1} 1(\hat{y}_j \not= y_j)

ここで、 $1(x)$ は指標関数です。

>>> from sklearn.metrics import hamming_loss

>>> y_pred = [1, 2, 3, 4]
>>> y_true = [2, 2, 3, 4]
>>> hamming_loss(y_true, y_pred)
0.25

バイナリラベルインジケータを使用したマルチラベルの場合:

>>>

>>> hamming_loss(np.array([[0, 1], [1, 1]]), np.zeros((2, 2)))
0.75

(注) マルチクラス分類では、ハミング損失は、 ゼロワン損失 関数に類似する y_truey_pred の間のハミング距離に対応します。しかし、1対1の損失は、真のセットに厳密に一致しない予測セットにペナルティを課すが、ハミング損失は個々のラベルに不利益をもたらす。したがって、ゼロ1の損失によって上限が決定されるハミング損失は、常に0と1との間であり、真のラベルの適切なサブセットまたはスーパーセットを予測することは、ゼロと1との間のハミング損失を排除することになる。


3.3.2.7. ジャカード類似性係数スコア

jaccard_similarity_score 関数は、ペアのラベルセット間のJaccardインデックスとも呼ばれる Jaccard類似性係数 の平均(デフォルト)または合計を計算します。

実測値ラベルセット $y_i$ と予測ラベルセット $\hat{y}_i$ を持つ $i$ 番目のサンプルのJaccard類似度係数は、次のように定義されます。

J(y_i, \hat{y}_i) = \frac{|y_i \cap \hat{y}_i|}{|y_i \cup \hat{y}_i|}.

バイナリおよびマルチクラス分類では、Jaccard類似度係数スコアは分類精度に等しい。

>>> import numpy as np

>>> from sklearn.metrics import jaccard_similarity_score
>>> y_pred = [0, 2, 1, 3]
>>> y_true = [0, 1, 2, 3]
>>> jaccard_similarity_score(y_true, y_pred)
0.5
>>> jaccard_similarity_score(y_true, y_pred, normalize=False)
2

バイナリラベルインジケータを使用したマルチラベルの場合:

>>>

>>> jaccard_similarity_score(np.array([[0, 1], [1, 1]]), np.ones((2, 2)))
0.75


3.3.2.8. 適合率、再現率、F-値(F-measure)

直観的には、適合率 は、分類器が否定的なサンプルを陽性とラベル付けしないようにする能力であり、再現率は、分類器がすべての陽性サンプルを見つける能力である。

F-値( $F_β$ および $F_1$ measures)は、適合率および再現率の加重調和平均として解釈することができます。 $\beta = 1$ の場合、$F_\beta$ と $F_1$ は等価であり、再現率と適合率は同じように重要です。

precision_recall_curve は、真理値ラベルからの適合率-再現率カーブと、判定閾値を変化させることによって分類器によって与えられたスコアを計算する。

average_precision_score 関数は、予測スコアから平均適合率(AP)を計算します。このスコアは、適合率 – 再現率曲線下の面積に相当します。値は0と1の間であり、より高い方が良いです。ランダム予測では、APは正のサンプルの割合です。

いくつかの機能を使用して,適合率,再現率,F-値 のスコアを分析することができます。

average_precision_score(y_true,y_score [,…])

予測スコアから平均適合率(AP)を計算する

f1_score(y_true,y_pred [,labels,…])

F1スコアを計算します。これはバランスFスコアまたはFメジャーとも呼ばれます

fbeta_score(y_true,y_pred,beta [,labels,…])

Fベータスコアを計算する

precision_recall_curve(y_true,probas_pred)

さまざまな確率しきい値に対する適合率 – 再現率のペアを計算する

precision_recall_fscore_support(y_true,y_pred)

各クラスの適合率,再現率,F-measureおよびサポートを計算する

precision_score(y_true,y_pred [,labels,…])

適合率を計算する

recall_score(y_true,y_pred [,labels,…])

再現率を計算する

precision_recall_curve 関数はバイナリの場合に制限されていることに注意してください。 average_precision_score 関数は,バイナリ分類およびマルチラベルインジケータ形式でのみ機能します。

average_precision_score(y_true,y_score [,…])

予測スコアから平均精度(AP)を計算する

f1_score(y_true,y_pred [,labels,…])

F1スコアを計算します。これはバランスFスコアまたはFメジャーとも呼ばれます

fbeta_score(y_true,y_pred,beta [,labels,…])

Fベータスコアを計算する

precision_recall_curve(y_true,probas_pred)

さまざまな確率のしきい値に対する適合率 – 再現率のペアを計算する

precision_recall_fscore_support(y_true,y_pred)

各クラスの適合率,再現率,F値およびサポートを計算する

precision_score(y_true,y_pred [,labels,…])

適合率を計算する

recall_score(y_true,y_pred [,labels,…])

再現率を計算する

precision_recall_curve関数はバイナリの場合に制限されていることに注意してください。

average_precision_score関数は,バイナリ分類およびマルチラベルインジケータ形式でのみ機能します。

precision_recall_curve関数はバイナリの場合に制限されていることに注意してください。 average_precision_score関数は、バイナリ分類およびマルチラベルインジケータ形式でのみ機能します。

例:

テキスト文書を分類するf1_scoreの使用例については、スパース関数を使用したテキスト文書の分類を参照してください。

ネストされた相互検証でグリッド検索を使用してパラメータを推定するためのprecision_scoreおよびrecall_scoreの使用例については、クロス検証によるグリッド検索を使用したパラメータ推定を参照してください。

分類器の出力品質を評価するためのprecision_recall_curveの使用例については、Precision-Recallを参照してください。

スパース線形モデルのフィーチャを選択するためのprecision_recall_curveの使用例については、スパースリニアモデルのスパースリカバリ:フィーチャ選択を参照してください。


3.3.2.8.1. 二値分類

二値分類タスクでは、「陽性」および「陰性」という用語は分類器の予測を示し、「真」および「偽」という用語は、その予測が外部の判断に対応するかどうかを示す「観察」とも呼ばれる)。これらの定義が与えられた場合、次の表を作成できます。

実際のクラス(観測)

予測クラス(期待値)

tp(真陽性)正しい結果

fp(偽陽性)予期しない結果

fn(偽陰性)欠落した結果

tn(真陰性)結果が正しくない

この文脈では、適合率、再現率、F-値という概念を定義することができます。

\text{precision} = \frac{tp}{tp + fp}, \\

\text{recall} = \frac{tp}{tp + fn}, \\
F_\beta = (1 + \beta^2) \frac{\text{precision} \times \text{recall}}{\beta^2 \text{precision} + \text{recall}}.

二値分類の小さな例をいくつか挙げます:

>>> from sklearn import metrics

>>> y_pred = [0, 1, 0, 0]
>>> y_true = [0, 1, 0, 1]
>>> metrics.precision_score(y_true, y_pred)
1.0
>>> metrics.recall_score(y_true, y_pred)
0.5
>>> metrics.f1_score(y_true, y_pred)
0.66...
>>> metrics.fbeta_score(y_true, y_pred, beta=0.5)
0.83...
>>> metrics.fbeta_score(y_true, y_pred, beta=1)
0.66...
>>> metrics.fbeta_score(y_true, y_pred, beta=2)
0.55...
>>> metrics.precision_recall_fscore_support(y_true, y_pred, beta=0.5)
(array([ 0.66..., 1. ]), array([ 1. , 0.5]), array([ 0.71..., 0.83...]), array([2, 2]...))

>>> import numpy as np
>>> from sklearn.metrics import precision_recall_curve
>>> from sklearn.metrics import average_precision_score
>>> y_true = np.array([0, 0, 1, 1])
>>> y_scores = np.array([0.1, 0.4, 0.35, 0.8])
>>> precision, recall, threshold = precision_recall_curve(y_true, y_scores)
>>> precision
array([ 0.66..., 0.5 , 1. , 1. ])
>>> recall
array([ 1. , 0.5, 0.5, 0. ])
>>> threshold
array([ 0.35, 0.4 , 0.8 ])
>>> average_precision_score(y_true, y_scores)
0.79...


3.3.2.8.2. マルチクラスとマルチラベルの分類

マルチクラスおよびマルチラベル分類タスクでは、適合率、再現率、F値の概念を各ラベルに個別に適用できます。上記のようにaverage_precision_score(multilabelのみ)、f1_scorefbeta_scoreprecision_recall_fscore_supportprecision_score、およびrecall_score関数のaverage引数で指定されたラベル間で結果を結合するには、いくつかの方法があります。すべてのラベルが含まれているマルチクラス設定での “micro” 平均化では、等しい適合率、再現率、F値が生成されますが、 “weighted” 平均化では適合率と再現率の間にないFスコアが生成されることに注意してください。

これをより明示的にするには、次の表記法を検討してください。

  • $y$ は予測された $(sample, label)$ のペアの集合
  • $\hat{y}$ は $true(sample, label)$ の組の集合
  • $L$ はラベルのセット
  • $S$ はサンプルセット
  • $y_s$ はyのサブセット、すなわち $y_s := \left\{(s’, l) \in y | s’ = s\right\}$
  • $y_l$ はラベル $l$ の $y$ のサブセット
  • 同様に、$\hat{y}_s$ と $\hat {y}_l$ は $\hat{y}$ のサブセットです
  • $P(A, B) := \frac{\left| A \cap B \right|}{\left|A\right|}$
  • $R(A, B) := \frac{\left| A \cap B \right|}{\left|B\right|}$ (表記規則は、 $B = \emptyset$ の取り扱いによって異なります。 この実装は $R(A, B):=0$ を使用し、 $P$ も同様です)。
  • $F_\beta(A, B) := \left(1 + \beta^2\right) \frac{P(A, B) \times R(A, B)}{\beta^2 P(A, B) + R(A, B)}$

次に、メトリックは次のように定義されます。

average

Precision

Recall

F_beta

"micro" $P(y, \hat{y})$ $R(y, \hat{y})$ $F_\beta(y, \hat{y})$

"samples"

$\frac{1}{\left|S\right|} \sum_{s \in S} P(y_s, \hat{y}_s)$

$\frac{1}{\left|S\right|} \sum_{s \in S} R(y_s, \hat{y}_s)$

$\frac{1}{\left|S\right|} \sum_{s \in S} F_\beta(y_s, \hat{y}_s)$

"macro"

$\frac{1}{\left|L\right|} \sum_{l \in L} P(y_l, \hat{y}_l)$

$\frac{1}{\left|L\right|} \sum_{l \in L} R(y_l, \hat{y}_l)$

$\frac{1}{\left|L\right|} \sum_{l \in L} F_\beta(y_l, \hat{y}_l)$

"weighted"

$\frac{1}{\sum_{l \in L} \left|\hat{y}_l\right|} \sum_{l \in L} \left|\hat{y}_l\right| P(y_l, \hat{y}_l)$

$\frac{1}{\sum_{l \in L} \left|\hat{y}_l\right|} \sum_{l \in L} \left|\hat{y}_l\right| R(y_l, \hat{y}_l)$

$\frac{1}{\sum_{l \in L} \left|\hat{y}_l\right|} \sum_{l \in L} \left|\hat{y}_l\right| F_\beta(y_l, \hat{y}_l)$

None

$\langle P(y_l, \hat{y}_l) | l \in L \rangle$

$\langle R(y_l, \hat{y}_l) | l \in L \rangle$

$\langle F_\beta(y_l, \hat{y}_l) | l \in L \rangle$

>>> from sklearn import metrics

>>> y_true = [0, 1, 2, 0, 1, 2]
>>> y_pred = [0, 2, 1, 0, 0, 1]
>>> metrics.precision_score(y_true, y_pred, average='macro')
0.22...
>>> metrics.recall_score(y_true, y_pred, average='micro')
...
0.33...
>>> metrics.f1_score(y_true, y_pred, average='weighted')
0.26...
>>> metrics.fbeta_score(y_true, y_pred, average='macro', beta=0.5)
0.23...
>>> metrics.precision_recall_fscore_support(y_true, y_pred, beta=0.5, average=None)
...
(array([ 0.66..., 0. , 0. ]), array([ 1., 0., 0.]), array([ 0.71..., 0. , 0. ]), array([2, 2, 2]...))

「ネガティブクラス」を含むマルチクラス分類では、いくつかのラベルを除外することができます。

>>>

>>> metrics.recall_score(y_true, y_pred, labels=[1, 2], average='micro')
... # excluding 0, no labels were correctly recalled
0.0

同様に、データサンプル中に存在しないラベルは、マクロ平均化において説明され得る。

>>>

>>> metrics.precision_score(y_true, y_pred, labels=[0, 1, 2, 3], average='macro')
...
0.166...


3.3.2.9. ヒンジ損失

hinge_loss 関数は、予測誤差のみを考慮する片側メトリックである ヒンジ損失 を使用して、モデルとデータ間の平均距離を計算します。 (ヒンジ損失は、サポートベクターマシンなどの最大マージン分類器で使用されます)。

ラベルが+1および-1でエンコードされている場合、$y:$ は真の値であり、 $w$ は decision_function の出力としての予測された決定であり、ヒンジ損失は次のように定義されます。

L_\text{Hinge}(y, w) = \max\left\{1 - wy, 0\right\} = \left|1 - wy\right|_+

2つ以上のラベルがある場合、hinge_lossはCrammer&Singerのためにマルチクラスの変形を使用します。ここにそれを記述する論文があります

$y_w$ が真のラベルの予測された決定であり、 $y_t$ が、決定関数によって予測された決定が出力される他のすべてのラベルの予測された決定の最大値である場合、マルチクラスヒンジ損失は、

L_\text{Hinge}(y_w, y_t) = \max\left\{1 + y_t - y_w, 0\right\}

ここでは、バイナリクラスの問題でsvm分類器でhinge_loss関数を使用する方法を示す小さな例を示します。

>>> from sklearn import svm

>>> from sklearn.metrics import hinge_loss
>>> X = [[0], [1]]
>>> y = [-1, 1]
>>> est = svm.LinearSVC(random_state=0)
>>> est.fit(X, y)
LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
intercept_scaling=1, loss='squared_hinge', max_iter=1000,
multi_class='ovr', penalty='l2', random_state=0, tol=0.0001,
verbose=0)
>>> pred_decision = est.decision_function([[-2], [3], [0.5]])
>>> pred_decision
array([-2.18..., 2.36..., 0.09...])
>>> hinge_loss([-1, 1, 1], pred_decision)
0.3...

多クラスの問題で、svm分類器でhinge_loss関数を使用する例を以下に示します:

>>>

>>> X = np.array([[0], [1], [2], [3]])
>>> Y = np.array([0, 1, 2, 3])
>>> labels = np.array([0, 1, 2, 3])
>>> est = svm.LinearSVC()
>>> est.fit(X, Y)
LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
intercept_scaling=1, loss='squared_hinge', max_iter=1000,
multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,
verbose=0)
>>> pred_decision = est.decision_function([[-1], [2], [3]])
>>> y_true = [0, 2, 3]
>>> hinge_loss(y_true, pred_decision, labels)
0.56...


3.3.2.10. ログ損失

ロジスティック回帰ロスまたはクロスエントロピーロスとも呼ばれるログ損失は、確率推定で定義されます。これは、(多項式)ロジスティック回帰およびニューラルネットワークならびに予想最大化のいくつかの変形例で一般的に使用され、離散的予測の代わりに分類器の確率出力(predict_proba)を評価するために使用することができる。

真のラベル $y \in {0,1}$ および確率推定 $ p = \operatorname{Pr}(y = 1)$ を有するバイナリ分類の場合、サンプル当たりのログ損失は、真のラベルが与えられた分類器の負の対数尤度である。

L_{\log}(y, p) = -\log \operatorname{Pr}(y|p) = -(y \log (p) + (1 - y) \log (1 - p))

これは以下のようにマルチクラスの場合にまで及ぶ。サンプルセットに対する真のラベルをK個のバイナリインジケータ行列 $Y$ の1つとして符号化する。すなわち、サンプルiがK個のラベルのセットから取られたラベルkを有する場合、 $ y_{i,k} = 1$ である。 $P$ を確率推定の行列とし、 $p_{i,k} = \operatorname{Pr}(t_{i,k} = 1)$ とする。 すると、集合全体の対数損失は

L_{\log}(Y, P) = -\log \operatorname{Pr}(Y|P) = - \frac{1}{N} \sum_{i=0}^{N-1} \sum_{k=0}^{K-1} y_{i,k} \log p_{i,k}

これがバイナリの場合、$ p_{i,0} = 1 – p_{i,1}$ と $y_{i,0} = 1 – y_{i,1}$ したがって、内部合計を $y_{i,k} \in {0,1}$ より大きくすると、バイナリログ損失が得られます。

log_loss 関数は、推定値の predict_proba メソッドによって返されるように、グランド真理値ラベルと確率行列のリストが与えられたときのログ損失を計算します。

>>> from sklearn.metrics import log_loss

>>> y_true = [0, 0, 1, 1]
>>> y_pred = [[.9, .1], [.8, .2], [.3, .7], [.01, .99]]
>>> log_loss(y_true, y_pred)
0.1738...

y_predの最初の [.9, .1] は、最初のサンプルがラベル0を持つ確率が90%であることを示します。ログ損失は負ではありません。


3.3.2.11. マシューズ相関係数

matthews_corrcoef 関数は、バイナリクラスのマシュー相関係数(MCC)を計算します。引用Wikipedia:

Matthewsの相関係数は、バイナリ(2クラス)分類の品質の尺度として機械学習で使用されます。真陽性と陰陰陽性と陰性を考慮し、クラスが非常に異なるサイズであっても使用できるバランスの取れた尺度と一般的にみなされます。 MCCは、本質的に、-1と+1との間の相関係数値である。 + 1の係数は完全予測を表し、0は平均ランダム予測を表し、-1は逆予測を表す。統計は、φ係数としても知られています。

$tp$ 、$tn$ 、$fp$ および $fn$ がそれぞれ真陽性、真陰性、偽陽性および偽陰性の数である場合、MCC係数は

MCC = \frac{tp \times tn - fp \times fn}{\sqrt{(tp + fp)(tp + fn)(tn + fp)(tn + fn)}}.

matthews_corrcoef関数の使い方を示す小さな例を次に示します。

>>>

>>> sklearn.metricsからのインポートmatthews_corrcoef
>>> y_true = [+1+1+1-1]
>>> y_pred = [+1-1+1+1]
>>> matthews_corrcoefy_truey_pred
-0.33 ...


3.3.2.12. レシーバ動作特性(ROC)

関数roc_curve は、受信者動作特性曲線またはROCカーブ を計算します。引用Wikipedia:

受信機動作特性(ROC)、または単純にROC曲線は、識別閾値が変化するときのバイナリ分類システムの性能を示すグラフプロットである。これは、さまざまな閾値設定で、陽性からの真陽性の割合(TPR =真陽性率)対陰性からの偽陽性の割合(FPR =偽陽性率)をプロットすることによって作成されます。 TPRは感受性としても知られており、FPRは特異性または真の負の率から1を引いたものです。

この関数は、真のバイナリ値と目標スコアを必要とします。これは、陽性クラスの確率推定値、信頼値、またはバイナリ決定のいずれかです。 roc_curve関数を使用する方法の小さな例を次に示します。

>>> import numpy as np

>>> from sklearn.metrics import roc_curve
>>> y = np.array([1, 1, 2, 2])
>>> scores = np.array([0.1, 0.4, 0.35, 0.8])
>>> fpr, tpr, thresholds = roc_curve(y, scores, pos_label=2)
>>> fpr
array([ 0. , 0.5, 0.5, 1. ])
>>> tpr
array([ 0.5, 0.5, 1. , 1. ])
>>> thresholds
array([ 0.8 , 0.4 , 0.35, 0.1 ])

この図は、そのようなROC曲線の例を示しています。

roc_auc_score 関数は、AUCまたはAUROCで表される受信機動作特性(ROC)カーブの下の面積を計算します。 roc曲線下の面積を計算することにより、曲線情報が1つの数にまとめられます。 詳細は、AUCに関するWikipediaの記事 を参照してください。

>>> import numpy as np

>>> from sklearn.metrics import roc_auc_score
>>> y_true = np.array([0, 0, 1, 1])
>>> y_scores = np.array([0.1, 0.4, 0.35, 0.8])
>>> roc_auc_score(y_true, y_scores)
0.75

マルチラベル分類では、上記のようにラベルを平均化することによってroc_auc_score関数が拡張されます。

サブセット精度、ハミング損失、F1スコアなどのメトリックと比較して、ROCでは各ラベルのしきい値を最適化する必要はありません。 予測された出力が2進化されている場合、roc_auc_score関数をマルチクラス分類で使用することもできます。


3.3.2.13. 0-1損失

zero_one_loss 関数は、$n_{\text{samples}}$ に対する0-1分類損失 $ (L_{0-1})$ の和または平均を計算します。 デフォルトでは、関数はサンプルに対して正規化されます。 $ L_{0-1}$ の和を求めるには、normalizeFalse に設定します。

マルチラベル分類では、 zero_one_loss は、そのラベルが予測と厳密に一致する場合にはサブセットを1としてスコア付けし、エラーがある場合にはゼロとしてスコア付けします。 デフォルトでは、この関数は不完全に予測されたサブセットの割合を返します。 そのようなサブセットの数を代わりに取得するには、normalizeFalse に設定します

$\hat {y} i$ が $i$ 番目のサンプルの予測値であり、 $y_i$ が対応する真の値である場合、0-1損失 $L {0-1}$ は次のように定義されます。

L_{0-1}(y_i, \hat{y}_i) = 1(\hat{y}_i \not= y_i)

ここで、 $1(x)$ は指標関数です。

>>> from sklearn.metrics import zero_one_loss

>>> y_pred = [1, 2, 3, 4]
>>> y_true = [2, 2, 3, 4]
>>> zero_one_loss(y_true, y_pred)
0.25
>>> zero_one_loss(y_true, y_pred, normalize=False)
1

バイナリラベルインジケータを持つマルチラベルの場合、最初のラベルセット[0,1]にエラーがあります。

>>>

>>> zero_one_loss(np.array([[0, 1], [1, 1]]), np.ones((2, 2)))
0.5

>>> zero_one_loss(np.array([[0, 1], [1, 1]]), np.ones((2, 2)), normalize=False)
1


3.3.2.14. Brierスコア損失

brier_score_loss 関数は、バイナリクラスの Brierスコア を計算します。引用Wikipedia:

Brierスコアは、確率的予測の精度を測定する適切なスコア関数です。予測が相互排他的離散結果の集合に確率を割り当てる必要があるタスクに適用できます。

この関数は、実際の結果と可能な結果の予測される確率との間の平均二乗差のスコアを返します。実際の結果は1または0(真または偽)である必要がありますが、実際の結果の予測確率は0と1の間の値になります。

brierスコアの損失も0〜1であり、スコアが低いほど(平均平方差が小さいほど)、予測がより正確である。これは、確率的予測のセットの「射程距離測定」の尺度と考えることができる。

BS = \frac{1}{N} \sum_{t=1}^{N}(f_t - o_t)^2

ここで、 $N$ は予測の総数であり、 $f_t$ は実際の結果 $o_t$ の予測される確率である。

この関数の使い方の小さな例を次に示します::

>>> import numpy as np

>>> from sklearn.metrics import brier_score_loss
>>> y_true = np.array([0, 1, 1, 0])
>>> y_true_categorical = np.array(["spam", "ham", "ham", "spam"])
>>> y_prob = np.array([0.1, 0.9, 0.8, 0.4])
>>> y_pred = np.array([0, 1, 1, 0])
>>> brier_score_loss(y_true, y_prob)
0.055
>>> brier_score_loss(y_true, 1-y_prob, pos_label=0)
0.055
>>> brier_score_loss(y_true_categorical, y_prob, pos_label="ham")
0.055
>>> brier_score_loss(y_true, y_prob > 0.5)
0.0


3.3.3. マルチラベルランキングメトリック

マルチラベル学習では、各サンプルには、それに関連するグラウンド・トゥルー・ラベルをいくつでも持つことができます。ゴールは高い得点を与え、地上の真理値札にランク付けすることです。


3.3.3.1. カバレッジエラー

coverage_error 関数は、全ての真のラベルが予測されるように、最終的な予測に含まれなければならないラベルの平均数を計算する。これは、真の値を失わずに平均で予測しなければならないトップスコアラベルの数を知りたい場合に便利です。したがって、このメトリックの最良の値は、真のラベルの平均数です。

公式には、グラウンドトゥルースラベル の2進インジケータ行列と各ラベル に関連付けられたスコアが与えられると、カバレッジは以下のように定義される。

公式には、グラウンドトゥルースラベル $ y \in \left\{0, 1\right\}^{n_\text{samples} \times n_\text{labels}}$ の2進インジケータ行列と各ラベル $\hat{f} \in \mathbb{R}^{n_\text{samples} \times n_\text{labels}}$ に関連付けられたスコアが与えられると、カバレッジは

coverage(y, \hat{f}) = \frac{1}{n_{\text{samples}}}

\sum_{i=0}^{n_{\text{samples}} - 1} \max_{j:y_{ij} = 1} \text{rank}_{ij}

で $\text{rank}_{ij} = \left|\left\{k: \hat{f}_{ik} \geq \hat{f}_{ij} \right\}\right|$ と定義されます。 ランクの定義が与えられると、y_scoresの結びつきは、すべての結び付けられた値に割り当てられる最大ランクを与えることによって壊されます。

この関数の使い方の小さな例を次に示します::

>>> import numpy as np

>>> from sklearn.metrics import coverage_error
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> coverage_error(y_true, y_score)
2.5


3.3.3.2. ラベルランクの平均適合率

label_ranking_average_precision_score 関数は、ラベルランク平均適合率(LRAP)を実装します。このメトリックは average_precision_score 関数にリンクされていますが、適合率と再現率の代わりにラベルのランク付けの概念に基づいています。

ラベルランク平均精度(LRAP)は、各サンプルに割り当てられた各グランド・トゥルース・ラベルの平均値であり、スコアの低い真のラベルと総ラベルの比率です。このメトリックは、各サンプルに関連付けられたラベルのランクを上げることができれば、スコアが向上します。得られたスコアは常に厳密に0より大きく、最良の値は1です。サンプルあたり1つの関連ラベルが正確にある場合、ラベルランキング平均適合率は 平均逆数ランク に相当します。

正式には、地上の真理値表の二項目の指標行列 $\mathcal {R} ^ {n_ \text {samples} \times n_ \text{labels}}$ と各ラベル $\hat {f} \ \mathcal {R} ^ {n_ \ text {samples} \ times n_ \text {labels}}$ では、平均精度は次のように定義されます。

LRAP(y, \hat{f}) = \frac{1}{n_{\text{samples}}}

\sum_{i=0}^{n_{\text{samples}} - 1} \frac{1}{|y_i|}
\sum_{j:y_{ij} = 1} \frac{|\mathcal{L}_{ij}|}{\text{rank}_{ij}}

$\mathcal{L}_{ij} = \left\{k: y_{ik} = 1, \hat{f}_{ik} \geq \hat{f}_{ij} \right\}$, $\text{rank}_{ij} = \left|\left\{k: \hat{f}_{ik} \geq \hat{f}_{ij} \right\}\right| $ そして $|\cdot|$ が l0ノルムまたはセットの基数である。

この関数の使用例を以下に示します。

>>> import numpy as np

>>> from sklearn.metrics import label_ranking_average_precision_score
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> label_ranking_average_precision_score(y_true, y_score)
0.416...


3.3.3.3. ランキング損失

label_ranking_loss 関数は、誤って順序づけられたラベルペアの数、すなわち真のラベルが偽のラベルよりもスコアが低く、偽のラベルと真のラベルの逆数で重み付けされたラベルのペアの数を平均するランキング損失を計算する。達成可能な最低ランキング損失はゼロです。

公式は、地面真理ラベル $ y \in \left\{0, 1\right\}^{n_\text{samples} \times n_\text{labels}}$ の2進インジケータ行列と各ラベル $ \hat{f} \in \mathbb{R}^{n_\text{samples} \times n_\text{labels}}$ に関連付けられたスコアが与えられた場合、ランキング損失は

\text{ranking\_loss}(y, \hat{f}) =  \frac{1}{n_{\text{samples}}}

\sum_{i=0}^{n_{\text{samples}} - 1} \frac{1}{|y_i|(n_\text{labels} - |y_i|)}
\left|\left\{(k, l): \hat{f}_{ik} < \hat{f}_{il}, y_{ik} = 1, y_{il} = 0 \right\}\right|

ここで、$ |\cdot| $ は、 $ \ell_0$ ノルムまたは集合の基数である。

この関数の使用例を以下に示します。

>>> import numpy as np

>>> from sklearn.metrics import label_ranking_loss
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> label_ranking_loss(y_true, y_score)
0.75...
>>> # With the following prediction, we have perfect and minimal loss
>>> y_score = np.array([[1.0, 0.1, 0.2], [0.1, 0.2, 0.9]])
>>> label_ranking_loss(y_true, y_score)
0.0


3.3.4. 回帰メトリック

sklearn.metrics モジュールは、回帰のパフォーマンスを測定するためのいくつかの損失、スコア、およびユーティリティ関数を実装しています。 mean_squared_errormean_absolute_errorexplain_variance_score、および r2_score のように、複数出力の場合を処理するように拡張されているものがあります。

これらの関数には、個々のターゲットのスコアまたは損失を平均する方法を指定する multioutputキーワード引数があります。デフォルトは 'uniform_average' です。これは、出力に対して均一に重み付けされた平均を指定します。シェイプが (n_outputs、)ndarray が渡された場合、そのエントリは重みとして解釈され、それに応じた加重平均が返されます。 multioutput'raw_values' の場合、変更されていない個々のスコアや損失はすべてシェイプ(n_outputs,) の配列 で返されます。

r2_score と explain_variance_score は、multioutput パラメータに対して追加の値 'variance_weighted' を受け入れます。このオプションは、対応するターゲット変数の分散による個々のスコアの重み付けにつながります。この設定は、グローバルにキャプチャされたスケーリングされていない分散を定量化します。目標変数のスケールが異なる場合、このスコアは分散変数が高いことをよく説明する上で重要です。 multioutput = 'variance_weighted' は下位互換性のためにr2_scoreのデフォルト値です。これは将来、'uniform_average' に変更されます。


3.3.4.1. 説明変数スコア

explain_variance_scoreは、説明変数回帰スコア を計算します。

$\hat {y}$ が推定された目標出力であり、 $y$ が対応する(正しい)目標出力であり、 $Var$ が標準偏差の2乗である分散である場合、説明変数は次のように推定される。

\texttt{explained_variance}(y, \hat{y}) = 1 - \frac{Var\{ y - \hat{y}\}}{Var\{y\}}

最高得点は1.0で、値が低いほど悪いです。

次に、explain_variance_score関数の使用例を示します。

>>> from sklearn.metrics import explained_variance_score

>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> explained_variance_score(y_true, y_pred)
0.957...
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> explained_variance_score(y_true, y_pred, multioutput='raw_values')
...
array([ 0.967..., 1. ])
>>> explained_variance_score(y_true, y_pred, multioutput=[0.3, 0.7])
...
0.990...


3.3.4.2. 平均絶対誤差

mean_absolute_error 関数は、平均絶対誤差、絶対誤差損失または $l1$ ノルム損失の期待値に対応するリスクメトリックを計算します。

$\hat {y} _i$ が $i$ 番目のサンプルの予測値であり、 $y_i$ が対応する真の値である場合、$ n_{\text{samples}}$ で推定された平均絶対誤差(MAE)は次のように定義されます。

\text{MAE}(y, \hat{y}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}}-1} \left| y_i - \hat{y}_i \right|.

mean_absolute_error関数の使用例を以下に示します。

>>> from sklearn.metrics import mean_absolute_error

>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> mean_absolute_error(y_true, y_pred)
0.5
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> mean_absolute_error(y_true, y_pred)
0.75
>>> mean_absolute_error(y_true, y_pred, multioutput='raw_values')
array([ 0.5, 1. ])
>>> mean_absolute_error(y_true, y_pred, multioutput=[0.3, 0.7])
...
0.849...


3.3.4.3. 平均二乗誤差

mean_squared_error 関数は、二乗(二次)エラー損失または損失の期待値に対応するリスク・メトリックである 平均二乗誤差 を計算します。

$\hat {y} _i$ が $i$ 番目のサンプルの予測値であり、 $y_i$ が対応する真の値である場合、 $ n_{\text{samples}}$ で推定された平均二乗誤差(MSE)は次のように定義されます。

\text{MSE}(y, \hat{y}) = \frac{1}{n_\text{samples}} \sum_{i=0}^{n_\text{samples} - 1} (y_i - \hat{y}_i)^2.

以下に、mean_squared_error関数の使用例を示します。

>>> from sklearn.metrics import mean_squared_error

>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> mean_squared_error(y_true, y_pred)
0.375
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> mean_squared_error(y_true, y_pred)
0.7083...

  • 例:

    • 勾配ブースティング回帰を評価するための二乗平均誤差の使用例については、勾配ブースト回帰 を参照してください。


3.3.4.4. 中央絶対誤差

median_absolute_error は特に異常値に対して堅牢であるため興味深いです。損失は​​、ターゲットと予測との間のすべての絶対差の中央値を取ることによって計算される。

$\hat {y} _i$ が $i$ 番目のサンプルの予測値であり、 $y_i$ が対応する真の値である場合、 $ n_{\text{samples}} $ で推定されたメジアン絶対誤差(MedAE)は次のように定義されます。

\text{MedAE}(y, \hat{y}) = \text{median}(\mid y_1 - \hat{y}_1 \mid, \ldots, \mid y_n - \hat{y}_n \mid).

median_absolute_errorはマルチ出力をサポートしていません。

次に、median_absolute_error関数の使用例を示します。

>>> from sklearn.metrics import median_absolute_error

>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> median_absolute_error(y_true, y_pred)
0.5


3.3.4.5. R²スコア、決定係数

r2_score 関数は、決定係数 であるR²を計算します。これは、将来のサンプルがモデルによって予測される可能性が高いことの指標を提供します。可能な最高得点は1.0であり、負であり得る(モデルが任意に悪化する可能性があるため)。入力特徴量を無視してyの期待値を常に予測する定数モデルでは、R ^ 2スコアが0.0になります。

$\ hat {y} _i$ が $i$ 番目のサンプルの予測値であり、 $y_i$ が対応する真の値である場合、 $n_{\text{samples}}$ で推定されたスコアR²は次のように定義されます。

R^2(y, \hat{y}) = 1 - \frac{\sum_{i=0}^{n_{\text{samples}} - 1} (y_i - \hat{y}_i)^2}{\sum_{i=0}^{n_\text{samples} - 1} (y_i - \bar{y})^2}

$\bar{y} = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}} – 1} y_i$. です。

次に、r2_score関数の使用例を示します。

>>> from sklearn.metrics import r2_score

>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> r2_score(y_true, y_pred)
0.948...
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> r2_score(y_true, y_pred, multioutput='variance_weighted')
...
0.938...
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> r2_score(y_true, y_pred, multioutput='uniform_average')
...
0.936...
>>> r2_score(y_true, y_pred, multioutput='raw_values')
...
array([ 0.965..., 0.908...])
>>> r2_score(y_true, y_pred, multioutput=[0.3, 0.7])
...
0.925...

  • 例:


3.3.5. クラスタリングメトリック

sklearn.metricsモジュールは、いくつかの損失、スコア、およびユーティリティ関数を実装しています。詳細については、インスタンスクラスタリングの クラスタリングパフォーマンス評価 セクション、およびバイクラスタリングの Biclustering評価 を参照してください。


3.3.6. ダミー見積もり

教師あり学習をするとき、単純な健全性チェックは、推定器を単純な経験則と比較することから成ります。 DummyClassifier は、分類のためのこのような単純な戦略をいくつか実装しています。


  • stratified は、トレーニングセットクラス分布を尊重することによってランダム予測を生成する。

  • most_frequent は、トレーニングセット内の最も頻繁なラベルを常に予測します。

  • prior は常にclassを最大にするクラスを(most_frequentのように)予測し、 predict_proba はクラスを先に返します。

  • uniform はランダムに一様に予測を生成します。

  • constant常にユーザーが提供する定数ラベルを予測として返します。

    • この方法の主な動機は、ポジティブなクラスが少数派である場合にF1スコアリングである。

これらのすべての戦略では、 predict メソッドは入力データを完全に無視します。

DummyClassifierを説明するには、まず不均衡なデータセットを作成しましょう:

>>> from sklearn.datasets import load_iris

>>> from sklearn.model_selection import train_test_split
>>> iris = load_iris()
>>> X, y = iris.data, iris.target
>>> y[y != 1] = -1
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

次に、SVCmost_frequent の精度を比較してみましょう。

>>> from sklearn.dummy import DummyClassifier

>>> from sklearn.svm import SVC
>>> clf = SVC(kernel='linear', C=1).fit(X_train, y_train)
>>> clf.score(X_test, y_test)
0.63...
>>> clf = DummyClassifier(strategy='most_frequent',random_state=0)
>>> clf.fit(X_train, y_train)
DummyClassifier(constant=None, random_state=0, strategy='most_frequent')
>>> clf.score(X_test, y_test)
0.57...

私たちは、SVCがダミーの分類器よりもはるかに優れていないことがわかります。さて、カーネルを変更しましょう:

>>> clf = SVC(kernel='rbf', C=1).fit(X_train, y_train)

>>> clf.score(X_test, y_test)
0.97...

精度はほぼ100%に向上しました。 CPUのコストがそれほど高くない場合は、精度をより正確に評価するために、クロスバリデーションを推奨します。詳細については、 クロスバリデーション:見積もりパフォーマンスの評価 セクションを参照してください。さらに、パラメータ空間を最適化する場合は、適切な方法を使用することを強くお勧めします。詳細については、推定器のハイパーパラメータのチューニング セクションを参照してください。

より一般的には、分類器の精度がランダムに近すぎると、何かが間違っている可能性があります。特徴量が役立たず、ハイパーパラメータが正しく調整されていない、分類器がクラスの不均衡などに苦しんでいます。

DummyRegressor はまた、回帰のための4つの簡単な経験則を実装しています。


  • mean は常に訓練目標の平均を予測する。

  • median は常に訓練目標の中央値を予測する。

  • quantile は、常に、ユーザーが訓練目標の分位点を提供することを予測します。

  • constant は、常にユーザーによって提供される一定の値を予測として返します。

これらの戦略すべてにおいて、predict メソッドは入力データを完全に無視する。


scikit-learn 0.18 ユーザーガイド 3. モデルの選択と評価 より

©2010 – 2016、scikit-learn developers(BSDライセンス)。


『 Python 』Article List