incrementalClassificationECOC

インクリメンタル学習用のバイナリ学習器を使用したマルチクラス分類モデル

R2022a 以降

説明

関数 incrementalClassificationECOC は incrementalClassificationECOC モデル オブジェクトを作成します。これは、インクリメンタル学習用のバイナリ学習器を使用したマルチクラス誤り訂正出力符号 (ECOC) 分類モデルを表します。

他の Statistics and Machine Learning Toolbox™ モデル オブジェクトとは異なり、incrementalClassificationECOC は直接呼び出すことができます。また、モデルをデータに当てはめる前に、パフォーマンス メトリクス構成やクラスの事前確率などの学習オプションを指定できます。incrementalClassificationECOC オブジェクトを作成すると、インクリメンタル学習用に準備されます。

incrementalClassificationECOC は、インクリメンタル学習に最適です。マルチクラス分類モデルに学習させるための従来のアプローチ (データへの当てはめによるモデルの作成、交差検証の実行、ハイパーパラメーターの調整など) については、fitcecoc を参照してください。

作成

incrementalClassificationECOC モデル オブジェクトは、次のいくつかの方法で作成できます。

• 関数の直接呼び出し — incrementalClassificationECOC を直接呼び出して、インクリメンタル学習オプションを構成するか、学習器固有のオプションを指定します。このアプローチは、データがまだない場合やインクリメンタル学習をすぐに開始したい場合に最適です。インクリメンタル学習中に応答データで予測される最大クラス数またはすべてのクラス名を指定しなければなりません。

• 従来式の学習済みモデルの変換 — 学習済みモデル オブジェクト (ClassificationECOC または CompactClassificationECOC) のモデル パラメーターを使用して、インクリメンタル学習用のマルチクラス ECOC 分類モデルを初期化するには、従来式の学習済みモデルを関数 incrementalLearner に渡して incrementalClassificationECOC モデル オブジェクトに変換できます。

• インクリメンタル学習関数の呼び出し — fit、updateMetrics、および updateMetricsAndFit は、構成済みの incrementalClassificationECOC モデル オブジェクトおよびデータを入力として受け入れ、入力モデルとデータから学習した情報で更新された incrementalClassificationECOC モデル オブジェクトを返します。

構文

Mdl = incrementalClassificationECOC(MaxNumClasses=maxNumClasses)

Mdl = incrementalClassificationECOC(ClassNames=classNames)

Mdl = incrementalClassificationECOC(___,Name=Value)

説明

Mdl = incrementalClassificationECOC(MaxNumClasses=maxNumClasses) は、マルチクラス ECOC 分類用の既定のインクリメンタル学習モデル オブジェクト Mdl を返します。MaxNumClasses は、インクリメンタル学習中に応答データで予測される最大クラス数です。既定のモデルのプロパティには、未知のモデル パラメーター用のプレースホルダーが含まれています。既定のモデルは、パフォーマンスを追跡したり、予測を生成したりする前に学習させなければなりません。

Mdl = incrementalClassificationECOC(ClassNames=classNames) は、インクリメンタル学習中に応答データで予測されるすべてのクラス名 ClassNames を指定し、ClassNames プロパティを設定します。

Mdl = incrementalClassificationECOC(___,Name=Value) は、前の構文のいずれかを使用し、名前と値の引数を使用してプロパティと追加のオプションを設定します。たとえば、incrementalClassificationECOC(MaxNumClasses=5,Coding="onevsone",MetricsWarmupPeriod=100) は、応答データで予測される最大クラス数を 5 に設定し、1 対 1 の 符号化設計を使用するように指定し、メトリクスのウォームアップ期間を 100 に設定します。

入力引数

MaxNumClasses — 最大クラス数

正の整数

インクリメンタル学習中に応答データで予測される最大クラス数。正の整数として指定します。

MaxNumClasses は ClassNames プロパティ内のクラス名の数を設定します。

MaxNumClasses を指定しない場合は、ClassNames 引数を指定しなければなりません。

例: MaxNumClasses=5

データ型: single | double

ClassNames — すべての一意のクラス ラベル

categorical 配列 | 文字配列 | string 配列 | logical ベクトル | 数値ベクトル | 文字ベクトルの cell 配列

インクリメンタル学習中に応答データで予測されるすべての一意のクラス ラベル。categorical 配列、文字配列、string 配列、logical ベクトル、数値ベクトル、または文字ベクトルの cell 配列として指定します。ClassNames と応答データは同じデータ型でなければなりません。この引数は ClassNames プロパティを設定します。

ClassNames は、クラスの順序に対応する入力または出力引数の次元の順序を指定します。たとえば、predict により返される分類スコアの列の順序を指定するために ClassNames を設定します。

ClassNames を指定しない場合は、MaxNumClasses 引数を指定しなければなりません。その場合、インクリメンタル学習中にデータから ClassNames プロパティが推定されます。

例: ClassNames=["virginica","setosa","versicolor"]

データ型: single | double | logical | string | char | cell | categorical

名前と値の引数

オプションの引数のペアを Name1=Value1,...,NameN=ValueN として指定します。ここで、Name は引数名で、Value は対応する値です。名前と値の引数は他の引数の後に指定しなければなりませんが、ペアの順序は重要ではありません。

例: NumPredictors=4,Prior=[0.3 0.3 0.4] は、予測子変数の数を 4 と指定し、クラスの事前確率分布を [0.3 0.3 0.4] に設定します。

Coding — 符号化設計

"onevsone" (既定値) | "allpairs" | "binarycomplete" | "denserandom" | "onevsall" | "ordinal" | "sparserandom" | "ternarycomplete" | 数値行列

符号化設計の名前。数値行列または次の表の値として指定します。

値	バイナリ学習器の数	説明
"allpairs" および "onevsone"	K(K – 1)/2	各バイナリ学習器では、1 つのクラスが陽性であり、もう 1 つのクラスは陰性です。残りは無視されます。この計画はすべてのクラス ペアの割り当ての組み合わせを使用します。
"binarycomplete"	$$2^{(K-1)}-1$$	この計画はクラスをすべて 2 つの組み合わせに分割します。いずれのクラスも無視されません。各バイナリ学習器では、すべてのクラス割り当てが –1 および 1 になり、割り当てに陽性クラスと陰性クラスが少なくとも 1 つずつ含まれます。
"denserandom"	ランダム。ただし、約 10 log2K	各バイナリ学習器には、陽性または陰性クラス (少なくとも各 1 つ) が無作為に割り当てられます。詳細については、ランダム符号化設計行列を参照してください。
"onevsall"	K	各バイナリ学習器では、1 つのクラスは陽性で残りは陰性です。この計画は陽性クラス割り当てのすべての組み合わせを使用します。
"ordinal"	K – 1	1 番目のバイナリ学習器では、1 番目のクラスが陰性であり、残りは陽性です。2 番目のバイナリ学習器では、最初の 2 つのクラスが陰性であり、残りは陽性です。他についても同様です。
"sparserandom"	ランダム。ただし、約 15 log2K	各バイナリ学習器では、各クラスに確率 0.25 で陽性または陰性が無作為に割り当てられ、確率が 0.5 の場合にクラスが無視されます。詳細については、ランダム符号化設計行列を参照してください。
"ternarycomplete"	$$\left(3^K-2^{(K+1)}+1\right)/2$$	この計画はクラスをすべて 3 つの組み合わせに分割します。すべてのクラス割り当てが 0、–1、および 1 になり、各割り当てに陽性クラスと陰性クラスが少なくとも 1 つずつ含まれます。

符号化設計は、カスタム符号化行列を使用して指定することもできます。K 行 L 列の行列を使用します。各行はクラスに対応し、各列はバイナリ学習器に対応します。クラス順 (行) は ClassNames プロパティでの順序に対応します。以下のガイドラインに従って行列を作成します。

• カスタム符号化行列は、すべての要素が –1、0、または 1 でなければなりません。また、値は二分法によるクラス割り当てに対応しなければなりません。Coding(i,j) は、学習器 j がクラス i の観測値に割り当てるクラスとなります。

  値	二分法によるクラス割り当て
  –1	学習器 j は、クラス i の観測値を陰性クラスに割り当てます。
  0	学習の前に、学習器 j はクラス i の観測値をデータ セットから削除します。
  1	学習器 j は、クラス i の観測値を陽性クラスに割り当てます。

• すべての列に –1 および 1 が少なくとも 1 つずつ含まれていなければなりません。

• i ≠ j となるすべての列インデックス i および j について、Coding(:,i) は Coding(:,j) と等しくなることができず、Coding(:,i) は –Coding(:,j) と等しくなることができません。

• カスタム符号化行列のすべての行は異なっていなければなりません。

カスタム符号化設計行列の形式の詳細については、カスタム符号化設計行列を参照してください。

例: Coding="ternarycomplete"

データ型: char | string | double | single | int16 | int32 | int64 | int8

Metrics — インクリメンタル学習中に追跡するモデルのパフォーマンス メトリクス

"classiferror" (既定値) | 関数ハンドル | cell ベクトル | 構造体配列

