Python ニューラルネットワークで自動車保険の支出を予測する

[[381201]]

新しいデータセット用のニューラルネットワーク予測モデルの開発は困難な場合があります。

1 つのアプローチは、最初にデータセットを調べて、使用できるモデルのアイデアを開発し、次にデータセット上の単純なモデルの学習ダイナミクスを調査し、最後に堅牢なテストハーネスを使用してデータセット用のモデルを開発および調整することです。このプロセスは、分類および回帰予測モデリングの問題に効果的なニューラルネットワークモデルを開発するために使用できます。

このチュートリアルでは、スウェーデンの自動車保険回帰データセット用の多層パーセプトロンニューラルネットワークモデルを開発する方法を学びます。このチュートリアルを完了すると、次のことが分かります。

スウェーデンの自動車保険データセットを読み込んで要約し、その結果を使用して使用するデータの準備とモデル構成を提案する方法。
シンプルな MLP モデルの学習ダイナミクスとデータセット上のデータ変換を探索する方法。
モデルのパフォーマンスの信頼性の高い推定値を作成し、モデルのパフォーマンスを調整し、新しいデータに基づいて予測を行う方法。

チュートリアルの概要

このチュートリアルは 4 つのパートに分かれています。彼らです：

自動車保険回帰データセット
最初のMLPと学習ダイナミクス
MLPモデルの評価と調整
最終モデルと予測の作成

自動車保険回帰データセット

最初のステップは、データセットを定義して調査することです。「自動車保険」標準回帰データセットを使用します。このデータセットは、スウェーデンの自動車保険について説明しています。入力変数は請求件数という 1 つのみであり、ターゲット変数は請求総額 (スウェーデンクローナ単位) です。目標は、請求件数に基づいて支払総額を予測することです。

データセットの詳細については、こちらをご覧ください:

自動車保険データセット (auto-insurance.csv)
自動車保険データセットの詳細 (auto-insurance.names)

以下にデータセットの最初の数行を示します。

値は数十から数百までの範囲の数値であることがわかります。これは、ニューラルネットワークを使用してモデル化する場合、データに対して何らかのタイプのスケーリングが適切であることを示唆しています。

データセットを URL から直接 pandas DataFrame として読み込むことができます。例:

 # データセットをロードして形状を要約する 
 pandasからread_csvをインポートする 
 # データセットの場所を定義する 
 url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'    
 # データセットをロードする 
 df = read_csv (url、ヘッダー=なし)  
 # 形状を要約する 
印刷(df.shape)

例を実行すると、データセットが URL から直接読み込まれ、データセットの形状が報告されます。

この場合、このデータセットには 2 つの変数 (1 つの入力と 1 つの出力) があり、データセットには 63 行のデータがあることを確認できます。

これはニューラルネットワークにとって大量のデータ行ではないため、小規模なネットワーク (おそらく正規化を含む) が適切であると考えられます。

これはまた、k 分割クロス検証を使用することがよいアイデアであることを示唆しています。これは、トレーニング/テスト分割よりも信頼性の高いモデルパフォーマンスの推定値が提供され、単一のモデルを数時間または数日ではなく数秒で適合できるためです。最大のデータセット。

 （63、2）

次に、データの要約統計とプロットを見て、データセットについてさらに詳しく知ることができます。

 # データセットの要約統計とプロットを表示する 
 pandasからread_csvをインポートする 
 matplotlibからpyplotをインポートする 
 # データセットの場所を定義する 
 url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'    
 # データセットをロードする 
 df = read_csv (url、ヘッダー=なし)  
 # 概要統計を表示 
印刷(df.describe())  
 # ヒストグラムをプロットする 
 df.hist()  
 pyplot.show()

例を実行する前に、データをロードし、各変数の要約統計を出力します。

各変数の平均は 10 以内であり、0 から数百の範囲であることがわかります。これは、データをスケーリングすることが良いアイデアである可能性があることを裏付けています。

              0 1  
カウント 63.000000 63.000000  
平均 22.904762 98.187302  
標準 23.351946 87.327553  
最小 0.000000 0.000000  
 25% 7.500000 38.850000  
 50% 14.000000 73.400000  
 75% 29.000000 140.000000  
最大 124.000000 422.200000

次に、各変数のヒストグラムを作成します。

各変数は同様の分布をしていることがわかります。歪んだガウス分布または指数分布のように見えます。

各変数にべき乗変換を使用すると、確率分布の歪度が低減され、モデルのパフォーマンスが向上する可能性があります。

データセットについて理解できたので、ニューラルネットワークモデルの開発方法を調べてみましょう。

最初のMLPと学習ダイナミクス

