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

http://scikit-learn.org/0.18/modules/model_evaluation.html を google翻訳した
[scikit-learn 0.18 ユーザーガイド 3. モデルの選択と評価](http://qiita.com/nazoking@github/items/267f2371757516f8c168#3-%E3%83%A2%E3%83%87%E3%83%AB%E3%81%AE%E9%81%B8%E6%8A%9E%E3%81%A8%E8%A9%95%E4%BE%A1) より

----

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

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

  - **推定器スコアメソッド** ：推定器には、解決するように設計された問題の既定の評価基準を提供する `score`メソッドがあります。これはこのページではなく、各推定器のドキュメントに記載されています。
  - **スコアリングパラメータ** ： [クロスバリデーション](http://qiita.com/nazoking@github/items/13b167283590f512d99a) を使用するモデル評価ツール（ [model_selection.cross_val_score](http://scikit-learn.org/0.18/modules/generated/sklearn.model_selection.cross_val_score.html#sklearn.model_selection.cross_val_score) や [model_selection.GridSearchCV](http://scikit-learn.org/0.18/modules/generated/sklearn.model_selection.GridSearchCV.html#sklearn.model_selection.GridSearchCV) など）は、内部スコアリング戦略に依存します。これについては、[スコアリングパラメータ：モデル評価ルールの定義](#331-%E5%BE%97%E7%82%B9%E3%83%91%E3%83%A9%E3%83%A1%E3%83%BC%E3%82%BF%E3%83%A2%E3%83%87%E3%83%AB%E8%A9%95%E4%BE%A1%E3%83%AB%E3%83%BC%E3%83%AB%E3%81%AE%E5%AE%9A%E7%BE%A9) の節で説明します。
  - **メトリック関数** ：メトリックモジュールは、特定の目的のために予測エラーを評価する関数を実装します。これらのメトリックは、分類メトリック、マルチラベルランキングメトリック、回帰メトリック、およびクラスタリングメトリックに関するセクションで詳しく説明しています。

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

 - **参照:** 「ペアごとの」メトリック、サンプルと推定値または予測との間の違いについては、[ペアワイズメトリック、アフィニティおよびカーネル](http://scikit-learn.org/0.18/modules/metrics.html#metrics)のセクションを参照してください。

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

[model_selection.GridSearchCV](http://scikit-learn.org/0.18/modules/generated/sklearn.model_selection.GridSearchCV.html#sklearn.model_selection.GridSearchCV) や [model_selection.cross_val_score](http://scikit-learn.org/0.18/modules/generated/sklearn.model_selection.cross_val_score.html#sklearn.model_selection.cross_val_score) などのツールを使用したモデルの選択と評価では、評価指標に適用するメトリックを制御する `scoring` パラメータを使用します。

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

最も一般的な使用例については、`scoring` パラメータを使用して得点オブジェクトを指定することができます。 以下の表はすべての可能な値を示しています。 すべてのスコアラーオブジェクトは、 **より高い戻り値が低い戻り値よりも優れている** という規則に従います。 したがって、 [metrics.mean_squared_error](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.mean_squared_error.html#sklearn.metrics.mean_squared_error) のように、モデルとデータの間の距離を測定するメトリックは、メトリックの否定された値を返す neg_mean_squared_errorとして利用できます。
   
| Scoring | Function | Comment |
| --- | --- | --- |
| **分類** |
| ‘accuracy’ | [`metrics.accuracy_score`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.accuracy_score.html#sklearn.metrics.accuracy_score "sklearn.metrics.accuracy_score") |
| ‘average_precision’ | [`metrics.average_precision_score`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.average_precision_score.html#sklearn.metrics.average_precision_score "sklearn.metrics.average_precision_score") |
| ‘f1’ | [`metrics.f1_score`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score "sklearn.metrics.f1_score") | バイナリターゲットの場合 |
| ‘f1_micro’ | [`metrics.f1_score`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score "sklearn.metrics.f1_score") | ミクロ平均化 |
| ‘f1_macro’ | [`metrics.f1_score`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score "sklearn.metrics.f1_score") | マクロ平均化 |
| ‘f1_weighted’ | [`metrics.f1_score`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score "sklearn.metrics.f1_score") | 加重平均 |
| ‘f1_samples’ | [`metrics.f1_score`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score "sklearn.metrics.f1_score") | マルチラベルサンプル |
| ‘neg_log_loss’ | [`metrics.log_loss`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.log_loss.html#sklearn.metrics.log_loss "sklearn.metrics.log_loss") | `predict_proba` サポートが必要です |
| ‘precision’ etc. | [`metrics.precision_score`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.precision_score.html#sklearn.metrics.precision_score "sklearn.metrics.precision_score") | 接尾辞は 'f1'と同様に適用されます。 |
| ‘recall’ etc. | [`metrics.recall_score`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.recall_score.html#sklearn.metrics.recall_score "sklearn.metrics.recall_score") | 接尾辞は 'f1'と同様に適用されます。 |
| ‘roc_auc’ | [`metrics.roc_auc_score`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.roc_auc_score.html#sklearn.metrics.roc_auc_score "sklearn.metrics.roc_auc_score") |
| **クラスタリング** |
| ‘adjusted_rand_score’ | [`metrics.adjusted_rand_score`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.adjusted_rand_score.html#sklearn.metrics.adjusted_rand_score "sklearn.metrics.adjusted_rand_score") |
| **回帰** |
| ‘neg_mean_absolute_error’ | [`metrics.mean_absolute_error`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.mean_absolute_error.html#sklearn.metrics.mean_absolute_error "sklearn.metrics.mean_absolute_error") |
| ‘neg_mean_squared_error’ | [`metrics.mean_squared_error`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.mean_squared_error.html#sklearn.metrics.mean_squared_error "sklearn.metrics.mean_squared_error") |
| ‘neg_median_absolute_error’ | [`metrics.median_absolute_error`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.median_absolute_error.html#sklearn.metrics.median_absolute_error "sklearn.metrics.median_absolute_error") |
| ‘r2’ | [`metrics.r2_score`](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.r2_score.html#sklearn.metrics.r2_score "sklearn.metrics.r2_score") |

Usage examples:

```python
>>>
>>> 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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.make_scorer.html#sklearn.metrics.make_scorer) を使用してスコアラーオブジェクトに変換するときは、`greater_is_better` パラメーターをFalseに設定します（デフォルトではTrue、以下のパラメーターの説明を参照）。
さまざまな機械学習タスクで使用できる指標については、以下のセクションで詳しく説明します。

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

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

```python
>>> 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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score) のラベルなどの追加パラメータ。

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

```python
>>> 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` は検証データであり、 `y` は `X`（教師ありの場合）または `None`（教師なしの場合）の実測値ターゲット。
  - `y` を参照して、`X` 上の `estimator` 予測品質を定量化する浮動小数点数を返すこと。繰り返しになりますが、慣例では数値が高いほど良いので、スコアラーが損失を返す場合は、その値を無効にする必要があります。

## 3.3.2. 分類メトリック

[sklearn.metrics](http://scikit-learn.org/0.18/modules/classes.html#module-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_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score) 、 [roc_auc_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.roc_auc_score.html#sklearn.metrics.roc_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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.accuracy_score.html#sklearn.metrics.accuracy_score) 関数は、正確な予測の割合（デフォルト）またはカウント（`normalize=False`）のいずれかを計算します。
マルチラベル分類では、この関数はサブセットの精度を返します。 サンプルの予測ラベルのセット全体が実際のラベルセットと厳密に一致する場合、サブセット精度は1.0です。 それ以外の場合は0.0です。

```math
\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)$ は[指標関数](https://en.wikipedia.org/wiki/Indicator_function)です。

```python
>>> 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
```

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

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

  - 例：
    - データセットの順列を使用した精度スコアの使用例の[分類スコアの重要性を順列でテストする](http://scikit-learn.org/0.18/auto_examples/feature_selection/plot_permutation_test_for_classification.html#sphx-glr-auto-examples-feature-selection-plot-permutation-test-for-classification-py) を参照してください。

### 3.3.2.3. カッパ係数

関数 [cohen_kappa_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.cohen_kappa_score.html#sklearn.metrics.cohen_kappa_score) は、[カッパ係数](https://en.wikipedia.org/wiki/Cohen%27s_kappa) を計算します。この尺度は、異なる人間の注釈者によるラベリングを比較することを目的としています。
κスコア（docstring参照）は-1と1の間の数値です.8以上のスコアは一般的に良い一致とみなされます。ゼロ以下は、合意がないことを意味する（事実上ランダムなラベル）。
κスコアは、バイナリまたはマルチクラスの問題については計算できますが、マルチラベルの問題（ラベルごとのスコアを手動で計算する場合を除く）ではなく、2つ以上の注釈では計算できません。

```python
>>> 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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.confusion_matrix.html#sklearn.metrics.confusion_matrix)関数は、[混同行列](https://en.wikipedia.org/wiki/Confusion_matrix)を計算することによって分類精度を評価します。
定義上、混同行列のエントリ $i,j$ は、グループ $i$ の実際の観測数ですが、グループ $j$ に属すると予測されます。 次に例を示します。

```python
>>> 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]])
```

このような混同行列を視覚的に表したものです（この図は[混同行列](http://scikit-learn.org/0.18/auto_examples/model_selection/plot_confusion_matrix.html#sphx-glr-auto-examples-model-selection-plot-confusion-matrix-py)の例です）。

![](http://scikit-learn.org/0.18/_images/sphx_glr_plot_confusion_matrix_0011.png)

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

  - 例：
    - 混同行列を使用して分類子の出力品質を評価する例については、「[混同行列](http://scikit-learn.org/0.18/auto_examples/model_selection/plot_confusion_matrix.html#sphx-glr-auto-examples-model-selection-plot-confusion-matrix-py)」を参照してください。
    - 手書き数字を分類するために混同行列を使用する例については、[手書き数字の認識](http://scikit-learn.org/0.18/auto_examples/classification/plot_digits_classification.html#sphx-glr-auto-examples-classification-plot-digits-classification-py)を参照してください。
    - 混同行列を使用してテキスト文書を分類する例については、[スパース関数を使用したテキスト文書の分類](http://scikit-learn.org/0.18/auto_examples/text/document_classification_20newsgroups.html#sphx-glr-auto-examples-text-document-classification-20newsgroups-py)を参照してください。

### 3.3.2.5. 分類レポート

[classification_report](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.classification_report.html#sklearn.metrics.classification_report) 関数は、主要分類メトリックを示すテキストレポートを作成します。 カスタム `target_names` と推定ラベルの小さな例を次に示します。

```pycon
>>> 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
```

  - 例：
    - 手書き数字の分類レポートの使用例については、[手書き数字の認識](http://scikit-learn.org/0.18/auto_examples/classification/plot_digits_classification.html#sphx-glr-auto-examples-classification-plot-digits-classification-py)を参照してください。
    - テキスト文書の分類レポートの使用例については、[スパース関数を使用したテキスト文書の分類](http://scikit-learn.org/0.18/auto_examples/text/document_classification_20newsgroups.html#sphx-glr-auto-examples-text-document-classification-20newsgroups-py)を参照してください。
    - ネストされた相互検証によるグリッド検索の分類レポートの使用例については、[相互検証付きグリッド検索を使用したパラメータ推定](http://scikit-learn.org/0.18/auto_examples/model_selection/grid_search_digits.html#sphx-glr-auto-examples-model-selection-grid-search-digits-py)を参照してください。

### 3.3.2.6. ハミング損失

[hamming_loss](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.hamming_loss.html#sklearn.metrics.hamming_loss)は、2組のサンプル間の平均ハミング損失またはハミング距離を計算します。
 $\hat{y}_j$ が与えられたサンプルの $j$ 番目のラベルの予測値である場合、 $y_j$ は対応する真の値であり、$n_\text{labels}$ はクラスまたはラベルの数であり、ハミング損失 $L_{Hamming}$ は、以下のように定義される。

```math
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)$ は[指標関数](https://en.wikipedia.org/wiki/Indicator_function)です。

```python
>>> 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
```

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

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

**（注）** マルチクラス分類では、ハミング損失は、 [ゼロワン損失](#33213-%E3%82%BC%E3%83%AD1%E3%81%A4%E3%81%AE%E6%90%8D%E5%A4%B1) 関数に類似する `y_true` と `y_pred` の間のハミング距離に対応します。しかし、1対1の損失は、真のセットに厳密に一致しない予測セットにペナルティを課すが、ハミング損失は個々のラベルに不利益をもたらす。したがって、ゼロ1の損失によって上限が決定されるハミング損失は、常に0と1との間であり、真のラベルの適切なサブセットまたはスーパーセットを予測することは、ゼロと1との間のハミング損失を排除することになる。

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

[jaccard_similarity_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.jaccard_similarity_score.html#sklearn.metrics.jaccard_similarity_score) 関数は、ペアのラベルセット間のJaccardインデックスとも呼ばれる [Jaccard類似性係数](https://en.wikipedia.org/wiki/Jaccard_index) の平均（デフォルト）または合計を計算します。
実測値ラベルセット $y_i$ と予測ラベルセット $\hat{y}_i$ を持つ $i$ 番目のサンプルのJaccard類似度係数は、次のように定義されます。

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

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

```python
>>> 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
```

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

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

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

直観的には、[適合率](https://en.wikipedia.org/wiki/Precision_and_recall#Precision) は、分類器が否定的なサンプルを陽性とラベル付けしないようにする能力であり、[再現率](https://en.wikipedia.org/wiki/Precision_and_recall#Recall)は、分類器がすべての陽性サンプルを見つける能力である。
F-値（ $F_β$ および $F\_1$ measures）は、適合率および再現率の加重調和平均として解釈することができます。 $\beta = 1$ の場合、$F_\beta$ と $F\_1$ は等価であり、再現率と適合率は同じように重要です。
[precision_recall_curve](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve) は、真理値ラベルからの適合率-再現率カーブと、判定閾値を変化させることによって分類器によって与えられたスコアを計算する。
[average_precision_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.average_precision_score.html#sklearn.metrics.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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve) 関数はバイナリの場合に制限されていることに注意してください。 [average_precision_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.average_precision_score.html#sklearn.metrics.average_precision_score) 関数は,バイナリ分類およびマルチラベルインジケータ形式でのみ機能します。

  - 例：
    - テキスト文書を分類する [f1_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score) の使用例については、[スパース関数を使用したテキスト文書の分類](http://scikit-learn.org/0.18/auto_examples/text/document_classification_20newsgroups.html#sphx-glr-auto-examples-text-document-classification-20newsgroups-py)を参照してください。
    - ネストされた相互検証でグリッド検索を使用してパラメータを推定するための [precision_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.precision_score.html#sklearn.metrics.precision_score) および [recall_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.recall_score.html#sklearn.metrics.recall_score) の使用例については、[クロス検証によるグリッド検索を使用したパラメータ推定](http://scikit-learn.org/0.18/auto_examples/model_selection/grid_search_digits.html#sphx-glr-auto-examples-model-selection-grid-search-digits-py) を参照してください。
    - 分類器の出力品質を評価するための [precision_recall_curve](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve) の使用例については、[Precision-Recall](http://scikit-learn.org/0.18/auto_examples/model_selection/plot_precision_recall.html#sphx-glr-auto-examples-model-selection-plot-precision-recall-py) を参照してください。
    - スパース線形モデルのフィーチャを選択するための [precision_recall_curve](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve) の使用例については、[スパースリニアモデルのスパースリカバリ：フィーチャ選択](http://scikit-learn.org/0.18/auto_examples/linear_model/plot_sparse_recovery.html#sphx-glr-auto-examples-linear-model-plot-sparse-recovery-py) を参照してください。

|  |  |
|-----|------|
|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-値という概念を定義することができます。

```math
\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}}.
```

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

```py
>>> 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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.average_precision_score.html#sklearn.metrics.average_precision_score)（multilabelのみ）、[f1_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score)、[fbeta_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.fbeta_score.html#sklearn.metrics.fbeta_score)、[precision_recall_fscore_support](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.precision_recall_fscore_support.html#sklearn.metrics.precision_recall_fscore_support)、[precision_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.precision_score.html#sklearn.metrics.precision_score)、および[recall_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.recall_score.html#sklearn.metrics.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)}$

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

<table>
<thead>
<tr><th>average</th>
<th>Precision</th>
<th>Recall</th>
<th>F_beta</th>
</tr>
</thead>
<tbody>
<tr><td><code>"micro"</code></td> <td>$P(y, \hat{y})$ </td> <td>$R(y, \hat{y})$ </td> <td>$F_\beta(y, \hat{y})$ </td> </tr>
<tr><td> <code>"samples"</code> </td>
<td>$\frac{1}{\left|S\right|} \sum_{s \in S} P(y_s, \hat{y}_s)$ </td>
<td>$\frac{1}{\left|S\right|} \sum_{s \in S} R(y_s, \hat{y}_s)$ </td>
<td>$\frac{1}{\left|S\right|} \sum_{s \in S} F_\beta(y_s, \hat{y}_s)$ </td>
</tr>
<tr><td><code>"macro"</code></td>
<td>$\frac{1}{\left|L\right|} \sum_{l \in L} P(y_l, \hat{y}_l)$ </td>
<td>$\frac{1}{\left|L\right|} \sum_{l \in L} R(y_l, \hat{y}_l)$ </td>
<td>$\frac{1}{\left|L\right|} \sum_{l \in L} F_\beta(y_l, \hat{y}_l)$ </td>
</tr>
<tr><td><code>"weighted"</code></td>
<td>$\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)$ </td>
<td>$\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)$ </td>
<td>$\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)$ </td>
</tr>
<tr><td><code>None</code></td>
<td>$\langle P(y_l, \hat{y}_l) | l \in L \rangle$ </td>
<td>$\langle R(y_l, \hat{y}_l) | l \in L \rangle$ </td>
<td>$\langle F_\beta(y_l, \hat{y}_l) | l \in L \rangle$ </td>
</tr>
</tbody>
</table>


```python
>>> 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]...))
```

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

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

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

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

### 3.3.2.9. ヒンジ損失

[hinge_loss](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.hinge_loss.html#sklearn.metrics.hinge_loss) 関数は、予測誤差のみを考慮する片側メトリックである [ヒンジ損失](https://en.wikipedia.org/wiki/Hinge_loss) を使用して、モデルとデータ間の平均距離を計算します。 （ヒンジ損失は、サポートベクターマシンなどの最大マージン分類器で使用されます）。
ラベルが+1および-1でエンコードされている場合、$y：$ は真の値であり、 $w$ は `decision_function` の出力としての予測された決定であり、ヒンジ損失は次のように定義されます。

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

2つ以上のラベルがある場合、hinge_lossはCrammer＆Singerのためにマルチクラスの変形を使用します。[ここにそれを記述する論文があります](http://jmlr.csail.mit.edu/papers/volume2/crammer01a/crammer01a.pdf)。
$y_w$ が真のラベルの予測された決定であり、 $y_t$ が、決定関数によって予測された決定が出力される他のすべてのラベルの予測された決定の最大値である場合、マルチクラスヒンジ損失は、

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

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

```python
>>> 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関数を使用する例を以下に示します:

```python
>>>
>>> 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)$ を有するバイナリ分類の場合、サンプル当たりのログ損失は、真のラベルが与えられた分類器の負の対数尤度である。

```math
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)$ とする。 すると、集合全体の対数損失は

```math
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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.log_loss.html#sklearn.metrics.log_loss) 関数は、推定値の `predict_proba` メソッドによって返されるように、グランド真理値ラベルと確率行列のリストが与えられたときのログ損失を計算します。


```python
>>> 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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.matthews_corrcoef.html#sklearn.metrics.matthews_corrcoef) 関数は、バイナリクラスの[マシュー相関係数（MCC）](https://en.wikipedia.org/wiki/Matthews_correlation_coefficient)を計算します。引用Wikipedia：

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

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

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

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

```python
>>>
>>> sklearn.metricsからのインポートmatthews_corrcoef
>>> y_true = [+1、+1、+1、-1]
>>> y_pred = [+1、-1、+1、+1]
>>> matthews_corrcoef（y_true、y_pred）
-0.33 ...
```

### 3.3.2.12. レシーバ動作特性（ROC）

関数[roc_curve](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.roc_curve.html#sklearn.metrics.roc_curve) は、[受信者動作特性曲線またはROCカーブ](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) を計算します。引用Wikipedia：
> 受信機動作特性（ROC）、または単純にROC曲線は、識別閾値が変化するときのバイナリ分類システムの性能を示すグラフプロットである。これは、さまざまな閾値設定で、陽性からの真陽性の割合（TPR =真陽性率）対陰性からの偽陽性の割合（FPR =偽陽性率）をプロットすることによって作成されます。 TPRは感受性としても知られており、FPRは特異性または真の負の率から1を引いたものです。

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

```python
>>> 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曲線の例を示しています。

![](http://scikit-learn.org/0.18/_images/sphx_glr_plot_roc_0011.png)

[roc_auc_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.roc_auc_score.html#sklearn.metrics.roc_auc_score) 関数は、AUCまたはAUROCで表される受信機動作特性（ROC）カーブの下の面積を計算します。 roc曲線下の面積を計算することにより、曲線情報が1つの数にまとめられます。 詳細は、[AUCに関するWikipediaの記事](https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve) を参照してください。

```python
>>> 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関数をマルチクラス分類で使用することもできます。

![](http://scikit-learn.org/0.18/_images/sphx_glr_plot_roc_0021.png)

  - 例：
    - ROCを使用して分類器の出力の品質を評価する例については、[受信者動作特性（ROC）](http://scikit-learn.org/0.18/auto_examples/model_selection/plot_roc.html#sphx-glr-auto-examples-model-selection-plot-roc-py) を参照してください。
    - クロスバリデーションを使用して、分類子の出力品質を評価するためのROCの使用例については、[相互検証による受信者動作特性（ROC）](http://scikit-learn.org/0.18/auto_examples/model_selection/plot_roc_crossval.html#sphx-glr-auto-examples-model-selection-plot-roc-crossval-py) を参照してください。
    - 種の分布をモデル化するためのROCの使用例については、[種の分布モデル](http://scikit-learn.org/0.18/auto_examples/applications/plot_species_distribution_modeling.html#sphx-glr-auto-examples-applications-plot-species-distribution-modeling-py) を参照してください。

### 3.3.2.13. 0-1損失

[zero_one_loss](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.zero_one_loss.html#sklearn.metrics.zero_one_loss) 関数は、$n_{\text{samples}}$ に対する0-1分類損失 $ (L_{0-1})$ の和または平均を計算します。 デフォルトでは、関数はサンプルに対して正規化されます。 $ L_{0-1}$ の和を求めるには、`normalize` を `False` に設定します。
マルチラベル分類では、 zero_one_loss は、そのラベルが予測と厳密に一致する場合にはサブセットを1としてスコア付けし、エラーがある場合にはゼロとしてスコア付けします。 デフォルトでは、この関数は不完全に予測されたサブセットの割合を返します。 そのようなサブセットの数を代わりに取得するには、`normalize` を `False` に設定します
$\hat {y} _i$ が $i$ 番目のサンプルの予測値であり、 $y_i$ が対応する真の値である場合、0-1損失 $L_ {0-1}$ は次のように定義されます。

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

ここで、 $1(x)$ は[指標関数](https://en.wikipedia.org/wiki/Indicator_function)です。

```python
>>> 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]にエラーがあります。

```python
>>>
>>> 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
```

  - 例：
    - クロスバリデーションを使用して再帰的な特徴を削除するための損失損失をゼロにする例については、[クロス検証による再帰的な特徴削除](http://scikit-learn.org/0.18/auto_examples/feature_selection/plot_rfe_with_cross_validation.html#sphx-glr-auto-examples-feature-selection-plot-rfe-with-cross-validation-py) を参照してください。

### 3.3.2.14. Brierスコア損失

[brier_score_loss](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.brier_score_loss.html#sklearn.metrics.brier_score_loss) 関数は、バイナリクラスの [Brierスコア](https://en.wikipedia.org/wiki/Brier_score) を計算します。引用Wikipedia：

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

この関数は、実際の結果と可能な結果の予測される確率との間の平均二乗差のスコアを返します。実際の結果は1または0（真または偽）である必要がありますが、実際の結果の予測確率は0と1の間の値になります。
brierスコアの損失も0〜1であり、スコアが低いほど（平均平方差が小さいほど）、予測がより正確である。これは、確率的予測のセットの「射程距離測定」の尺度と考えることができる。

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

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

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

```python
>>> 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
```

  - 例：
    - 分類器の確率射程距離測定を実行するためのBrierスコア損失の使用例については、[分類器の確率射程距離測定](http://scikit-learn.org/0.18/auto_examples/calibration/plot_calibration.html#sphx-glr-auto-examples-calibration-plot-calibration-py)を参照してください。
  - 参考文献：
    - G. Brier、[確率的に表現された予測の検証](http://docs.lib.noaa.gov/rescue/mwr/078/mwr-078-01-0001.pdf) 、毎月の気象評価78.1（1950）

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

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

### 3.3.3.1. カバレッジエラー

[coverage_error](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.coverage_error.html#sklearn.metrics.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}}$ に関連付けられたスコアが与えられると、カバレッジは

```math
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`の結びつきは、すべての結び付けられた値に割り当てられる最大ランクを与えることによって壊されます。


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

```python
>>> 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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.label_ranking_average_precision_score.html#sklearn.metrics.label_ranking_average_precision_score) 関数は、ラベルランク平均適合率（LRAP）を実装します。このメトリックは [average_precision_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.average_precision_score.html#sklearn.metrics.average_precision_score) 関数にリンクされていますが、適合率と再現率の代わりにラベルのランク付けの概念に基づいています。
ラベルランク平均精度（LRAP）は、各サンプルに割り当てられた各グランド・トゥルース・ラベルの平均値であり、スコアの低い真のラベルと総ラベルの比率です。このメトリックは、各サンプルに関連付けられたラベルのランクを上げることができれば、スコアが向上します。得られたスコアは常に厳密に0より大きく、最良の値は1です。サンプルあたり1つの関連ラベルが正確にある場合、ラベルランキング平均適合率は [平均逆数ランク](https://en.wikipedia.org/wiki/Mean_reciprocal_rank) に相当します。
正式には、地上の真理値表の二項目の指標行列 $\mathcal {R} ^ {n_ \text {samples} \times n_ \text{labels}}$ と各ラベル $\hat {f} \ \mathcal {R} ^ {n_ \ text {samples} \ times n_ \text {labels}}$ では、平均精度は次のように定義されます。

```math
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ノルムまたはセットの基数である。
この関数の使用例を以下に示します。

```python
>>> 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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.label_ranking_loss.html#sklearn.metrics.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}}$ に関連付けられたスコアが与えられた場合、ランキング損失は

```math
\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$ ノルムまたは集合の基数である。

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

```python
>>> 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](http://scikit-learn.org/0.18/modules/classes.html#module-sklearn.metrics) モジュールは、回帰のパフォーマンスを測定するためのいくつかの損失、スコア、およびユーティリティ関数を実装しています。 [mean_squared_error](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.mean_squared_error.html#sklearn.metrics.mean_squared_error)、[mean_absolute_error](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.mean_absolute_error.html#sklearn.metrics.mean_absolute_error)、[explain_variance_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.explained_variance_score.html#sklearn.metrics.explained_variance_score)、および [r2_score](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.r2_score.html#sklearn.metrics.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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.explained_variance_score.html#sklearn.metrics.explained_variance_score)は、[説明変数回帰スコア](https://en.wikipedia.org/wiki/Explained_variation) を計算します。
$\hat {y}$ が推定された目標出力であり、 $y$ が対応する（正しい）目標出力であり、 $Var$ が標準偏差の2乗である分散である場合、説明変数は次のように推定される。

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

最高得点は1.0で、値が低いほど悪いです。
次に、explain_variance_score関数の使用例を示します。

```python
>>> 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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.mean_absolute_error.html#sklearn.metrics.mean_absolute_error) 関数は、[平均絶対誤差](https://en.wikipedia.org/wiki/Mean_absolute_error)、絶対誤差損失または $l1$ ノルム損失の期待値に対応するリスクメトリックを計算します。
$\hat {y} \_i$ が $i$ 番目のサンプルの予測値であり、 $y\_i$ が対応する真の値である場合、$ n\_{\text{samples}}$ で推定された平均絶対誤差（MAE）は次のように定義されます。

```math
\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関数の使用例を以下に示します。

```python
>>> 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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.mean_squared_error.html#sklearn.metrics.mean_squared_error) 関数は、二乗（二次）エラー損失または損失の期待値に対応するリスク・メトリックである [平均二乗誤差](https://en.wikipedia.org/wiki/Mean_squared_error) を計算します。
$\hat {y} \_i$ が $i$ 番目のサンプルの予測値であり、 $y\_i$ が対応する真の値である場合、 $ n\_{\text{samples}}$ で推定された平均二乗誤差（MSE）は次のように定義されます。

```math
\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...
```

  - 例：
    - 勾配ブースティング回帰を評価するための二乗平均誤差の使用例については、[勾配ブースト回帰](http://scikit-learn.org/0.18/auto_examples/ensemble/plot_gradient_boosting_regression.html#sphx-glr-auto-examples-ensemble-plot-gradient-boosting-regression-py) を参照してください。

### 3.3.4.4. 中央絶対誤差

[median_absolute_error](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.median_absolute_error.html#sklearn.metrics.median_absolute_error) は特に異常値に対して堅牢であるため興味深いです。損失は​​、ターゲットと予測との間のすべての絶対差の中央値を取ることによって計算される。
$\hat {y} \_i$ が $i$ 番目のサンプルの予測値であり、 $y\_i$ が対応する真の値である場合、 $ n\_{\text{samples}} $ で推定されたメジアン絶対誤差（MedAE）は次のように定義されます。

```math
\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関数の使用例を示します。

```python
>>> 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](http://scikit-learn.org/0.18/modules/generated/sklearn.metrics.r2_score.html#sklearn.metrics.r2_score) 関数は、[決定係数](https://en.wikipedia.org/wiki/Coefficient_of_determination) であるR²を計算します。これは、将来のサンプルがモデルによって予測される可能性が高いことの指標を提供します。可能な最高得点は1.0であり、負であり得る（モデルが任意に悪化する可能性があるため）。入力特徴量を無視してyの期待値を常に予測する定数モデルでは、R ^ 2スコアが0.0になります。
$\ hat {y} \_i$ が $i$ 番目のサンプルの予測値であり、 $y\_i$ が対応する真の値である場合、 $n\_{\text{samples}}$ で推定されたスコアR²は次のように定義されます。

```math
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...
```

  - 例：
    - 疎な信号でLassoとElastic Netを評価するためのR²スコアの使用例については、[疎信号用のLassoとElastic Net](http://scikit-learn.org/0.18/auto_examples/linear_model/plot_lasso_and_elasticnet.html#sphx-glr-auto-examples-linear-model-plot-lasso-and-elasticnet-py) を参照してください。


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

sklearn.metricsモジュールは、いくつかの損失、スコア、およびユーティリティ関数を実装しています。詳細については、インスタンスクラスタリングの [クラスタリングパフォーマンス評価](http://scikit-learn.org/0.18/modules/clustering.html#clustering-evaluation) セクション、およびバイクラスタリングの [Biclustering評価](http://scikit-learn.org/0.18/modules/biclustering.html#biclustering-evaluation) を参照してください。

## 3.3.6. ダミー見積もり

教師あり学習をするとき、単純な健全性チェックは、推定器を単純な経験則と比較することから成ります。 [DummyClassifier](http://scikit-learn.org/0.18/modules/generated/sklearn.dummy.DummyClassifier.html#sklearn.dummy.DummyClassifier) は、分類のためのこのような単純な戦略をいくつか実装しています。

  - `stratified` は、トレーニングセットクラス分布を尊重することによってランダム予測を生成する。
  - `most_frequent` は、トレーニングセット内の最も頻繁なラベルを常に予測します。
  - `prior` は常にclassを最大にするクラスを（`most_frequent`のように）予測し、 `predict_proba` はクラスを先に返します。
  - `uniform` はランダムに一様に予測を生成します。
  - `constant` は **常にユーザーが提供する定数ラベルを予測として返します。**
    - この方法の主な動機は、ポジティブなクラスが少数派である場合にF1スコアリングである。

これらのすべての戦略では、 `predict` メソッドは入力データを完全に無視します。
DummyClassifierを説明するには、まず不均衡なデータセットを作成しましょう：

```python
>>> 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)
```

次に、`SVC` と `most_frequent` の精度を比較してみましょう。

```python
>>> 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がダミーの分類器よりもはるかに優れていないことがわかります。さて、カーネルを変更しましょう：

```python
>>> clf = SVC(kernel='rbf', C=1).fit(X_train, y_train)
>>> clf.score(X_test, y_test)  
0.97...
```

精度はほぼ100％に向上しました。 CPUのコストがそれほど高くない場合は、精度をより正確に評価するために、クロスバリデーションを推奨します。詳細については、 [クロスバリデーション：見積もりパフォーマンスの評価](http://qiita.com/nazoking@github/items/13b167283590f512d99a) セクションを参照してください。さらに、パラメータ空間を最適化する場合は、適切な方法を使用することを強くお勧めします。詳細については、[推定器のハイパーパラメータのチューニング](http://scikit-learn.org/0.18/modules/grid_search.html#grid-search) セクションを参照してください。
より一般的には、分類器の精度がランダムに近すぎると、何かが間違っている可能性があります。特徴量が役立たず、ハイパーパラメータが正しく調整されていない、分類器がクラスの不均衡などに苦しんでいます。

[DummyRegressor](http://scikit-learn.org/0.18/modules/generated/sklearn.dummy.DummyRegressor.html#sklearn.dummy.DummyRegressor) はまた、回帰のための4つの簡単な経験則を実装しています。

  - `mean` は常に訓練目標の平均を予測する。
  - `median` は常に訓練目標の中央値を予測する。
  - `quantile` は、常に、ユーザーが訓練目標の分位点を提供することを予測します。
  - `constant` は、常にユーザーによって提供される一定の値を予測として返します。

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

----
[scikit-learn 0.18 ユーザーガイド 3. モデルの選択と評価](http://qiita.com/nazoking@github/items/267f2371757516f8c168#3-%E3%83%A2%E3%83%87%E3%83%AB%E3%81%AE%E9%81%B8%E6%8A%9E%E3%81%A8%E8%A9%95%E4%BE%A1) より

©2010 - 2016、scikit-learn developers（BSDライセンス）。