インクリメンタル学習中に追跡するモデルのパフォーマンス メトリクス。"classiferror" (分類誤差または誤分類誤差率)、関数ハンドル (@metricName など)、関数ハンドルの構造体配列、または名前、関数ハンドル、構造体配列の cell ベクトルとして指定します。

Mdl が "ウォーム" のとき (IsWarm を参照)、updateMetrics および updateMetricsAndFit は Mdl の Metrics プロパティのパフォーマンス メトリクスを追跡します。

パフォーマンス メトリクスを返すカスタム関数を指定するには、関数ハンドル表記を使用します。関数は次の形式でなければなりません。

metric = customMetric(C,S)

• 出力引数 metric は n 行 1 列の数値ベクトルです。ここで、各要素は、学習サイクル中にインクリメンタル学習関数によって処理されたデータの対応する観測値の損失です。

• 関数名 (ここでは customMetric) を指定します。

• C は n 行 K 列の logical 行列であり、対応する観測値が属するクラスを各行が示します。K はクラスの数です。列の順序は ClassNames プロパティのクラスの順序に対応します。C を作成するには、指定されたデータの各観測値について観測値 p がクラス q に属する場合に C(p,q) = 1 を設定します。行 p の他の要素を 0 に設定します。

• S は、予測分類スコアの n 行 K 列の数値行列です。S は predict の出力 NegLoss に似ています。ここで、行はデータの観測値に対応し、列の順序は ClassNames プロパティのクラスの順序に対応しています。S(p,q) は、クラス q に分類されている観測値 p の分類スコアです。

複数のカスタム メトリクスを指定し、それぞれにカスタム名を割り当てるには、構造体配列を使用します。組み込みメトリクスとカスタム メトリクスの組み合わせを指定するには、cell ベクトルを使用します。

updateMetrics および updateMetricsAndFit は、table で指定したメトリクスを Metrics プロパティに保存します。Metrics のデータ型によって、table の行名が決まります。

Metrics 値のデータ型	Metrics プロパティの行名の説明	例
string または文字ベクトル	対応する組み込みメトリクスの名前	"classiferror" の行名は "ClassificationError"
構造体配列	フィールド名	struct(Metric1=@customMetric1) の行名は "Metric1"
プログラム ファイルに格納されている関数への関数ハンドル	関数名	@customMetric の行名は "customMetric"
無名関数	CustomMetric_j。ここで、j は Metrics のメトリクス j	@(C,S)customMetric(C,S)... の行名は CustomMetric_1

パフォーマンス メトリクス オプションの詳細については、パフォーマンス メトリクスを参照してください。

例: Metrics=struct(Metric1=@customMetric1,Metric2=@customMetric2)

例: Metrics={@customMetric1,@customMetric2,"classiferror",struct(Metric3=@customMetric3)}

データ型: char | string | struct | cell | function_handle

Learners — バイナリ学習器テンプレート

"linear" (既定値) | "kernel" | インクリメンタル学習オブジェクト | テンプレート オブジェクト | インクリメンタル学習オブジェクトとテンプレート オブジェクトの cell 配列

バイナリ学習器テンプレート。"linear"、"kernel"、インクリメンタル学習オブジェクト、テンプレート オブジェクト、またはサポートされるインクリメンタル学習オブジェクトとテンプレート オブジェクトの cell 配列として指定します。

• "linear" または "kernel" — 既定の線形学習器または既定のカーネル学習器 (それぞれ既定の incrementalClassificationLinear オブジェクトまたは incrementalClassificationKernel オブジェクト) を使用するには、Learners の値を string スカラーまたは文字ベクトルとして指定します。

• インクリメンタル学習オブジェクト (incrementalClassificationLinear オブジェクトまたは incrementalClassificationKernel オブジェクト) — インクリメンタル学習オブジェクトの作成時にバイナリ学習器のプロパティ (モデル固有のプロパティとインクリメンタル学習のプロパティの両方) を構成し、そのオブジェクトを incrementalClassificationECOC に Learners の値として渡します。

• 関数 templateLinear、templateSVM、または templateKernel によって返されるテンプレート オブジェクト — テンプレート オブジェクトの作成時にモデル固有のプロパティを構成し、そのオブジェクトを incrementalClassificationECOC に Learners の値として渡します。このアプローチは、テンプレート オブジェクトでモデル プロパティを指定する場合や既定のインクリメンタル学習オプションを使用する場合に使用します。

• サポートされるインクリメンタル学習オブジェクトとテンプレート オブジェクトの cell 配列 — このアプローチは、各学習器を個別にカスタマイズする場合に使用します。

incrementalClassificationECOC オブジェクトの ClassNames (クラス名) および Prior (事前クラス確率) のプロパティは、バイナリ学習器を使用して指定することはできません。これらのプロパティについては、代わりに incrementalClassificationECOC の対応する名前と値の引数を使用して指定します。

例: Learners="kernel"

UpdateBinaryLearnerMetrics — バイナリ学習器のメトリクスの更新のフラグ

false または 0 (既定値) | true または 1

バイナリ学習器のメトリクスの更新のフラグ。logical 0 (false) または 1 (true) として指定します。

値が true の場合、BinaryLearners プロパティに格納されたバイナリ学習器の Metrics プロパティを使用してソフトウェアでバイナリ学習器のパフォーマンス メトリクスが追跡されます。例については、モデルとバイナリ学習器のパフォーマンス メトリクスを追跡するためのインクリメンタル モデルの構成を参照してください。

例: UpdateBinaryLearnerMetrics=true

データ型: logical

プロパティ

ほとんどのプロパティは、incrementalClassificationECOC を呼び出すときに名前と値の引数の構文を使用して直接設定できます。BinaryLearners、CodingMatrix、CodingName、NumTrainingObservations、および IsWarm の各プロパティは、名前と値の引数の構文で同じ名前の引数を使用して設定することはできません。ただし、CodingMatrix と CodingName は名前と値の引数 Coding、BinaryLearners は名前と値の引数 Learners を使用して設定できます。

incrementalLearner を呼び出して従来式の学習済みモデルを変換するときに、いくつかのプロパティを設定できます。

分類モデルのパラメーター

BinaryLearners — 学習済みバイナリ学習器

読み取り専用: モデル オブジェクトの cell 配列

この プロパティ は読み取り専用です。

学習済みバイナリ学習器。incrementalClassificationLinear または incrementalClassificationKernel モデル オブジェクトの cell 配列として指定します。バイナリ学習器の数は符号化設計によって異なります。

BinaryLearner{j} の学習は、CodingMatrix(:,j) によって指定されるバイナリ問題に従って行われます。

BinaryLearners の既定値は、モデルの作成方法に応じて異なります。

• 従来式の学習済みモデル (たとえば TTMdl) を変換して Mdl を作成する場合、TTMdl のバイナリ学習器から変換されたインクリメンタル学習器が BinaryLearners に格納されます。

  TTMdl に学習させるときは、fitcecoc の名前と値の引数 Learners を指定して、サポート ベクター マシン (SVM) バイナリ学習器テンプレート (templateSVM) または線形分類モデル バイナリ学習器テンプレート (templateLinear) を使用しなければなりません。

• それ以外の場合、このプロパティの設定は名前と値の引数 Learners で行います。この引数の既定値は "linear" であり、SVM 学習器をもつ incrementalClassificationLinear モデル オブジェクトが使用されます。

データ型: cell

BinaryLoss — バイナリ学習器損失関数

読み取り専用: "hamming" | "linear" | "logit" | "exponential" | "binodeviance" | "hinge" | "quadratic" | 関数ハンドル

この プロパティ は読み取り専用です。

バイナリ学習器損失関数。組み込みの損失関数の名前または関数ハンドルとして指定します。incrementalClassificationECOC は BinaryLoss の値を文字ベクトルまたは関数ハンドルとして格納します。

• 次の表で、組み込み関数について説明します。ここで、y_j は特定のバイナリ学習器のクラス ラベル (集合 {–1,1,0} 内)、s_j は観測値 j のスコア、g(y_j,s_j) はバイナリ損失の式です。

  値	説明	スコア領域	g(yj,sj)
  "binodeviance"	二項分布からの逸脱度	(–∞,∞)	log[1 + exp(–2yjsj)]/[2log(2)]
  "exponential"	指数	(–∞,∞)	exp(–yjsj)/2
  "hamming"	ハミング	[0,1] または (–∞,∞)	[1 – sign(yjsj)]/2
  "hinge"	ヒンジ	(–∞,∞)	max(0,1 – yjsj)/2
  "linear"	線形	(–∞,∞)	(1 – yjsj)/2
  "logit"	ロジスティック	(–∞,∞)	log[1 + exp(–yjsj)]/[2log(2)]
  "quadratic"	2 次	[0,1]	[1 – yj(2sj – 1)]2/2

  バイナリ損失は、y_j = 0 の場合に損失が 0.5 になるように正規化されます。また、各クラスについて平均のバイナリ損失が計算されます[1]。