TensorFlow を使用して、データセットの多層パーセプトロン (MLP) モデルを開発します。このデータセットに対してハイパーパラメータを学習するためのどのモデルアーキテクチャが適切または最適であるかはわかりません。そのため、実験して何がうまく機能するかを見つける必要があります。データセットが小さいと仮定すると、8 行または 16 行などの小さなバッチが適切なアイデアかもしれません。始めるときは、学習率を自動的に適応させ、ほとんどのデータセットでうまく機能するため、確率的勾配降下法の Adam バージョンを使用することをお勧めします。モデルを真剣に評価する前に、学習ダイナミクスを確認し、安定した学習ダイナミクスが得られるまでモデルアーキテクチャと学習構成を微調整してから、モデルを最大限に活用することをお勧めします。

単純なトレーニング/テストデータ分割でこれを実行し、学習曲線のプロットを確認できます。これにより、学習が過剰か不足かを把握し、それに応じて構成を調整できるようになります。まず、データセットを入力変数と出力変数に分割し、次に 67/33 のトレーニングセットとテストセットに分割します。

 # 入力列と出力列に分割 
 X, y = df .values[:, :-1], df .values[:, -1]  
 # トレーニングデータセットとテストデータセットに分割 
 X_train、X_test、y_train、 y_test = train_test_split (X、y、 test_size = 0.33 )

次に、最小限の MLP モデルを定義します。この場合、10 個のノードを持つ 1 つの隠し層と 1 つの出力層 (任意に選択) を使用します。良い習慣として、ReLU 活性化関数と 'he_normal' 重み初期化を隠し層で使用します。

モデルの出力は線形活性化（活性化なし）であり、平均二乗誤差（MSE）損失を最小化します。

 # 入力特徴の数を決定する 
 n_features = X .shape[1]  
 # モデルを定義する 
モデル=シーケンシャル()  
 model.add(Dense(10, activation = 'relu' , kernel_initializer = 'he_normal' , input_shape =(n_features,)))  
モデルを追加します(密(1))  
 # モデルをコンパイルする 
 model.compile(オプティマイザー= 'adam' 、損失= 'mse' )

データセットが小さいため、バッチサイズ 8 で 100 のトレーニングエポック (任意に選択) にモデルを適合させます。私たちは生データにモデルを当てはめていますが、これはおそらく良い考えではないと思いますが、重要な出発点です。

 # モデルに適合する 
 history = model .fit(X_train, y_train,エポック= 100 、 batch_size = 8 、 verbose = 0 、 validation_data =(X_test,y_test))

トレーニングの最後に、テストデータセットでモデルのパフォーマンスを評価し、パフォーマンスを平均絶対誤差 (MAE) として報告します。通常は MSE または RMSE を使用します。

 # テストセットを予測する 
 yhat =モデル.予測(X_test)  
 # 予測を評価する 
スコア=平均絶対誤差(y_test,yhat)  
 print('MAE: %.3f' % スコア)

最後に、トレーニング中のトレーニングセットとテストセットの MSE 損失の学習曲線をプロットします。

 # 学習曲線をプロットする 
 pyplot.title('学習曲線')  
 pyplot.xlabel('エポック')  
 pyplot.ylabel('平均二乗誤差')  
 pyplot.plot(history.history['loss'],ラベル= 'train' )  
 pyplot.plot(history.history['val_loss'],ラベル= 'val' )  
 pyplot.凡例()  
 pyplot.show()

以上を踏まえて、自動車保険データセットで最初の MLP を評価した完全な例を以下に示します。

 # シンプルな MLP モデルを適合し、学習曲線を確認します 
 pandasからread_csvをインポートする 
 sklearn.model_selection から train_test_split をインポートします 
 sklearn.metricsからmean_absolute_errorをインポートします 
 tensorflow.kerasからSequentialをインポートする 
 tensorflow.keras.layers から Dense をインポートします 
 matplotlibからpyplotをインポートする 
 # データセットをロードする 
パス= 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'    
 df = read_csv (パス、ヘッダー=なし)  
 # 入力列と出力列に分割 
 X, y = df .values[:, :-1], df .values[:, -1]  
 # トレーニングデータセットとテストデータセットに分割 
 X_train、X_test、y_train、 y_test = train_test_split (X、y、 test_size = 0.33 )  
 # 入力特徴の数を決定する 
 n_features = X .shape[1]  
 # モデルを定義する 
モデル=シーケンシャル()  
 model.add(Dense(10, activation = 'relu' , kernel_initializer = 'he_normal' , input_shape =(n_features,)))  
モデルを追加します(密(1))  
 # モデルをコンパイルする 
 model.compile(オプティマイザー= 'adam' 、損失= 'mse' )  
 # モデルに適合する 
 history = model .fit(X_train, y_train,エポック= 100 、 batch_size = 8 、 verbose = 0 、 validation_data =(X_test,y_test))  
 # テストセットを予測する 
 yhat =モデル.予測(X_test)  
 # 予測を評価する 
スコア=平均絶対誤差(y_test,yhat)  
 print('MAE: %.3f' % スコア)  
 # 学習曲線をプロットする 
 pyplot.title('学習曲線')  
 pyplot.xlabel('エポック')  
 pyplot.ylabel('平均二乗誤差')  
 pyplot.plot(history.history['loss'],ラベル= 'train' )  
 pyplot.plot(history.history['val_loss'],ラベル= 'val' )  
 pyplot.凡例()  
 pyplot.show()

例を実行すると、まずトレーニングデータセットにモデルを適合させ、次にテストデータセットの MAE を報告します。

注意: アルゴリズムや評価手順の確率的特性、または数値精度の違いにより、結果が異なる場合があります。例を複数回実行し、平均結果を比較することを検討してください。

この場合、モデルが約 33.2 の MAE を達成していることがわかります。これはパフォーマンスの適切なベースラインであり、おそらく改善できるものです。

前兆: 33.233

次に、トレーニングセットとテストセットの MSE の折れ線グラフを作成します。

モデルの適合度が高く、収束も良好であることがわかります。モデルの構成は良い出発点となります。

これまでのところ、学習の勢いは良好ですが、MAE は大まかな推定値であり、信頼すべきではありません。

おそらく、モデルの容量をわずかに増やすと、同様の学習ダイナミクスが期待できるでしょう。たとえば、8 つのノード (任意に選択) を持つ 2 番目の隠し層を追加し、トレーニングエポックの数を 200 に倍増することができます。

 # モデルを定義する 
モデル=シーケンシャル()  
 model.add(Dense(10, activation = 'relu' , kernel_initializer = 'he_normal' , input_shape =(n_features,)))  
 model.add(Dense(8, activation = 'relu' , kernel_initializer = 'he_normal' ))  
モデルを追加します(密(1))  
 # モデルをコンパイルする
model.compile(オプティマイザー= 'adam' 、損失= 'mse' )  
 # モデルに適合する 
 history = model .fit(X_train, y_train,エポック= 200 、 batch_size = 8 、 verbose = 0 、 validation_data =(X_test,y_test))

完全な例は次のとおりです。

 # より深いMLPモデルを適合させ、学習曲線を確認する 
 pandasからread_csvをインポートする 
 sklearn.model_selection から train_test_split をインポートします 
 sklearn.metricsからmean_absolute_errorをインポートします 
 tensorflow.kerasからSequentialをインポートする 
 tensorflow.keras.layers から Dense をインポートします 
 matplotlibからpyplotをインポートする
# データセットをロードする 
パス= 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'    
 df = read_csv (パス、ヘッダー=なし)  
 # 入力列と出力列に分割 
 X, y = df .values[:, :-1], df .values[:, -1]  
 # トレーニングデータセットとテストデータセットに分割 
 X_train、X_test、y_train、 y_test = train_test_split (X、y、 test_size = 0.33 )  
 # 入力特徴の数を決定する 
 n_features = X .shape[1]  
 # モデルを定義する 
モデル=シーケンシャル()  
 model.add(Dense(10, activation = 'relu' , kernel_initializer = 'he_normal' , input_shape =(n_features,)))  
 model.add(Dense(8, activation = 'relu' , kernel_initializer = 'he_normal' ))  
モデルを追加します(密(1))  
 # モデルをコンパイルする 
 model.compile(オプティマイザー= 'adam' 、損失= 'mse' )  
 # モデルに適合する 
 history = model .fit(X_train, y_train,エポック= 200 、 batch_size = 8 、 verbose = 0 、 validation_data =(X_test,y_test))  
 # テストセットを予測する 
 yhat =モデル.予測(X_test)  
 # 予測を評価する 
スコア=平均絶対誤差(y_test,yhat)  
 print('MAE: %.3f' % スコア)  
 # 学習曲線をプロットする 
 pyplot.title('学習曲線')  
 pyplot.xlabel('エポック')  
 pyplot.ylabel('平均二乗誤差')  
 pyplot.plot(history.history['loss'],ラベル= 'train' )  
 pyplot.plot(history.history['val_loss'],ラベル= 'val' )  
 pyplot.凡例()  
 pyplot.show()

例を実行すると、まずトレーニングデータセットにモデルを適合させ、次にテストデータセットの MAE を報告します。

この場合、MAE が 27.9 程度にわずかに改善されていることがわかりますが、トレーニングとテストの分割における大きなばらつきにより、この評価は信頼できません。

前兆: 27.939

次に、MSE トレーニングセットとテストセットの学習曲線をプロットします。予想どおり、モデルは良好な適合を達成し、妥当な反復回数内で収束していることがわかります。

最後に、データを変換して、それが学習ダイナミクスにどのように影響するかを確認します。

この場合、べき乗変換を使用してデータ分布の歪度を減らします。これにより、変数は平均が 0、標準偏差が 1 になるように自動的に標準化されます。これは、ニューラルネットワークを使用してモデル化する場合に適した方法です。