• カスタム バイナリ損失関数の場合は関数ハンドルを指定します。たとえば、customFunction の場合は BinaryLoss=@customFunction を指定します。

  customFunction の形式は次のとおりです。

  bLoss = customFunction(M,s)

  • M は Mdl.CodingMatrix に格納された K 行 B 列の符号化行列です。

  • s は 1 行 B 列の分類スコアの行ベクトルです。

  • bLoss は分類損失です。このスカラーは、特定のクラスのすべての学習器についてバイナリ損失を集計します。たとえば、平均バイナリ損失を使用して、各クラスの学習器の損失を集計できます。

  • K は、クラスの数です。

  • B はバイナリ学習器の数です。

  カスタム バイナリ損失関数の例については、カスタム バイナリ損失関数の使用による ECOC モデルのテスト標本ラベルの予測を参照してください。この例は従来式の学習済みモデルの例です。この例で示しているように、インクリメンタル学習用のカスタム損失関数を定義できます。

詳細については、バイナリ損失を参照してください。

BinaryLoss の既定値は、モデルの作成方法に応じて異なります。

• 従来式の学習済みモデルを変換して Mdl を作成する場合、BinaryLoss は従来式の学習済みモデルの対応するプロパティによって指定されます。incrementalLearner の名前と値の引数 BinaryLoss を使用して BinaryLoss の値を指定することもできます。

• それ以外の場合、BinaryLoss の既定値は "hinge" です。

データ型: char | string | function_handle

ClassNames — すべての一意のクラス ラベル

読み取り専用: categorical 配列 | 文字配列 | string 配列 | logical ベクトル | 数値ベクトル | 文字ベクトルの cell 配列

この プロパティ は読み取り専用です。

インクリメンタル学習中に応答データで予測されるすべての一意のクラス ラベル。categorical 配列、文字配列、logical ベクトル、数値ベクトル、または文字ベクトルの cell 配列として指定します。

ClassNames は次の 3 つのいずれかの方法で設定できます。

• MaxNumClasses 引数を指定した場合、インクリメンタル学習中に ClassNames プロパティが推定されます。

• ClassNames 引数を指定した場合、incrementalClassificationECOC はその指定を ClassNames プロパティに格納します。(string 配列は文字ベクトルの cell 配列として扱われます)。

• 従来式の学習済みモデルを変換して Mdl を作成する場合、ClassNames プロパティは従来式の学習済みモデルの対応するプロパティによって指定されます。

データ型: single | double | logical | char | string | cell | categorical

CodingMatrix — クラス割り当て符号

読み取り専用: 数値行列

この プロパティ は読み取り専用です。

バイナリ学習器のクラス割り当て符号。数値行列を指定します。CodingMatrix は K 行 L 列の行列で、K はクラスの個数、L はバイナリ学習器の個数です。

CodingMatrix の要素は –1、0、1 であり、値は二分法によるクラス割り当てに対応します。次の表に、学習器 j がクラス i の観測値を CodingMatrix(i,j) の値に対応する二分クラスに割り当てる方法を示します。

値	二分法によるクラス割り当て
–1	学習器 j は、クラス i の観測値を陰性クラスに割り当てます。
0	学習の前に、学習器 j はクラス i の観測値をデータ セットから削除します。
1	学習器 j は、クラス i の観測値を陽性クラスに割り当てます。

詳細については、符号化設計を参照してください。

CodingMatrix の既定値は、モデルの作成方法に応じて異なります。

• 従来式の学習済みモデルを変換して Mdl を作成する場合、CodingMatrix は従来式の学習済みモデルの対応するプロパティによって指定されます。

• それ以外の場合、このプロパティの設定は名前と値の引数 Coding で行います。この引数の既定値では、1 対 1 の 符号化設計が使用されます。

データ型: double | single | int8 | int16 | int32 | int64

CodingName — 符号化設計名

読み取り専用: 文字ベクトル

この プロパティ は読み取り専用です。

符号化設計名。文字ベクトルを指定します。

CodingName の既定値は、モデルの作成方法に応じて異なります。

• 従来式の完全な学習済みモデル (ClassificationECOC) を変換して Mdl を作成する場合、CodingName は従来式の学習済みモデルの対応するプロパティによって指定されます。

• 従来式のコンパクトな学習済みモデル (CompactClassificationECOC) を変換して Mdl を作成する場合、CodingName は "converted" になります。

• それ以外の場合、このプロパティの設定は名前と値の引数 Coding で行います。この引数の既定値は "onevsone" です。Coding を使用してカスタム符号化行列を指定する場合、CodingName は "custom" になります。

詳細については、符号化設計を参照してください。

データ型: char

Decoding — 復号化スキーム

読み取り専用: "lossweighted" | "lossbased"

この プロパティ は読み取り専用です。

復号化方式。"lossweighted" または "lossbased" として指定します。incrementalClassificationECOC は Decoding の値を文字ベクトルとして格納します。

ソフトウェアでバイナリ損失をどのように集計して各観測値の予測クラスを判定するかは、ECOC モデルの復号化方式で指定します。ソフトウェアでは 2 つの復号化方式をサポートしています。

• "lossweighted" — 観測値の予測クラスは、バイナリ学習器におけるバイナリ損失の合計が最小になるクラスに対応します。

• "lossbased" — 観測値の予測クラスは、バイナリ学習器におけるバイナリ損失の平均が最小になるクラスに対応します。

詳細については、バイナリ損失を参照してください。

Decoding の既定値は、モデルの作成方法に応じて異なります。

• 従来式の学習済みモデルを変換して Mdl を作成する場合、このプロパティの設定は incrementalLearner の名前と値の引数 Decoding で行います。この引数の既定値は "lossweighted" です。

• それ以外の場合、Decoding の既定値は "lossweighted" です。

データ型: char | string

NumPredictors — 予測子変数の数

読み取り専用: 非負の数値スカラー

この プロパティ は読み取り専用です。

予測子変数の数。非負の数値スカラーとして指定します。

NumPredictors の既定値は、モデルの作成方法に応じて異なります。

• 従来式の学習済みモデルを変換して Mdl を作成する場合、NumPredictors は従来式の学習済みモデルの対応するプロパティによって指定されます。

• incrementalClassificationECOC を直接呼び出して Mdl を作成する場合、NumPredictors は名前と値の引数の構文を使用して指定できます。値を指定しない場合、既定値は 0 で、インクリメンタル近似関数は学習中に予測子データから NumPredictors を推測します。

データ型: double

NumTrainingObservations — インクリメンタル モデルに当てはめる観測値の数

読み取り専用: 0 (既定値) | 非負の数値スカラー

この プロパティ は読み取り専用です。

インクリメンタル モデル Mdl に当てはめる観測値の数。非負の数値スカラーとして指定します。NumTrainingObservations は、Mdl および学習データを fit または updateMetricsAndFit に渡すときに増加します。

メモ

従来式の学習済みモデルを変換して Mdl を作成する場合、incrementalClassificationECOC は、従来式の学習済みモデルに当てはめる観測値の数を NumTrainingObservations に追加しません。

データ型: double

Prior — 事前クラス確率

読み取り専用: 数値ベクトル | "empirical" | "uniform"

この プロパティ は読み取り専用です。

事前クラス確率。"empirical"、"uniform"、または数値ベクトルとして指定します。incrementalClassificationECOC は Prior 値を数値ベクトルとして格納します。

値	説明
"empirical"	インクリメンタル学習関数が、インクリメンタル学習中に応答データで観測されたクラスの相対頻度から前のクラスの確率を推定します。
"uniform"	各クラスの事前確率を 1/K とします。ここで、K はクラスの数です。
数値ベクトル	正規化されたカスタム事前確率。Prior の要素の順序は ClassNames プロパティの要素に対応します。

Prior の既定値は、モデルの作成方法に応じて異なります。

• 従来式の学習済みモデルを変換して Mdl を作成する場合、Prior は従来式の学習済みモデルの対応するプロパティによって指定されます。

• それ以外の場合、既定値は "empirical" です。

データ型: single | double | char | string

ScoreTransform — 予測されたスコアに適用するスコア変換関数

読み取り専用: 'none'

この プロパティ は読み取り専用です。

予測されたスコアに適用するスコア変換関数。'none' を指定します。ECOC モデルではスコア変換はサポートされません。

パフォーマンス メトリクス パラメーター

IsWarm — モデルがパフォーマンス メトリクスを追跡するかどうかを示すフラグ

false または 0 | true または 1

インクリメンタル モデルがパフォーマンス メトリクスを追跡するかどうかを示すフラグ。logical 0 (false) または 1 (true) として指定します。

インクリメンタル モデル Mdl は、インクリメンタル近似関数で次の両方のアクションを実行すると "ウォーム" (IsWarm が true) になります。

• インクリメンタル モデルを MetricsWarmupPeriod の観測値に当てはめる。

• MaxNumClasses のクラス、または名前と値の引数 ClassNames で指定されたすべてのクラス名を処理する。

値	説明
true または 1	インクリメンタル モデル Mdl がウォームです。この結果、updateMetrics および updateMetricsAndFit が Mdl の Metrics プロパティのパフォーマンス メトリクスを追跡します。
false または 0	updateMetrics および updateMetricsAndFit はパフォーマンス メトリクスを追跡しません。

データ型: logical