まず、ターゲット変数が 2 次元配列であることを確認する必要があります。

 # ターゲット変数が2次元配列であることを確認する 
 y_train、 y_test = y_train.reshape ((len(y_train),1)), y_test.reshape((len(y_test),1))

次に、入力変数とターゲット変数に PowerTransformer を適用します。

これは、まず変換をトレーニングデータに適合させ、次にトレーニングセットとテストセットを変換することによって実現できます。

このプロセスは、データ漏洩を防ぐために、入力変数と出力変数に個別に適用されます。

 # 入力データの累乗変換 
 pt1 =パワートランスフォーマー()  
 pt1.fit(X_train)  
 X_train = pt1.transform (X_train)  
 X_test = pt1.transform (X_test)  
 # べき乗変換出力データ 
 pt2 =パワートランスフォーマー()  
 pt2.fit(y_train)  
 y_train = pt2.transform (y_train)  
 y_test = pt2.transform (y_test)

その後、データはモデルに適合するために使用されます。

その後、モデルによる予測とテストセット内の予想されるターゲット値に基づいて変換を反転し、以前と同じように正しいスケールで MAE を計算できます。

 # ターゲット変数の逆変換 
 y_test = pt2.inverse_transform (y_test)  
 yhat = pt2.inverse_transform (yhat)

これらすべてをまとめると、変換されたデータを使用して MLP を適合および評価し、モデルの学習曲線を作成する完全な例が以下になります。

 # データ変換を使用して MLP モデルを適合させ、学習曲線を確認します 
 pandasからread_csvをインポートする 
 sklearn.model_selection から train_test_split をインポートします 
 sklearn.metricsからmean_absolute_errorをインポートします
sklearn.preprocessing から PowerTransformer をインポートします 
 tensorflow.kerasからSequentialをインポートする 
 tensorflow.keras.layers から Dense をインポートします 
 matplotlibからpyplotをインポートする 
 # データセットをロードする 
パス= 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'    
 df = read_csv (パス、ヘッダー=なし)  
 # 入力列と出力列に分割 
 X, y = df .values[:, :-1], df .values[:, -1]  
 # トレーニングデータセットとテストデータセットに分割 
 X_train、X_test、y_train、 y_test = train_test_split (X、y、 test_size = 0.33 )  
 # ターゲット変数が2次元配列であることを確認する 
 y_train、 y_test = y_train.reshape ((len(y_train),1)), y_test.reshape((len(y_test),1))  
 # 入力データの累乗変換
pt1 =パワートランスフォーマー()  
 pt1.fit(X_train)  
 X_train = pt1.transform (X_train)  
 X_test = pt1.transform (X_test)  
 # べき乗変換出力データ 
 pt2 =パワートランスフォーマー()  
 pt2.fit(y_train)  
 y_train = pt2.transform (y_train)  
 y_test = pt2.transform (y_test)  
 # 入力特徴の数を決定する 
 n_features = X .shape[1]  
 # モデルを定義する 
モデル=シーケンシャル()  
 model.add(Dense(10, activation = 'relu' , kernel_initializer = 'he_normal' , input_shape =(n_features,)))  
 model.add(Dense(8, activation = 'relu' , kernel_initializer = 'he_normal' ))  
モデルを追加します(密(1))  
 # モデルをコンパイルする 
 model.compile(オプティマイザー= 'adam' 、損失= 'mse' )  
 # モデルに適合する 
 history = model .fit(X_train, y_train,エポック= 200 、 batch_size = 8 、 verbose = 0 、 validation_data =(X_test,y_test))  
 # テストセットを予測する 
 yhat =モデル.予測(X_test)  
 # ターゲット変数の逆変換 
 y_test = pt2.inverse_transform (y_test)  
 yhat = pt2.inverse_transform (yhat)  
 # 予測を評価する 
スコア=平均絶対誤差(y_test,yhat)
 print('MAE: %.3f' % スコア)  
 # 学習曲線をプロットする 
 pyplot.title('学習曲線')  
 pyplot.xlabel('エポック')  
 pyplot.ylabel('平均二乗誤差')  
 pyplot.plot(history.history['loss'],ラベル= 'train' )  
 pyplot.plot(history.history['val_loss'],ラベル= 'val' )  
 pyplot.凡例()  
 pyplot.show()

例を実行すると、まずトレーニングデータセットにモデルを適合させ、次にテストデータセットの MAE を報告します。

この場合、モデルは、以前に報告されたパフォーマンスよりも劣るものの、妥当な MAE スコアを達成できます。今のところモデルのパフォーマンスは無視します。

前: 34.320

学習曲線の折れ線グラフが作成され、モデルが適切な適合を達成し、収束するのに十分な時間があったことが示されました。

データ変換ありとなしの単純な MLP モデルの学習ダイナミクスについてある程度理解できたので、次はモデルのパフォーマンスを評価し、モデルの構成を調整する方法を検討します。

MLPモデルの評価と調整

k 分割クロス検証手順は、非常に遅くなる可能性があるものの、MLP パフォーマンスのより信頼性の高い推定値を提供できます。これは、k 個のモデルを適合して評価する必要があるためです。自動車保険データセットなど、データセットのサイズが小さい場合には、これは問題になりません。 KFold クラスを使用して分割を作成し、各分割を手動で列挙し、モデルを適合させて評価し、プロセスの最後に評価スコアの平均を報告できます。

 # クロス検証を準備する 
 kfold = Kフォールド(10)  
 # 分割を列挙する 
スコア=リスト()  
 kfold.split(X, y) の train_ix、test_ix の場合:  
 # モデルを適合して評価します...  
 ...  
 ...  
 # すべてのスコアを要約する 
 print('平均MAE: %.3f (%.3f)' % (平均(スコア), 標準偏差(スコア)))

このフレームワークを使用すると、さまざまなデータ準備、モデルアーキテクチャ、学習構成にわたって MLP モデルのパフォーマンスの信頼性の高い推定値を作成できます。

k 分割交差検証を使用してパフォーマンスを評価する前に、まず前のセクションのデータセットに対するモデルの学習ダイナミクスを理解することが重要です。モデルの調整を直接開始すると、良い結果が得られる可能性がありますが、そうでない場合は、モデルのパフォーマンスが過剰または不足している理由がわからない場合があります。

モデルに再度大きな変更を加える場合は、戻ってモデルが適切に収束していることを確認することをお勧めします。

前のセクションの基本的な MLP モデルを評価するこのフレームワークの完全な例を以下に示します。

 # 自動車保険回帰データセットの基本モデルの k 分割交差検証 
 numpyからの平均をインポート 
 numpyからstdをインポート 
 pandasからread_csvをインポートする 
 sklearn.model_selectionからKFoldをインポートします 
 sklearn.metricsからmean_absolute_errorをインポートします 
 tensorflow.kerasからSequentialをインポートする 
 tensorflow.keras.layers から Dense をインポートします 
 matplotlibからpyplotをインポートする 
 # データセットをロードする 
パス= 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'    
 df = read_csv (パス、ヘッダー=なし)  
 # 入力列と出力列に分割 
 X, y = df .values[:, :-1], df .values[:, -1]  
 # クロス検証を準備する 
 kfold = Kフォールド(10)  
 # 分割を列挙する 
スコア=リスト()  
 kfold.split(X, y) の train_ix、test_ix の場合:  
 # データを分割 
 X_train、X_test、y_train、 y_test = X [train_ix]、X[test_ix]、y[train_ix]、y[test_ix]  
 # 入力特徴の数を決定する 
 n_features = X .shape[1]  
 # モデルを定義する 
モデル=シーケンシャル()
 model.add(Dense(10, activation = 'relu' , kernel_initializer = 'he_normal' , input_shape =(n_features,)))  
 モデルを追加します(密(1))  
 # モデルをコンパイルする 
 model.compile(オプティマイザー= 'adam' 、損失= 'mse' )  
 # モデルに適合する
 model.fit(X_train、y_train、エポック= 100 、バッチサイズ= 8 、詳細= 0 )  
 # テストセットを予測する 
 yhat =モデル.予測(X_test)  
 # 予測を評価する 
スコア=平均絶対誤差(y_test,yhat)  
 print(' > %.3f' % スコア)  
 スコア.append(スコア)  
 # すべてのスコアを要約する 
 print('平均MAE: %.3f (%.3f)' % (平均(スコア), 標準偏差(スコア)))

例を実行すると、評価プロセスの各反復におけるモデルのパフォーマンスと、実行終了時の MAE の平均と標準偏差が報告されます。

この場合、MLP モデルの MAE は約 38.913 であることがわかります。

この結果をベースラインとして使用し、より良いパフォーマンスが達成できるかどうかを確認します。

 > 27.314  
 > 69.577  
 > 20.891  
 > 14.810  
 > 13.412  
 > 69.540  
 > 25.612  
 > 49.508  
 > 35.769  
 > 62.696  
平均MAE: 38.913 (21.056)

まず、元のデータセットでより深いモデルを評価して、ベースラインモデルよりもパフォーマンスが優れているかどうかを確認してみましょう。

 # モデルを定義する 
モデル=シーケンシャル()  
 model.add(Dense(10, activation = 'relu' , kernel_initializer = 'he_normal' , input_shape =(n_features,)))  
 model.add(Dense(8, activation = 'relu' , kernel_initializer = 'he_normal' ))
モデルを追加します(密(1))  
 # モデルをコンパイルする 
 model.compile(オプティマイザー= 'adam' 、損失= 'mse' )  
 # モデルに適合する 
 model.fit(X_train、y_train、エポック= 200 、バッチサイズ= 8 、詳細= 0 )