Metrics — モデルのパフォーマンス メトリクス

読み取り専用: table

この プロパティ は読み取り専用です。

updateMetrics および updateMetricsAndFit によってインクリメンタル学習中に更新されたモデルのパフォーマンス メトリクス。m 行 2 列の table として指定します。ここで、m は、名前と値の引数 Metrics によって指定されたメトリクスの数です。

Metrics の列には Cumulative および Window のラベルが付けられます。

• Cumulative:要素 j は、メトリクス j で測定される、モデルがウォーム (IsWarm が 1) になった時点からの、モデルの性能です。

• Window:要素 j は、メトリクス j で測定され、MetricsWindowSize プロパティで指定されたウィンドウ内のすべての観測値に対して評価される、モデルの性能です。ソフトウェアは MetricsWindowSize 個の観測値を処理した後、Window を更新します。

行には、指定したメトリクスのラベルが付けられます。詳細については、incrementalLearner または incrementalClassificationECOC の名前と値の引数 Metrics を参照してください。

データ型: table

MetricsWarmupPeriod — パフォーマンス メトリクスを追跡する前に当てはめる観測値の数

読み取り専用: 非負の整数

この プロパティ は読み取り専用です。

インクリメンタル モデルが Metrics プロパティのパフォーマンス メトリクスを追跡する前に当てはめなければならない観測値の数。非負の整数として指定します。

MetricsWarmupPeriod の既定値は、モデルの作成方法に応じて異なります。

• 従来式の学習済みモデルを変換して Mdl を作成する場合、このプロパティの設定は関数 incrementalLearner の名前と値の引数 MetricsWarmupPeriod で行います。この引数の既定値は 0 です。

• それ以外の場合、既定値は 1000 です。

詳細については、パフォーマンス メトリクスを参照してください。

データ型: single | double

MetricsWindowSize — ウィンドウ パフォーマンス メトリクスの計算に使用する観測値の数

読み取り専用: 正の整数

この プロパティ は読み取り専用です。

ウィンドウ パフォーマンス メトリクスの計算に使用する観測値の数。正の整数として指定します。

MetricsWindowSize の既定値は、モデルの作成方法に応じて異なります。

• 従来式の学習済みモデルを変換して Mdl を作成する場合、このプロパティの設定は関数 incrementalLearner の名前と値の引数 MetricsWindowSize で行います。この引数の既定値は 200 です。

• それ以外の場合、既定値は 200 です。

パフォーマンス メトリクス オプションの詳細については、パフォーマンス メトリクスを参照してください。

データ型: single | double

オブジェクト関数

fit	インクリメンタル学習用の ECOC 分類モデルの学習
updateMetricsAndFit	ECOC インクリメンタル学習分類モデルの新しいデータに基づくパフォーマンス メトリクスの更新とモデルの学習
updateMetrics	ECOC インクリメンタル学習分類モデルの新しいデータに基づくパフォーマンス メトリクスの更新
loss	データのバッチでの ECOC インクリメンタル学習分類モデルの損失
predict	ECOC インクリメンタル学習分類モデルからの新しい観測値の応答予測
perObservationLoss	インクリメンタル学習用モデルの観測値ごとの分類誤差
reset	インクリメンタル分類モデルのリセット

例

十分な事前情報なしでのインクリメンタル学習器の作成

インクリメンタル学習用の ECOC 分類モデルを作成するには、モデルが処理する、予測される最大クラス数 (名前と値の引数 MaxNumClasses) を指定する必要があります。インクリメンタル近似関数を使用してデータの入力バッチにモデルを当てはめると、モデルで新しいクラスが ClassNames プロパティに収集されます。最大クラス数の指定が正確でないと、次のいずれかが発生します。

• 予測される最大クラス数をインクリメンタル近似関数が処理するまで、モデルはコールドになります。その結果、関数 updateMetrics および updateMetricsAndFit でパフォーマンス メトリクスが測定されません。

• 予測される最大数をクラスの数が超えると、インクリメンタル近似関数でエラーが発行されます。

この例では、データに含まれる予測される最大クラス数しか情報を指定しない場合の、インクリメンタル学習用 ECOC モデルの作成方法を示します。また、インクリメンタル近似関数が標本の早い時点と遅い時点のすべての予測されるクラスを処理する場合の結果も示します。

この例では、デバイスに学習させ、被験者で測定された生体データに基づいて、被験者が座る、立つ、歩く、走る、踊るのいずれの状態であるかを予測するとします。したがって、デバイスが選択することになるクラスは最大 5 つです。

予測される最大クラス数を標本の早い時点で処理

人の行動のデータ セットを読み込みます。データをランダムにシャッフルします。

load humanactivity
n = numel(actid);
rng(1) % For reproducibility
idx = randsample(n,n);
X = feat(idx,:);
Y = actid(idx);

データ セットの詳細については、コマンド ラインで Description を入力してください。

マルチクラス学習用のインクリメンタル ECOC モデルを作成します。データ内のクラスの最大数を 5 と指定します。

MdlEarly = incrementalClassificationECOC(MaxNumClasses=5)

MdlEarly = 
  incrementalClassificationECOC

            IsWarm: 0
           Metrics: [1×2 table]
        ClassNames: [1×0 double]
    ScoreTransform: 'none'
    BinaryLearners: {10×1 cell}
        CodingName: 'onevsone'
          Decoding: 'lossweighted'


  Properties, Methods

MdlEarly は incrementalClassificationECOC モデル オブジェクトです。そのプロパティはすべて読み取り専用です。MdlEarly は、他の演算の実行に使用する前に、データに当てはめなければなりません。

符号化設計行列を表示します。

MdlEarly.CodingMatrix

ans = 5×10

     1     1     1     1     0     0     0     0     0     0
    -1     0     0     0     1     1     1     0     0     0
     0    -1     0     0    -1     0     0     1     1     0
     0     0    -1     0     0    -1     0    -1     0     1
     0     0     0    -1     0     0    -1     0    -1    -1

符号化設計行列の各行はクラスに対応し、各列はバイナリ学習器に対応します。たとえば、1 番目のバイナリ学習器はクラス 1 と 2、4 番目のバイナリ学習器はクラス 1 と 5 に対応しており、どちらの学習器でもクラス 1 を陽性クラスと仮定しています。

関数 updateMetricsAndFit を使用して、インクリメンタル モデルを学習データに当てはめます。50 個の観測値のチャンクを一度に処理して、データ ストリームをシミュレートします。各反復で次を行います。

• 50 個の観測値を処理します。

• 前のインクリメンタル モデルを、入力観測値に当てはめた新しいモデルで上書きします。

• 1 番目のバイナリ学習器の 1 番目のモデル係数 $${\beta }_{11}$$、累積メトリクス、およびウィンドウ メトリクスを保存し、インクリメンタル学習中にそれらがどのように進化するかを確認します。

% Preallocation
numObsPerChunk = 50;
nchunk = floor(n/numObsPerChunk);
mc = array2table(zeros(nchunk,2),VariableNames=["Cumulative","Window"]);
beta11 = zeros(nchunk+1,1);    

% Incremental learning
for j = 1:nchunk
    ibegin = min(n,numObsPerChunk*(j-1) + 1);
    iend = min(n,numObsPerChunk*j);
    idx = ibegin:iend;    
    MdlEarly = updateMetricsAndFit(MdlEarly,X(idx,:),Y(idx));
    mc{j,:} = MdlEarly.Metrics{"ClassificationError",:};
    beta11(j) = MdlEarly.BinaryLearners{1}.Beta(1);
end

MdlEarly は、ストリーム内のすべてのデータで学習させた incrementalClassificationECOC モデル オブジェクトです。インクリメンタル学習中およびモデルがウォームアップされた後、updateMetricsAndFit は入力観測値でモデルの性能をチェックし、モデルをその観測値に当てはめます。

パフォーマンス メトリクスと $${\beta }_{11}$$ が学習中にどのように進化するかを確認するには、それらを別々のタイルにプロットします。

t = tiledlayout(2,1);
nexttile
plot(beta11)
ylabel("\beta_{11}")
xlim([0 nchunk])
nexttile
plot(mc.Variables)
xlim([0 nchunk])
ylabel("Classification Error")
xline(MdlEarly.MetricsWarmupPeriod/numObsPerChunk,"--")
legend(mc.Properties.VariableNames)
xlabel(t,"Iteration")

このプロットは、updateMetricsAndFit が次のアクションを実行することを示しています。

• $${\beta }_{11}$$ をインクリメンタル学習のすべての反復で当てはめます。

• パフォーマンス メトリクスをメトリクスのウォームアップ期間 (垂直な破線) の後にのみ計算します。

• 累積メトリクスを各反復中に計算します。

• ウィンドウ メトリクスを 200 個の観測値 (4 回の反復) の処理後に計算します。

予測される最大クラス数を標本の遅い時点で処理

クラス 5 でラベル付けされた観測値が最後の 5000 個の標本にのみ含まれるようにデータ セットを再編成します。

クラス 5 でラベル付けされたすべての観測値を標本の最後に移動します。

idx5 = Y == 5;
Xnew = [X(~idx5,:); X(idx5,:)];
Ynew = [Y(~idx5); Y(idx5)];
sum(idx5)

ans = 
2653

最後の 5000 個の標本をシャッフルします。

m = 5000;
idx_shuffle = randsample(m,m);
Xnew(end-m+1:end,:) = Xnew(end-m+idx_shuffle,:);
Ynew(end-m+1:end) = Ynew(end-m+idx_shuffle);

ECOC モデルでは、バイナリ学習器が陽性または陰性として扱うクラスの観測値が入力チャンクに含まれているときにのみバイナリ学習器に学習させます。そのため、予測されるすべてのクラスに対して入力データのラベルが適切に分散していない場合は、符号化行列にゼロを含まない符号化設計を選択して、すべてのバイナリ学習器にすべてのチャンクについて学習させることが推奨されます。

インクリメンタル学習用の新しい ECOC モデルを作成します。onevsall の符号化設計を指定します。この設計では、バイナリ学習器ごとに 1 つのクラスが陽性で残りが陰性になります。

MdlLate = incrementalClassificationECOC(MaxNumClasses=5,Coding="onevsall")

MdlLate = 
  incrementalClassificationECOC

            IsWarm: 0
           Metrics: [1×2 table]
        ClassNames: [1×0 double]
    ScoreTransform: 'none'
    BinaryLearners: {5×1 cell}
        CodingName: 'onevsall'
          Decoding: 'lossweighted'


  Properties, Methods

符号化設計行列を表示します。

MdlLate.CodingMatrix

ans = 5×5

     1    -1    -1    -1    -1
    -1     1    -1    -1    -1
    -1    -1     1    -1    -1
    -1    -1    -1     1    -1
    -1    -1    -1    -1     1

インクリメンタル モデルを当てはめて結果をプロットします。1 番目と 5 番目のバイナリ学習器の 1 番目のモデル係数 $${\beta }_{11}$$ と $${\beta }_{51}$$ を保存します。

mcnew = array2table(zeros(nchunk,2),VariableNames=["Cumulative","Window"]);
beta11new = zeros(nchunk,1);    
beta51new = zeros(nchunk,1); 

for j = 1:nchunk
    ibegin = min(n,numObsPerChunk*(j-1) + 1);
    iend   = min(n,numObsPerChunk*j);
    idx = ibegin:iend;    
    MdlLate = updateMetricsAndFit(MdlLate,Xnew(idx,:),Ynew(idx));
    mcnew{j,:} = MdlLate.Metrics{"ClassificationError",:};
    beta11new(j) = MdlLate.BinaryLearners{1}.Beta(1);
    beta51new(j) = MdlLate.BinaryLearners{5}.Beta(1);
end

t = tiledlayout(3,1);
nexttile
plot(beta11new)
xline(MdlLate.MetricsWarmupPeriod/numObsPerChunk,"--")
xline((n-m)/numObsPerChunk,":")
ylabel("\beta_{11}")
xlim([0 nchunk])
nexttile
plot(beta51new)
xline(MdlLate.MetricsWarmupPeriod/numObsPerChunk,"--")
xline((n-m)/numObsPerChunk,":")
ylabel("\beta_{51}")
xlim([0 nchunk])
nexttile
plot(mcnew.Variables)
xline(MdlLate.MetricsWarmupPeriod/numObsPerChunk,"--")
xline((n-m)/numObsPerChunk,":")
xlim([0 nchunk])
ylabel("Classification Error")
legend(mcnew.Properties.VariableNames,Location="best")
xlabel(t,"Iteration")

関数 updateMetricsAndFit は、インクリメンタル学習全体を通してモデルに学習させます。ただし、5 番目のクラスの観測値が入力チャンクに含まれるまで (垂直な点線)、$${\beta }_{51}$$ は大きくは変化しません。また、関数は予測される数のクラスにモデルが当てはめられて初めてパフォーマンス メトリクスの追跡を開始します。

すべてのクラス名の指定

データに含まれるすべてのクラス名がわかっている場合にインクリメンタル ECOC モデルを作成します。

デバイスに学習させ、被験者で測定された生体データに基づいて、被験者が座る、立つ、歩く、走る、踊るのいずれの状態であるかを予測するとします。各行動にはクラス名 1 ～ 5 をマッピングします。

マルチクラス学習用のインクリメンタル ECOC モデルを作成します。クラス名を指定します。

classnames = 1:5;
Mdl = incrementalClassificationECOC(ClassNames=classnames)

Mdl = 
  incrementalClassificationECOC

            IsWarm: 0
           Metrics: [1×2 table]
        ClassNames: [1 2 3 4 5]
    ScoreTransform: 'none'
    BinaryLearners: {10×1 cell}
        CodingName: 'onevsone'
          Decoding: 'lossweighted'


  Properties, Methods

Mdl は incrementalClassificationECOC モデル オブジェクトです。そのプロパティはすべて読み取り専用です。

Mdl は、他の演算の実行に使用する前に、データに当てはめなければなりません。

人の行動のデータ セットを読み込みます。データをランダムにシャッフルします。

load humanactivity
n = numel(actid);
rng(1) % For reproducibility
idx = randsample(n,n);
X = feat(idx,:);
Y = actid(idx);

データ セットの詳細については、コマンド ラインで Description を入力してください。

関数 updateMetricsAndFit を使用して、インクリメンタル モデルを学習データに当てはめます。50 個の観測値のチャンクを一度に処理して、データ ストリームをシミュレートします。各反復で次を行います。

• 50 個の観測値を処理します。

• 前のインクリメンタル モデルを、入力観測値に当てはめた新しいモデルで上書きします。

% Preallocation
numObsPerChunk = 50;
nchunk = floor(n/numObsPerChunk);

% Incremental learning
for j = 1:nchunk
    ibegin = min(n,numObsPerChunk*(j-1) + 1);
    iend   = min(n,numObsPerChunk*j);
    idx = ibegin:iend;    
    Mdl = updateMetricsAndFit(Mdl,X(idx,:),Y(idx));
end

インクリメンタル学習オプションの構成

クラスの最大数の指定に加え、メトリクスのウォームアップ期間とメトリクス ウィンドウ サイズを指定して、インクリメンタル ECOC 学習器を準備します。

人の行動のデータ セットを読み込みます。データをランダムにシャッフルします。予測子データの観測値を列に配置します。

load humanactivity
n = numel(actid);
rng(1) % For reproducibility
idx = randsample(n,n);
X = feat(idx,:)';
Y = actid(idx);

データ セットの詳細については、コマンド ラインで Description を入力してください。

マルチクラス学習用のインクリメンタル ECOC モデルを作成します。次のようにモデルを構成します。

• クラスの最大数を 5 に設定します。

• メトリクスのウォームアップ期間を観測値 5000 個に指定します。

• メトリクス ウィンドウ サイズを観測値 500 個に指定します。

Mdl = incrementalClassificationECOC(MaxNumClasses=5, ...
    MetricsWarmupPeriod=5000,MetricsWindowSize=500)

Mdl = 
  incrementalClassificationECOC

            IsWarm: 0
           Metrics: [1×2 table]
        ClassNames: [1×0 double]
    ScoreTransform: 'none'
    BinaryLearners: {10×1 cell}
        CodingName: 'onevsone'
          Decoding: 'lossweighted'


  Properties, Methods

Mdl はインクリメンタル学習用に構成された incrementalClassificationECOC モデル オブジェクトです。既定では、incrementalClassificationECOC は分類誤差損失を使用してモデルの性能を測定します。

関数 updateMetricsAndFit を使用して、インクリメンタル モデルを残りのデータに当てはめます。各反復で次を行います。

• 50 個の観測値のチャンクを処理して、データ ストリームをシミュレートします。

• 前のインクリメンタル モデルを、入力観測値に当てはめた新しいモデルで上書きします。観測値の向きを列方向に指定します。

• 1 番目のバイナリ学習器の 1 番目のモデル係数 $${\beta }_{11}$$、累積メトリクス、およびウィンドウ メトリクスを保存し、インクリメンタル学習中にそれらがどのように進化するかを確認します。

% Preallocation
numObsPerChunk = 50;
nchunk = floor(n/numObsPerChunk);
ce = array2table(zeros(nchunk,2),VariableNames=["Cumulative","Window"]);
beta11 = zeros(nchunk,1);    

% Incremental fitting
for j = 1:nchunk
    ibegin = min(n,numObsPerChunk*(j-1) + 1);
    iend   = min(n,numObsPerChunk*j);
    idx = ibegin:iend;    
    Mdl = updateMetricsAndFit(Mdl,X(:,idx),Y(idx),ObservationsIn="columns");
    ce{j,:} = Mdl.Metrics{"ClassificationError",:};
    beta11(j) = Mdl.BinaryLearners{1}.Beta(1);
end

Mdl は、ストリーム内のすべてのデータで学習させた incrementalClassificationECOC モデル オブジェクトです。インクリメンタル学習中およびモデルがウォームアップされた後、updateMetricsAndFit は入力観測値でモデルの性能をチェックし、モデルをその観測値に当てはめます。