完全な例は次のとおりです。

 # 自動車保険回帰データセットのより深いモデルの k 分割交差検証 
 numpyからの平均をインポート 
 numpyからstdをインポート 
 pandasからread_csvをインポートする 
 sklearn.model_selectionからKFoldをインポートします 
 sklearn.metricsからmean_absolute_errorをインポートします 
 tensorflow.kerasからSequentialをインポートする 
 tensorflow.keras.layers から Dense をインポートします 
 matplotlibからpyplotをインポートする 
 # データセットをロードする 
パス= 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'    
 df = read_csv (パス、ヘッダー=なし)  
 # 入力列と出力列に分割 
 X, y = df .values[:, :-1], df .values[:, -1]  
 # クロス検証を準備する 
 kfold = Kフォールド(10)  
 # 分割を列挙する 
スコア=リスト()  
 kfold.split(X, y) の train_ix、test_ix の場合:  
 # データを分割 
 X_train、X_test、y_train、 y_test = X [train_ix]、X[test_ix]、y[train_ix]、y[test_ix]  
 # 入力特徴の数を決定する 
 n_features = X .shape[1]  
 # モデルを定義する 
モデル=シーケンシャル()  
 model.add(Dense(10, activation = 'relu' , kernel_initializer = 'he_normal' , input_shape =(n_features,)))  
 model.add(Dense(8, activation = 'relu' , kernel_initializer = 'he_normal' ))  
 モデルを追加します(密(1))
 # モデルをコンパイルする 
 model.compile(オプティマイザー= 'adam' 、損失= 'mse' )  
 # モデルに適合する 
 model.fit(X_train、y_train、エポック= 200 、バッチサイズ= 8 、詳細= 0 )  
 # テストセットを予測する 
 yhat =モデル.予測(X_test)  
 # 予測を評価する
スコア=平均絶対誤差(y_test,yhat)  
 print(' > %.3f' % スコア)  
 スコア.append(スコア)  
 # すべてのスコアを要約する 
 print('平均MAE: %.3f (%.3f)' % (平均(スコア), 標準偏差(スコア)))

実行では、実行終了時の MAE の平均と標準偏差が報告されます。

この場合、MLP モデルは約 35.384 の MAE を取得し、これは約 38.913 の MAE を取得するベースラインモデルよりもわずかに優れていることがわかります。

平均MAE: 35.384 (14.951)

次に、前のセクションと同じモデルで、入力変数とターゲット変数のべき乗変換を試してみましょう。

完全な例を以下に示します。

 # データ変換によるより深いモデルの k 分割交差検証 
 numpyからの平均をインポート 
 numpyからstdをインポート 
 pandasからread_csvをインポートする 
 sklearn.model_selectionからKFoldをインポートします 
 sklearn.metricsからmean_absolute_errorをインポートします 
 sklearn.preprocessing から PowerTransformer をインポートします 
 tensorflow.kerasからSequentialをインポートする 
 tensorflow.keras.layers から Dense をインポートします 
 matplotlibからpyplotをインポートする 
 # データセットをロードする
パス= 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'    
 df = read_csv (パス、ヘッダー=なし)  
 # 入力列と出力列に分割 
 X, y = df .values[:, :-1], df .values[:, -1]  
 # クロス検証を準備する 
 kfold = Kフォールド(10)  
 # 分割を列挙する 
スコア=リスト()  
 kfold.split(X, y) の train_ix、test_ix の場合:  
 # データを分割 
 X_train、X_test、y_train、 y_test = X [train_ix]、X[test_ix]、y[train_ix]、y[test_ix]  
 # ターゲットが2次元配列であることを確認する 
 y_train、 y_test = y_train.reshape ((len(y_train),1)), y_test.reshape((len(y_test),1))  
 # 入力データを準備する 
 pt1 =パワートランスフォーマー()  
 pt1.fit(X_train)  
 X_train = pt1.transform (X_train)  
 X_test = pt1.transform (X_test)  
 # ターゲットを準備する 
 pt2 =パワートランスフォーマー()  
 pt2.fit(y_train)  
 y_train = pt2.transform (y_train)  
 y_test = pt2.transform (y_test)  
 # 入力特徴の数を決定する 
 n_features = X .shape[1]  
 # モデルを定義する 
モデル=シーケンシャル()
 model.add(Dense(10, activation = 'relu' , kernel_initializer = 'he_normal' , input_shape =(n_features,)))  
 model.add(Dense(8, activation = 'relu' , kernel_initializer = 'he_normal' ))  
 モデルを追加します(密(1))  
 # モデルをコンパイルする 
 model.compile(オプティマイザー= 'adam' 、損失= 'mse' )  
 # モデルに適合する 
 model.fit(X_train、y_train、エポック= 200 、バッチサイズ= 8 、詳細= 0 )  
 # テストセットを予測する 
 yhat =モデル.予測(X_test)  
 # 逆変換 
 y_test = pt2.inverse_transform (y_test)  
 yhat = pt2.inverse_transform (yhat)  
 # 予測を評価する 