パフォーマンス メトリクスと $${\beta }_{11}$$ が学習中にどのように進化するかを確認するには、それらを別々のタイルにプロットします。

t = tiledlayout(2,1);
nexttile
plot(beta11)
ylabel("\beta_{11}")
xlim([0 nchunk])
xline(Mdl.MetricsWarmupPeriod/numObsPerChunk,"--")
nexttile
plot(ce.Variables)
xlim([0 nchunk])
ylabel("Classification Error")
xline(Mdl.MetricsWarmupPeriod/numObsPerChunk,"--")
legend(ce.Properties.VariableNames)
xlabel(t,"Iteration")

このプロットは、updateMetricsAndFit が次のアクションを実行することを示しています。

• $${\beta }_{11}$$ をインクリメンタル学習のすべての反復で当てはめます。

• パフォーマンス メトリクスをメトリクスのウォームアップ期間 (垂直な破線) の後にのみ計算します。

• 累積メトリクスを各反復中に計算します。

• ウィンドウ メトリクスを 500 個の観測値 (10 回の反復) の処理後に計算します。

従来式の学習済みモデルのインクリメンタル学習器への変換

fitcecoc を使用して、マルチクラス分類用の ECOC モデルに学習させます。次に、そのモデルをインクリメンタル学習器に変換し、その性能を追跡し、モデルをストリーミング データに当てはめます。学習オプションを従来式からインクリメンタル学習に引き継ぎます。

データの読み込みと前処理

人の行動のデータ セットを読み込みます。データをランダムにシャッフルします。

load humanactivity
rng(1) % For reproducibility
n = numel(actid);
idx = randsample(n,n);
X = feat(idx,:);
Y = actid(idx);

データ セットの詳細については、コマンド ラインで Description を入力してください。

被験者が静止 (Y <= 2) していたときの収集データが、被験者が移動していたときのデータの倍の品質であると仮定します。静止している被験者から収集した観測値に 2 を割り当て、移動している被験者から収集した観測値に 1 を割り当てる重み変数を作成します。

W = ones(n,1) + (Y <= 2);

ECOC モデルの学習

マルチクラス分類用の ECOC モデルをデータの半分の無作為標本に当てはめます。

idxtt = randsample([true false],n,true);
TTMdl = fitcecoc(X(idxtt,:),Y(idxtt),Weights=W(idxtt))

TTMdl = 
  ClassificationECOC
             ResponseName: 'Y'
    CategoricalPredictors: []
               ClassNames: [1 2 3 4 5]
           ScoreTransform: 'none'
           BinaryLearners: {10×1 cell}
               CodingName: 'onevsone'


  Properties, Methods

TTMdl は従来式の学習済み ECOC モデルを表す ClassificationECOC モデル オブジェクトです。

学習済みモデルの変換

従来式の学習済み ECOC モデルをインクリメンタル学習用のモデルに変換します。

IncrementalMdl = incrementalLearner(TTMdl)

IncrementalMdl = 
  incrementalClassificationECOC

            IsWarm: 1
           Metrics: [1×2 table]
        ClassNames: [1 2 3 4 5]
    ScoreTransform: 'none'
    BinaryLearners: {10×1 cell}
        CodingName: 'onevsone'
          Decoding: 'lossweighted'


  Properties, Methods

IncrementalMdl はインクリメンタル学習用に構成された incrementalClassificationECOC モデル オブジェクトです。

パフォーマンス メトリクスの追跡とモデルの当てはめの個別の実行

関数 updateMetrics および fit を使用して、残りのデータに対してインクリメンタル学習を実行します。50 個の観測値を一度に処理して、データ ストリームをシミュレートします。各反復で次を行います。

1. updateMetrics を呼び出し、観測値の入力チャンクを所与として、モデルの分類誤差の累積とウィンドウを更新します。前のインクリメンタル モデルを上書きして、Metrics プロパティを更新します。関数がモデルをデータ チャンクに当てはめないことに注意してください。チャンクはモデルに対して "新しい" データです。観測値の重みを指定します。

2. fit を呼び出して、観測値の入力チャンクにモデルを当てはめます。前のインクリメンタル モデルを上書きして、モデル パラメーターを更新します。観測値の重みを指定します。

3. 分類誤差と 1 番目のバイナリ学習器の 1 番目のモデル係数 $${\beta }_{11}$$ を保存します。

% Preallocation
idxil = ~idxtt;
nil = sum(idxil);
numObsPerChunk = 50;
nchunk = floor(nil/numObsPerChunk);
ec = array2table(zeros(nchunk,2),VariableNames=["Cumulative","Window"]);
beta11 = [IncrementalMdl.BinaryLearners{1}.Beta(1); zeros(nchunk+1,1)];
Xil = X(idxil,:);
Yil = Y(idxil);
Wil = W(idxil);

% Incremental fitting
for j = 1:nchunk
    ibegin = min(nil,numObsPerChunk*(j-1) + 1);
    iend   = min(nil,numObsPerChunk*j);
    idx = ibegin:iend;
    IncrementalMdl = updateMetrics(IncrementalMdl,Xil(idx,:),Yil(idx), ...
        Weights=Wil(idx));
    ec{j,:} = IncrementalMdl.Metrics{"ClassificationError",:};
    IncrementalMdl = fit(IncrementalMdl,Xil(idx,:),Yil(idx),Weights=Wil(idx));
    beta11(j+1) = IncrementalMdl.BinaryLearners{1}.Beta(1);
end

IncrementalMdl は、ストリーム内のすべてのデータで学習させた incrementalClassificationECOC モデル オブジェクトです。

あるいは、updateMetricsAndFit を使用して、新しいデータ チャンクに対するモデルのパフォーマンス メトリクスを更新し、モデルをデータに当てはめることもできます。

パフォーマンス メトリクスと推定された係数 $${\beta }_{11}$$ のトレース プロットを別々のタイルにプロットします。

t = tiledlayout(2,1);
nexttile
plot(ec.Variables)
xlim([0 nchunk])
ylabel("Classification Error")
legend(ec.Properties.VariableNames)
nexttile
plot(beta11)
ylabel("\beta_{11}")
xlim([0 nchunk])
xlabel(t,"Iteration")

累積の損失はすぐに平坦になり安定していますが、ウィンドウの損失には学習全体を通じて急な変動があります。

$${\beta }_{11}$$ はまず急激に変動した後、fit がより多くのチャンクを処理するにつれて徐々に平坦になります。

バイナリ学習器の指定

名前と値の引数 Learners を指定して incrementalClassificationECOC モデル オブジェクトのバイナリ学習器をカスタマイズします。

最初に、incrementalClassificationLinear オブジェクトを作成してバイナリ学習器のプロパティを構成します。線形分類モデルのタイプ (Learner) をロジスティック回帰に設定し、Standardize を true と指定して予測子データを標準化します。

binaryMdl = incrementalClassificationLinear(Learner="logistic", ...
    Standardize=true)

binaryMdl = 
  incrementalClassificationLinear

            IsWarm: 0
           Metrics: [1×2 table]
        ClassNames: [1×0 double]
    ScoreTransform: 'logit'
              Beta: [0×1 double]
              Bias: 0
           Learner: 'logistic'


  Properties, Methods

マルチクラス学習用のインクリメンタル ECOC モデルを作成します。データに含まれるクラスの数を 5 と指定し、バイナリ学習器テンプレート (Learners) を binaryMdl に設定します。

Mdl = incrementalClassificationECOC(MaxNumClasses=5,Learners=binaryMdl)

Mdl = 
  incrementalClassificationECOC

            IsWarm: 0
           Metrics: [1×2 table]
        ClassNames: [1×0 double]
    ScoreTransform: 'none'
    BinaryLearners: {10×1 cell}
        CodingName: 'onevsone'
          Decoding: 'lossweighted'


  Properties, Methods

Mdl の BinaryLearners プロパティを表示します。

Mdl.BinaryLearners

ans=10×1 cell array
    {1×1 incrementalClassificationLinear}
    {1×1 incrementalClassificationLinear}
    {1×1 incrementalClassificationLinear}
    {1×1 incrementalClassificationLinear}
    {1×1 incrementalClassificationLinear}
    {1×1 incrementalClassificationLinear}
    {1×1 incrementalClassificationLinear}
    {1×1 incrementalClassificationLinear}
    {1×1 incrementalClassificationLinear}
    {1×1 incrementalClassificationLinear}

既定では、incrementalClassificationECOC は 1 対 1 の符号化設計を使用するので、5 クラスの場合は 10 個の学習器が必要になります。そのため、BinaryLearners プロパティに incrementalClassificationLinear タイプの 10 個のバイナリ学習器が格納されます。

詳細

インクリメンタル学習

"インクリメンタル学習" ("オンライン学習") は、予測子変数の分布、予測関数や目的関数の素性 (調整パラメーターの値を含む)、観測値にラベル付けがされているか等についてほぼ知識が無い時に、データ ストリームから入ってくるデータを処理することに関係している機械学習の一分野です。従来の機械学習は、モデルへの当てはめに十分にラベル付けされたデータを使用でき、交差検証を実施してハイパーパラメーターを調整し、予測子の分布を推論するもので、インクリメンタル学習と異なります。

入力観測値に対し、インクリメンタル学習モデルは、次のいずれかの方法 (通常はこの順序) でデータを処理します。

• ラベルを予測します。

• 予測性能を測定します。

• モデルの構造的な破綻やドリフトについてチェックします。

• 入力観測値へモデルを当てはめます。

詳細については、インクリメンタル学習の概要を参照してください。

インクリメンタル学習用の適応型スケール不変ソルバー

"インクリメンタル学習用の適応型スケール不変ソルバー" ([5]で紹介) は、線形予測モデルに学習させるための勾配降下法ベースの目的ソルバーです。ソルバーはハイパーパラメーターを持たず、予測子変数のスケールの違いの影響を受けず、予測子変数の分布の事前知識が不要です。これらの特徴は、インクリメンタル学習に適しています。

インクリメンタル近似関数 fit および updateMetricsAndFit は、アルゴリズムのより積極的な ScInOL2 バージョンを使用してバイナリ学習器に学習させます。関数でモデルを当てはめる前にデータの入力バッチが常にシャッフルされます。

誤り訂正出力符号モデル

"誤り訂正出力符号 (ECOC) モデル" は、3 つ以上のクラスがある分類の問題を一連のバイナリ分類問題に縮小します。

ECOC 分類は、バイナリ学習器が学習するクラスを決定する符号化設計と、バイナリ学習器の結果 (予測) が集計される方法を決定する復号化スキームを必要とします。

以下のように仮定します。

• 分類問題には 3 つのクラスがある。

• 符号化設計が 1 対 1 である。3 クラスの場合、この符号化設計は次のようになります。

  $$\begin{array}{cccc}& \text{Learner 1}& \text{Learner 2}& \text{Learner 3}\\ \text{Class 1}& 1& 1& 0\\ \text{Class 2}& -1& 0& 1\\ \text{Class 3}& 0& -1& -1\end{array}$$

  分類モデルを作成するときに、名前と値の引数 Coding を使用して別の符号化設計を指定できます。

• モデルでの予測クラスの判定にバイナリ損失関数 g による損失に重みを付けた復号化方式を使用する。ソフトウェアでは損失に基づく復号化方式もサポートされます。復号化方式とバイナリ損失関数は、分類モデルを作成するとき、またはオブジェクト関数 predict および loss を呼び出すときに、名前と値の引数 Decoding と BinaryLoss を使用してそれぞれ指定できます。

この分類モデルをビルドするための ECOC アルゴリズムの手順は次のとおりです。

1. 学習器 1 は、クラス 1 またはクラス 2 の観測値について学習を行い、クラス 1 を陽性クラス、クラス 2 を陰性クラスとして扱います。他の学習器の学習も同様に実行します。

2. 次のように仮定します。M は要素 m_kl をもつ符号化設計行列です。s_l は学習器 l の陽性クラスの予測された分類スコアです。新しい観測値は、L 個のバイナリ学習器について損失の合計が最小になるクラス ($$\widehat{k}$$) に割り当てられます。

   $$\widehat{k}=\underset{k}{\text{argmin}}\frac{{\displaystyle \sum }_{l=1}^B\left|m_{kl}\right|g\left(m_{kl},s_l\right)}{{\displaystyle \sum }_{l=1}^B\left|m_{kl}\right|}.$$

ECOC モデルは他のマルチクラス モデルと比較して分類精度を向上させることができます[4]。

符号化設計

"符号化設計" は、各バイナリ学習器がどのクラスを学習したのかを要素が指示する行列です。つまり、マルチクラス問題がどのように一連のバイナリ問題にされたのかを示します。

符号化設計の各行は各クラスに対応し、各列はバイナリ学習器に対応します。三項符号化設計では、特定の列 (バイナリ学習器) に対して以下が実行されます。

• 1 が含まれている行の場合、対応するクラスの観測値をすべて陽性クラスにグループ化するようバイナリ学習器に指示します。

• –1 が含まれている行の場合、対応するクラスの観測値をすべて陰性クラスにグループ化するようバイナリ学習器に指示します。

• 0 が含まれている行の場合、対応するクラスの観測値をすべて無視するようバイナリ学習器に指示します。

ハミング尺度に基づく行の最小ペアワイズ距離が大きい符号化設計行列が最適です。行のペアワイズ距離の詳細については、ランダム符号化設計行列および[3]を参照してください。

次の表は一般的な符号化設計について説明しています。

符号化設計	説明	学習器の数	行の最小ペアワイズ距離
OVA (1 対他)	各バイナリ学習器では、1 つのクラスは陽性で残りは陰性です。この計画は陽性クラス割り当てのすべての組み合わせを使用します。	K	2
OVO (1 対 1)	各バイナリ学習器では、1 つのクラスが陽性で、1 つのクラスが陰性です。残りは無視されます。この計画はすべてのクラス ペアの割り当ての組み合わせを使用します。	K(K – 1)/2	1
完全二項	この計画はクラスをすべて 2 つの組み合わせに分割します。いずれのクラスも無視されません。つまり、すべてのクラス割り当てが –1 および 1 になり、各バイナリ学習器について 1 つ以上の陽性クラスおよび 1 つ以上の陰性クラスが割り当てに含まれます。	2K – 1 – 1	2K – 2
完全三項	この計画はクラスをすべて 3 つの組み合わせに分割します。つまり、すべてのクラス割り当てが 0、–1 および 1 になり、各バイナリ学習器について 1 つ以上の陽性クラスおよび 1 つ以上の陰性クラスが割り当てに含まれます。	(3K – 2K + 1 + 1)/2	3K – 2
順序	1 番目のバイナリ学習器では、1 番目のクラスが陰性であり、残りは陽性です。2 番目のバイナリ学習器では、最初の 2 つのクラスが陰性であり、残りは陽性です。他についても同様です。	K – 1	1
密なランダム	各バイナリ学習器には、陽性または陰性クラス (少なくとも各 1 つ) が無作為に割り当てられます。詳細については、ランダム符号化設計行列を参照してください。	ランダム。ただし、約 10 log2K	変数
スパース ランダム	各バイナリ学習器では、各クラスに確率 0.25 で陽性または陰性が無作為に割り当てられ、確率が 0.5 の場合にクラスが無視されます。詳細については、ランダム符号化設計行列を参照してください。	ランダム。ただし、約 15 log2K	変数

このプロットは符号化設計のバイナリ学習器の数を増加するクラス数 (K) と比較します。

バイナリ損失

"バイナリ損失" は、バイナリ学習器がどの程度の精度で観測値をクラスに分類するかを決定する、クラスと分類スコアの関数です。ソフトウェアでバイナリ損失をどのように集計して各観測値の予測クラスを判定するかは、ECOC モデルの "復号化方式" で指定します。

以下のように仮定します。

• m_kj は符号化設計行列 M の要素 (k,j)、つまりバイナリ学習器 j のクラス k に対応する符号。M は K 行 B 列の行列であり、K はクラスの数、B はバイナリ学習器の数です。

• s_j は観測値に対するバイナリ学習器 j のスコア。

• g はバイナリ損失関数。

• $$\widehat{k}$$ は観測値の予測クラス。

ソフトウェアでは 2 つの復号化方式をサポートしています。

• "損失に基づく復号化" [3] (Decoding が "lossbased") — 観測値の予測クラスは、すべてのバイナリ学習器におけるバイナリ損失の平均が最小になるクラスに対応します。

  $$\widehat{k}=\underset{k}{\text{argmin}}\frac{1}{B}{\displaystyle \sum _{j=1}^B\left|m_{kj}\right|g}(m_{kj},s_j).$$

• "損失に重みを付けた復号化" [2] (Decoding が "lossweighted") — 観測値の予測クラスは、対応するクラスのバイナリ学習器におけるバイナリ損失の平均が最小になるクラスに対応します。

  $$\widehat{k}=\underset{k}{\text{argmin}}\frac{{\displaystyle \sum _{j=1}^B\left|m_{kj}\right|g}(m_{kj},s_j)}{{\displaystyle \sum }_{j=1}^B\left|m_{kj}\right|}.$$

  分母はクラス k のバイナリ学習器の数に対応します。[1]によると、すべてのクラスの損失値が同じダイナミック レンジに収まるので、損失に重みを付けた復号化では分類精度が向上します。

関数 predict、resubPredict、および kfoldPredict は、それぞれの観測値とクラスについて、argmin の目的関数の符号反転値を 2 番目の出力引数 (NegLoss) として返します。

次の表は、サポートされる損失関数をまとめたものです。ここで、y_j は特定のバイナリ学習器のクラス ラベル (集合 {–1,1,0} 内)、s_j は観測値 j のスコア、g(y_j,s_j) はバイナリ損失関数です。