スコア=平均絶対誤差(y_test,yhat)  
 print(' > %.3f' % スコア)  
 スコア.append(スコア)  
 # すべてのスコアを要約する 
 print('平均MAE: %.3f (%.3f)' % (平均(スコア), 標準偏差(スコア)))

実行では、実行終了時の MAE の平均と標準偏差が報告されます。

この場合、MLP モデルは約 37.371 の MAE を取得していることがわかります。これはベースラインモデルよりは優れていますが、より深いベースラインモデルよりは優れていません。

おそらく、この変化は当初考えていたほど有益ではないかもしれません。

平均MAE: 37.371 (29.326)

もう 1 つの変換は、入力変数とターゲット変数を正規化することです。

これは、各変数の値を範囲[0, 1]にスケーリングすることを意味します。これを実現するには MinMaxScaler を使用できます。例えば：

 # 入力データを準備する 
 pt1 =最小最大スケーラー()  
 pt1.fit(X_train)  
 X_train = pt1.transform (X_train)  
 X_test = pt1.transform (X_test)  
 # ターゲットを準備する 
 pt2 =最小最大スケーラー()  
 pt2.fit(y_train)
 y_train = pt2.transform (y_train)  
 y_test = pt2.transform (y_test)

これらすべてをまとめると、データ正規化を使用してより深い MLP を評価する完全な例が以下にリストされます。

 # 正規化変換によるより深いモデルの k 分割交差検証 
 numpyからの平均をインポート 
 numpyからstdをインポート 
 pandasからread_csvをインポートする 
 sklearn.model_selectionからKFoldをインポートします 
 sklearn.metricsからmean_absolute_errorをインポートします 
 sklearn.preprocessing から MinMaxScaler をインポートします 
 tensorflow.kerasからSequentialをインポートする 
 tensorflow.keras.layers から Dense をインポートします 
 matplotlibからpyplotをインポートする 
 # データセットをロードする 
パス= 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'    
 df = read_csv (パス、ヘッダー=なし)  
 # 入力列と出力列に分割 
 X, y = df .values[:, :-1], df .values[:, -1]  
 # クロス検証を準備する 
 kfold = Kフォールド(10)  
 # 分割を列挙する 
スコア=リスト()  
 kfold.split(X, y) の train_ix、test_ix の場合:  
 # データを分割 
 X_train、X_test、y_train、 y_test = X [train_ix]、X[test_ix]、y[train_ix]、y[test_ix]  
 # ターゲットが2次元配列であることを確認する 
 y_train、 y_test = y_train.reshape ((len(y_train),1)), y_test.reshape((len(y_test),1))  
 # 入力データを準備する 
 pt1 =最小最大スケーラー()  
 pt1.fit(X_train)  
 X_train = pt1.transform (X_train)  
 X_test = pt1.transform (X_test)  
 # ターゲットを準備する 
 pt2 =最小最大スケーラー()  
 pt2.fit(y_train)  
 y_train = pt2.transform (y_train)  
 y_test = pt2.transform (y_test)  
 # 入力特徴の数を決定する 
 n_features = X .shape[1]  
 # モデルを定義する 
モデル=シーケンシャル()  
 model.add(Dense(10, activation = 'relu' , kernel_initializer = 'he_normal' , input_shape =(n_features,)))  
 model.add(Dense(8, activation = 'relu' , kernel_initializer = 'he_normal' ))  
 モデルを追加します(密(1))  
 # モデルをコンパイルする 
 model.compile(オプティマイザー= 'adam' 、損失= 'mse' )  
 # モデルに適合する 
 model.fit(X_train、y_train、エポック= 200 、バッチサイズ= 8 、詳細= 0 )  
 # テストセットを予測する
yhat =モデル.予測(X_test)  
 # 逆変換 
 y_test = pt2.inverse_transform (y_test)  
 yhat = pt2.inverse_transform (yhat)  
 # 予測を評価する 
スコア=平均絶対誤差(y_test,yhat)  
 print(' > %.3f' % スコア)  
 スコア.append(スコア)  
 # すべてのスコアを要約する 
 print('平均MAE: %.3f (%.3f)' % (平均(スコア), 標準偏差(スコア)))

実行では、実行終了時の MAE の平均と標準偏差が報告されます。

この場合、MLP モデルは約 30.388 の MAE を達成していることがわかります。これは、これまで試した他のどの構成よりも優れています。

平均MAE: 30.388 (14.258)

モデルアーキテクチャの代替構成 (ノードまたはレイヤーの増減)、ハイパーパラメータの学習 (バッチの増減)、およびデータ変換を引き続きテストできます。

これを練習として残しておきますので、何が見つかったか教えてください。より良い結果を得ることができますか?

結果を下のコメント欄に投稿してください。どんな結果になるかぜひ見てみたいです。

次に、最終モデルを適合させ、それを使用して予測を行う方法を見てみましょう。

最終モデルと予測の作成

モデル構成を選択したら、利用可能なすべてのデータで最終モデルをトレーニングし、それを使用して新しいデータの予測を行うことができます。この場合、データの正規化を行ったより深いモデルを最終モデルとして使用します。つまり、モデルをファイルに保存する場合は、モデル自体 (予測を行うため)、入力データの変換 (新しい入力データのため)、およびターゲット変数の変換 (新しい予測のため) を保存する必要があります。データセットのトレーニングサブセットではなくデータセット全体に対して、以前と同じようにデータを準備し、モデルを適合させることは可能です。

 # 入力列と出力列に分割 
 X, y = df .values[:, :-1], df .values[:, -1]  
 # ターゲットが2次元配列であることを確認する 
 y y = y.reshape((len(y),1))  
 # 入力データを準備する 
 pt1 =最小最大スケーラー()  
 pt1.フィット(X)  
 X = pt1.変換(X)  
 # ターゲットを準備する 
 pt2 =最小最大スケーラー()  
 pt2.フィット(y)  
 y = pt2.transform (y)  
 # 入力特徴の数を決定する 
 n_features = X .shape[1]  
 # モデルを定義する 
モデル=シーケンシャル()  
 model.add(Dense(10, activation = 'relu' , kernel_initializer = 'he_normal' , input_shape =(n_features,)))  
 model.add(Dense(8, activation = 'relu' , kernel_initializer = 'he_normal' ))  
モデルを追加します(密(1))  
 # モデルをコンパイルする 
 model.compile(オプティマイザー= 'adam' 、損失= 'mse' )

このモデルを使用して、新しいデータに関する予測を行うことができます。まず、このデータセットの単なる変数である新しいデータ行を定義します。

 # 新しいデータの行を定義する 
行= [13]

次に、この新しいデータを変換して、モデルへの入力として使用できるようにします。

 # 入力データを変換する 
 X_new = pt1.transform ([行])

そうすれば予測を立てることができます。

 # 予測する 
 yhat =モデル.予測(X_new)

次に、予測された変換を反転して、正しいスケールで結果を使用したり解釈したりできるようにします。

 # 予測時に変換を反転する 
 yhat = pt2.inverse_transform (yhat)

この場合は予測のみを報告します。

 # レポート予測 
 print('f(%s) = %.3f' % (行、yhat[0]))

要約すると、自動車保険データセットに最終モデルを適合させ、それを使用して新しいデータに対する予測を行う完全な例を次に示します。

 # 最終モデルを適合し、新しいデータに対して予測を行います。  
 pandasからread_csvをインポートする 
 sklearn.model_selectionからKFoldをインポートします 
 sklearn.metricsからmean_absolute_errorをインポートします 
 sklearn.preprocessing から MinMaxScaler をインポートします 
 tensorflow.kerasからSequentialをインポートする 
 tensorflow.keras.layers から Dense をインポートします 
 # データセットをロードする 
パス= 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'    
 df = read_csv (パス、ヘッダー=なし)  
 # 入力列と出力列に分割 
 X, y = df .values[:, :-1], df .values[:, -1]  
 # ターゲットが2次元配列であることを確認する 
 y y = y.reshape((len(y),1))  
 # 入力データを準備する 
 pt1 =最小最大スケーラー()  
 pt1.フィット(X)  
 X = pt1.変換(X)  
 # ターゲットを準備する 
 pt2 =最小最大スケーラー()  
 pt2.フィット(y)  
 y = pt2.transform (y)  
 # 入力特徴の数を決定する 
 n_features = X .shape[1]  
 # モデルを定義する 
モデル=シーケンシャル()  
 model.add(Dense(10, activation = 'relu' , kernel_initializer = 'he_normal' , input_shape =(n_features,)))  
 model.add(Dense(8, activation = 'relu' , kernel_initializer = 'he_normal' ))  
モデルを追加します(密(1))  
 # モデルをコンパイルする 
 model.compile(オプティマイザー= 'adam' 、損失= 'mse' )  
 # モデルに適合する 
 model.fit(X, y,エポック= 200 、バッチサイズ= 8 、詳細= 0 )  
 # 新しいデータの行を定義する 
行= [13]  
 # 入力データを変換する 
 X_new = pt1.transform ([行])  
 # 予測する 
 yhat =モデル.予測(X_new)  
 # 予測時に変換を反転する 
 yhat = pt2.inverse_transform (yhat)  
 # レポート予測 
 print('f(%s) = %.3f' % (行、yhat[0]))