値	説明	スコア領域	g(yj,sj)
"binodeviance"	二項分布からの逸脱度	(–∞,∞)	log[1 + exp(–2yjsj)]/[2log(2)]
"exponential"	指数	(–∞,∞)	exp(–yjsj)/2
"hamming"	ハミング	[0,1] または (–∞,∞)	[1 – sign(yjsj)]/2
"hinge"	ヒンジ	(–∞,∞)	max(0,1 – yjsj)/2
"linear"	線形	(–∞,∞)	(1 – yjsj)/2
"logit"	ロジスティック	(–∞,∞)	log[1 + exp(–yjsj)]/[2log(2)]
"quadratic"	2 次	[0,1]	[1 – yj(2sj – 1)]2/2

y_j = 0 のときに損失が 0.5 になるようにバイナリ損失が正規化され、バイナリ学習器の平均が集計に使用されます[1]。

ECOC 分類器の全体的な性能の尺度である全体の分類損失 (オブジェクト関数 loss および predict の名前と値の引数 LossFun により指定) とバイナリ損失を混同しないでください。

分類誤差

"分類誤差" は次のような形式になります。

$$L={\displaystyle \sum _{j=1}^n{w}_j{e}_j},$$

ここで

• w_j は観測値 j の重みです。重みは再度正規化され、合計は 1 になります。

• 観測 j の予測クラスが真のクラスと異なる場合、e_j = 1 になり、それ以外の場合は 0 になります。

つまり、分類誤差は、分類器が誤分類した観測値の比率です。

アルゴリズム

パフォーマンス メトリクス

• 関数 updateMetrics および updateMetricsAndFit は、インクリメンタル モデルが "ウォーム" (IsWarm プロパティが true) のときにのみ、新しいデータからモデルのパフォーマンス メトリクス (Metrics) を追跡します。

  • incrementalLearner を使用してインクリメンタル モデルを作成するときに、MetricsWarmupPeriod が 0 (incrementalLearner の既定値) である場合、モデルは作成時にウォームになります。

  • それ以外の場合、インクリメンタル モデルは、fit または updateMetricsAndFit で次の両方のアクションを実行するとウォームになります。

    • インクリメンタル モデルを MetricsWarmupPeriod の観測値 ("メトリクスのウォームアップ期間") に当てはめる。

    • インクリメンタル モデルを予測されるすべてのクラスに当てはめる (incrementalClassificationECOC の引数 MaxNumClasses と ClassNames を参照)。

• インクリメンタル モデルの Metrics プロパティは、各パフォーマンス メトリクスの 2 つの形式を table の変数 (列) Cumulative および Window とし、個々のメトリクスを行に格納します。インクリメンタル モデルがウォームになると、updateMetrics および updateMetricsAndFit は次の頻度でメトリクスを更新します。

  • Cumulative — 関数は、モデルの性能追跡の開始以降の累積メトリクスを計算します。関数は、関数が呼び出されるたびにメトリクスを更新し、提供されたデータ セット全体に基づいて計算を行います。

  • Window — 関数は、MetricsWindowSize によって決定されたウィンドウ内のすべての観測値に基づいてメトリクスを計算します。これによってソフトウェアが Window メトリクスを更新する頻度も決まります。たとえば、MetricsWindowSize が 20 の場合、関数は提供されたデータの最後の 20 個の観測値に基づいてメトリクスを計算します (X((end – 20 + 1):end,:) および Y((end – 20 + 1):end))。

    ウィンドウ内のパフォーマンス メトリクスを追跡するインクリメンタル関数は、次のプロセスを使用します。

    1. 指定された各メトリクスについて長さ MetricsWindowSize のバッファーを保存し、観測値の重みのバッファーを保存します。

    2. 入力観測値のバッチに基づくモデル性能をメトリクス バッファーの要素に入力し、対応する観測値の重みを重みバッファーに格納します。

    3. バッファーがいっぱいになると、Metrics プロパティの Window フィールドをメトリクス ウィンドウの性能の加重平均で上書きします。関数が観測値のバッチを処理するときにバッファーがあふれる場合、最新の入力観測値 MetricsWindowSize がバッファーに入り、最も古い観測値がバッファーから削除されます。たとえば、MetricsWindowSize が 20 で、メトリクス バッファーには前に処理されたバッチからの 10 個の値が存在し、15 個の値が入力されるとします。長さ 20 のウィンドウを構成するため、関数は 15 個の入力観測値からの測定値と前のバッチからの最新の 5 個の測定値を使用します。

• Cumulative と Window のパフォーマンス メトリクスの値を計算する際、スコアが NaN の観測値は省略されます。

カスタム符号化設計行列

カスタム符号化行列は特定の形式でなければなりません。ソフトウェアによるカスタム符号化行列の検証では、以下について確認されます。

• すべての要素が –1、0、または 1 である。

• すべての列に –1 および 1 が少なくとも 1 つずつ含まれている。

• すべての列ベクトル u と v のそれぞれについて、u ≠ v かつ u ≠ –v である。

• すべての行ベクトルが一意である。

• 行列は任意の 2 つのクラスを分離できます。つまり、任意の行から他の任意の行に次のルールに従って移動できる。

  • 1 から –1 または –1 から 1 に垂直方向に移動。

  • 非ゼロ要素から別の非ゼロ要素に水平方向に移動。

  • 垂直方向の移動に行列の列を一度だけ使用。

  上記のルールを使用して、行 i から行 j に移動できない場合、クラス i および j は計画により分離できません。たとえば、次の符号化設計ではクラス 1 および 2 をクラス 3 および 4 から分離できません。

  $$\left[\begin{array}{cc}1& 0\\ -1& 0\\ 0& 1\\ 0& -1\end{array}\right]$$

  2 行目の 2 列目に 0 があるので、2 行目の –1 を 2 列目に水平に移動できません。したがって、この符号化設計は拒否されます。

ランダム符号化設計行列

K 個のクラスに対して、ランダム符号化設計行列が以下のように生成されます。

1. 次のいずれかの行列が生成されます。

   1. 密なランダム — K 行 L_d 列の符号化設計行列の各要素に同じ確率で 1 または –1 が割り当てられます。ここで $$L_d\approx \lceil 10{\log }_{2}K\rceil$$ です。

   2. スパース ランダム — K 行 L_s 列の符号化設計行列の各要素に 0.25 の確率で 1、0.25 の確率で -1、0.5 の確率で 0 が割り当てられます。ここで $$L_s\approx \lceil 15{\log }_{2}K\rceil$$ です。

2. 1 および –1 が少なくとも 1 つずつ列に含まれていない場合、その列は削除されます。

3. 異なる列 u および v について u = v または u = –v である場合、v が符号化設計行列から削除されます。

既定では 10,000 個の行列が無作為に生成されます。次によって与えられるハミング尺度 ([3]) に基づき、行の最小ペアワイズ距離が最大になる行列が保持されます。

$$\Delta (k_1,k_2)=0.5{\displaystyle \sum }_{l=1}^L\left|m_{k_{1}l}\right|\left|m_{k_{2}l}\right|\left|m_{k_{1}l}-m_{k_{2}l}\right|,$$

ここで、m_kjl は符号化設計行列 j の要素です。

参照

[1] Allwein, E., R. Schapire, and Y. Singer. “Reducing multiclass to binary: A unifying approach for margin classifiers.” Journal of Machine Learning Research. Vol. 1, 2000, pp. 113–141.

[2] Escalera, S., O. Pujol, and P. Radeva. “On the decoding process in ternary error-correcting output codes.” IEEE Transactions on Pattern Analysis and Machine Intelligence. Vol. 32, Issue 7, 2010, pp. 120–134.

[3] Escalera, S., O. Pujol, and P. Radeva. “Separability of ternary codes for sparse designs of error-correcting output codes.” Pattern Recog. Lett. Vol. 30, Issue 3, 2009, pp. 285–297.

[4] Fürnkranz, Johannes. “Round Robin Classification.” J. Mach. Learn. Res., Vol. 2, 2002, pp. 721–747.

[5] Kempka, Michał, Wojciech Kotłowski, and Manfred K. Warmuth. "Adaptive Scale-Invariant Online Algorithms for Learning Linear Models." Preprint, submitted February 10, 2019. https://arxiv.org/abs/1902.07528.

拡張機能

C/C++ コード生成

MATLAB® Coder™ を使用して C および C++ コードを生成します。 (R2025a 以降)

使用上の注意および制限:

• fit、loss、predict、updateMetrics、および updateMetricsAndFit の各関数はコード生成をサポートします。

• incrementalClassificationECOC モデル オブジェクトを作成する場合、次の制限が適用されます。

  • ClassNames と NumPredictors を指定しなければなりません。

  • バイナリ学習器は線形でなければなりません。

• incrementalClassificationECOC モデル オブジェクトを読み込むか作成するコードを生成する場合、次の制限が適用されます。

  • 予測子変数の数は Mdl.NumPredictors と等しくなければなりません。

  • 予測されるすべてのクラス名を ClassNames プロパティに含めなければなりません。

詳細は、コード生成の紹介を参照してください。

バージョン履歴

R2022a で導入

参考

incrementalLearner | fitcecoc | ClassificationECOC | CompactClassificationECOC

トピック

• インクリメンタル学習の概要
• インクリメンタル学習モデルの構成
• 簡潔なワークフローを使用した分類用のインクリメンタル学習の実装
• 柔軟なワークフローを使用した分類用のインクリメンタル学習の実装