🧠

ディープラーニング基礎

2023/05/14に公開

Python

[!Important]+ Goals

基本アルゴリズムの概要

基本的な実装方法

チューニング方法

[!info]+ Subject

機械学習プロジェクトに関わる全ての方

DL の実装を始めたい方

[!abstract]+ Curriculum
1.深層学習の実践
2.深層学習チューニング
添削問題

ディープラーニング実践

ディープラーニングの概要

フレームワーク

TensorFlow by Google
- 本講義ではtensorflow.kerasを使用します。
PyTorch by Facebook

基本用語

Epoch : トレーニングデータを使用した回数
ETA : estimated time of arrival、1 Epochあたりトレーニングにかかる時間を予測する。
loss : トレーニングデータに対する損失
accuracy : トレーニングデータに対する精度
val_loss : 検証データに対する損失
val_accuracy : 検証データに対する正解率

Accuracy と val_accuracy の Epoch に応じた推移

import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf
from tensorflow.keras.layers import Dense, Activation, Dropout
from tensorflow.keras.datasets import mnist

tf.random.set_seed(32) #乱数を固定

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = tf.keras.utils.to_categorical(y_train)[:6000]
y_test = tf.keras.utils.to_categorical(y_test)[:1000]

model = tf.keras.Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=['accuracy'])

# epochs数は5を指定
history = model.fit(X_train, y_train, batch_size=500, epochs=5, verbose=1, validation_data=(X_test, y_test))

#acc, val_accのプロット
plt.plot(history.history['accuracy'], label="acc", ls="-", marker="o")
plt.plot(history.history["val_accuracy"], label="val_acc", ls="-", marker="x")
plt.ylabel("accuracy")
plt.xlabel("epoch")
plt.legend(loc="best")
plt.show()

>>> Epoch 1/5
>>> 1/12 [=>............................] - ETA: 0s - loss: 2.6069 - accuracy: 0.0940 
>>> 6/12 [==============>...............] - ETA: 0s - loss: 2.5584 - accuracy: 0.1030 
>>> 12/12 [==============================] - 0s 24ms/step - loss: 2.5531 - accuracy: 0.1067 - val_loss: 2.2820 - val_accuracy: 0.1570 
>>> 
>>> Epoch 2/5
>>> 1/12 [=>............................] - ETA: 0s - loss: 2.5821 - accuracy: 0.0940
>>> 7/12 [================>.............] - ETA: 0s - loss: 2.5061 - accuracy: 0.1097
>>> 12/12 [==============================] - 0s 11ms/step - loss: 2.4921 - accuracy: 0.1135 - val_loss: 2.2371 - val_accuracy: 0.2120
>>> 
>>> Epoch 3/5
>>> 1/12 [=>............................] - ETA: 0s - loss: 2.3880 - accuracy: 0.1360
>>> 5/12 [===========>..................] - ETA: 0s - loss: 2.4374 - accuracy: 0.1336
>>> 10/12 [========================>.....] - ETA: 0s - loss: 2.4399 - accuracy: 0.1282
>>> 12/12 [==============================] - 0s 14ms/step - loss: 2.4374 - accuracy: 0.1278 - val_loss: 2.2023 - val_accuracy: 0.2840
>>> 
>>> Epoch 4/5 1/12 [=>............................] - ETA: 0s - loss: 2.3907 - accuracy: 0.1520
>>> 5/12 [===========>..................] - ETA: 0s - loss: 2.4087 - accuracy: 0.1304
>>> 12/12 [==============================] - ETA: 0s - loss: 2.4008 - accuracy: 0.1392
>>> 12/12 [==============================] - 0s 14ms/step - loss: 2.4008 - accuracy: 0.1392 - val_loss: 2.1724 - val_accuracy: 0.3470
>>> 
>>> Epoch 5/5 1/12 [=>............................] - ETA: 0s - loss: 2.3424 - accuracy: 0.1400
>>> 7/12 [================>.............] - ETA: 0s - loss: 2.3600 - accuracy: 0.1491
>>> 12/12 [==============================] - 0s 11ms/step - loss: 2.3578 - accuracy: 0.1483 - val_loss: 2.1435 - val_accuracy: 0.3870

ディープラーニングとは？

生物の神経系を模倣したアルゴリズム「ニューラルネットワーク（NN、Neural Network）」の利用が主流であり、現在、最も精度の高い機械学習技術です。
ニューロン, ニューラルネットワーク
NN
- DNN(Deep NN), MLP(MultiLayer Perceptron) : NN 4層以上
  - CNN (Convolutional NN) → 画像識別分野など。
  - RNN (Recurrent NN) → 音声、時系列分野など。
注目される理由
- アルゴリズムの発見
- 膨大なデータ収集が可能
- GPUなど計算機の高性能化

ニューロンの計算方法と学習方法

|600

活性化関数 $\varphi
- シグモイド関数とReLu関数
- ソフトマックス関数 : 出力の総和を1にして各出力を確率変換する
推論結果と正解の誤差が最小になるように学習を行う。

手書き数字の分類

分類までの流れ

データ準備
NN構築
学習
精度評価

DNN

one-hot ベクトル、クラスラベル
ノード(ユニット), 層(レイヤー)

Keras+TensorFlow

ディープラーニングのプログラミングをより簡潔かつ直感的にするライブラリ
TensorFlow : 実装部分によく使われます。
- Keras : TensorFlowの中の高レベルAPI、tf.keras
PyTorch : 研究分野でよく使う

データの概要と準備

MNIST : 28 x 28の白黒画像データ。
#tf/keras/data/mnist #mnist

from tensorflow.keras.datasets import mnist

(X_train, y_train), (X_test, y_test) = mnist.load_data()

# 次の一行を変更してください
print(X_train.shape, y_train.shape, X_test.shape, y_test.shape)

モデル作成

#tf/keras/層/活性化 #tf/keras/層/緻密化

dense : 電熱結層
activation : 活性化層

モデル学習

#歴史 #tf/keras/fit

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Activation
from tensorflow.keras.utils import plot_model
from tensorflow.keras.utils import to_categorical
import matplotlib.pyplot as plt

tf.random.set_seed(32)  # 乱数を固定

(X_train, y_train), (X_test, y_test) = mnist.load_data()

# (◯, 28, 28)のデータを(◯, 784)に次元削減します。(簡単のためデータ数を減らします)
shapes = X_train.shape[1] * X_train.shape[2]
X_train = X_train.reshape(X_train.shape[0], shapes)[:6000]
X_test = X_test.reshape(X_test.shape[0], shapes)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
# 入力ユニット数は784, 1つ目の全結合層の出力ユニット数は256
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))

# 2つ目の全結合層の出力ユニット数は128。活性化関数はrelu。
model.add(Dense(128))
model.add(Activation("relu"))

# 3つ目の全結合層（出力層）の出力ユニット数は10
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])
#---------------------------
# ここに書いて下さい
history = model.fit(X_train, y_train, verbose=1, epochs=3)
#---------------------------
#acc, val_accのプロット
plt.plot(history.history["accuracy"], label="accuracy", ls="-", marker="o")
plt.ylabel("accuracy")
plt.xlabel("epoch")
plt.legend(loc="best")
plt.show()

モデル評価

#tf/keras/evaluate

モデルによる分類

#tf/keras/predict

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Activation, Dense
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.utils import to_categorical

tf.random.set_seed(32) #乱数を固定

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])

model.fit(X_train, y_train, verbose=1)

score = model.evaluate(X_test, y_test, verbose=0)
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

# 検証データの最初の10枚を表示します
for i in range(10):
    plt.subplot(1, 10, i+1)
    plt.imshow(X_test[i].reshape((28,28)), "gray")
plt.show()

# X_testの最初の10枚の予測されたラベルを表示しましょう
#---------------------------
# ここに書いて下さい
pred = np.argmax(model.predict(X_test[0:10]), axis=1)
print("予測値 :" + str(pred))

#---------------------------
>>> 1/188 [..............................] - ETA: 0s - loss: 2.3778 - accuracy: 0.0625 
>>> 21/188 [==>...........................] - ETA: 0s - loss: 2.3032 - accuracy: 0.1622 
>>> 46/188 [======>.......................] - ETA: 0s - loss: 2.2571 - accuracy: 0.1984 
>>> 71/188 [==========>...................] - ETA: 0s - loss: 2.2220 - accuracy: 0.2447
>>> 96/188 [==============>...............] - ETA: 0s - loss: 2.1858 - accuracy: 0.3070 
>>> 118/188 [=================>............] - ETA: 0s - loss: 2.1537 - accuracy: 0.3435 143/188 [=====================>........] - ETA: 0s - loss: 2.1214 - accuracy: 0.3800 
>>> 162/188 [========================>.....] - ETA: 0s - loss: 2.0981 - accuracy: 0.4057 
>>> 186/188 [============================>.] - ETA: 0s - loss: 2.0693 - accuracy: 0.4325 
>>> 188/188 [==============================] - 0s 2ms/step - loss: 2.0670 - accuracy: 0.4352
>>> evaluate loss: 1.8662300109863281
>>> evaluate acc: 0.597000002861023
>>> 予測値 :[7 6 1 0 4 1 4 7 1 4]

ディープラーニングチューニング

ハイパーパラメータ

この章のすべてのパラメータのまとめ

import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Activation, Dense, Dropout
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras import optimizers
from tensorflow.keras.utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
# ハイパーパラメータ：活性化関数
model.add(Activation("sigmoid"))
# ハイパーパラメータ：隠れ層の数、隠れ層のユニット数
model.add(Dense(128))
model.add(Activation("sigmoid"))
# ハイパーパラメータ：ドロップアウトする割合（rate）
model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))

# ハイパーパラメータ：学習率（lr）
sgd = optimizers.SGD(lr=0.01)

# ハイパーパラメータ：最適化関数（optimizer）
# ハイパーパラメータ：誤差関数（loss）
model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])

# ハイパーパラメータ：バッチサイズ（batch_size）
# ハイパーパラメータ：エポック数（epochs）
model.fit(X_train, y_train, batch_size=32, epochs=10, verbose=1)

score = model.evaluate(X_test, y_test, verbose=0)
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

ネットワーク構造の設定

レイヤーが多いと学習速度が遅くなる
ユニットが多いと重要でない特徴量を抽出し、科学的な学習が起こりやすい

任意に設定した3つのレイヤーの比較

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Activation, Dense, Dropout
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras import optimizers
from tensorflow.keras.utils import to_categorical

tf.random.set_seed(32) #乱数を固定

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))

def funcA():
    model.add(Dense(128))
    model.add(Activation("sigmoid"))

def funcB():
    model.add(Dense(128))
    model.add(Activation("sigmoid"))
    model.add(Dense(128))
    model.add(Activation("sigmoid"))
    model.add(Dense(128))
    model.add(Activation("sigmoid"))

def funcC():
    model.add(Dense(1568))
    model.add(Activation("sigmoid"))

# A、B、Cのモデルの中から1つを選び、残りの2つはコメントアウトしてください。
#---------------------------
#funcA()
#funcB()
#funcC()
#---------------------------

model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])

model.fit(X_train, y_train, batch_size=32, epochs=3, verbose=1)

score = model.evaluate(X_test, y_test, verbose=0)
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

ドロップアウト

#tf/keras/layers/dropout

ランダムなニューロンを取り除きながら学習を繰り返します。
- これにより、特定のニューロンに依存するのを防ぎ、汎用的な特徴を学習します。
ドロップアウトの位置と比率、両方ともハイパーパラメータです。

ドロップアウトレイヤーを追加してAccuracyとval_accuracyを比較します。

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Activation, Dense, Dropout
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras import optimizers
from tensorflow.keras.utils import to_categorical

tf.random.set_seed(32) #乱数を固定

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))

#- --------------------------
# ここを書いて下さい
model.add(Dropout(rate=0.5))
# ここまで書いて下さい
# ---------------------------
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])

history = model.fit(X_train, y_train, batch_size=32, epochs=5, verbose=1, validation_data=(X_test, y_test))

#acc, val_accのプロット
plt.plot(history.history["accuracy"], label="acc", ls="-", marker="o")
plt.plot(history.history["val_accuracy"], label="val_acc", ls="-", marker="x")
plt.ylabel("accuracy")
plt.xlabel("epoch")
plt.legend(loc="best")
plt.show()

アクティブ化関数

#tf/keras/layers/activation

前結合層は入力を線形変換して出力するが、活性化関数を利用することで非線形性を持たせることができる。
活性化関数で非線形性を付与することで、線形分離不可能なモデルでも適切に学習を進めれば必ず分類できるようになる。

シグモイド関数

\sigma(x) = \frac{1}{1 + e^{-x}}

導関数はNNのweight更新時に使用します。

ReLu

f(x) = \begin{cases} 0 & x \leq 0 \\ x & x > 0 \end{cases}

損失関数

学習時の出力データと教師データの違いを評価
- 正解率を指標にすることも可能だが、個々のデータの詳細な結果までは分からない。
- つまり、個々の出力データと教師データの差を見るためのものが損失関数です。
二乗誤差、クロスエントピー誤差
逆波動法：損失関数の微分計算を効果的に行うための手法。
- 出力データと教師データの差が最小になるように weight を更新する

MSE

#MSE

回帰に適している
最小値付近でゆっくり更新されるため、収束しやすい。

クロスエントロピー誤差

#クロスエントロピーロス

L(y, \hat{y}) = -\sum_{i=1}^n y_i \log(\hat{y}_i) + (1-y_i)\log(1-\hat{y}_i)

分類の評価に特化、主に分類モデルの誤差関数として使われます。
誤差が小さいほど小さい値を持つ

最適化関数

#optimizer

どのように weight を更新するのか
- 学習ルール、エポキシ数、以前の weight の更新量など。
- 誤差関数を各 weight に対して微分した値を元に weight を更新。

学習率

#learning_rate

各層の重みを一度にどの程度変更するかを決めるハイパーパラメータ。
上のグラフから分かるように、適切な値を選ぶ必要がある。

学習率による正解率を比較する ### 学習率による正解率を比較する

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Activation, Dense, Dropout
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras import optimizers
from tensorflow.keras.utils import to_categorical

tf.random.set_seed(32) #乱数を固定

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))


def funcA():
    global lr
    lr = 0.01

def funcB():
    global lr
    lr = 0.1

def funcC():
    global lr
    lr = 1.0

# 3つのうち1つを選び、他の2行をコメントアウトして学習率を決めます。
#---------------------------
#funcA()
#funcB()
#funcC()
#---------------------------

sgd = optimizers.SGD(lr=lr)

model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])

model.fit(X_train, y_train, batch_size=32, epochs=3, verbose=1)

score = model.evaluate(X_test, y_test, verbose=0)
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

ミニバッチ学習

#minibatch

batch size : モデルに一度に入力するデータの数。
モデルは一度に複数のデータが与えられたとき、それぞれ損失関数の値と傾きを計算し、その平均値を基準に一度だけ重みを更新。
メリット
- 偏ったデータの影響を減らす
- 並列計算で計算時間を短縮
短所
- 一部のデータのみに最適化され、局所解から抜け出せない可能性がある。
イレギュラーデータが多ければサイズアップ、少なければダウン。
種類
- オンライン学習 : バッチサイズ1
- バッチ学習 : 全データ数
- ミニバッチ学習 : その間

バッチサイズによる正解率の比較

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Activation, Dense, Dropout
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras import optimizers
from tensorflow.keras.utils import to_categorical

tf.random.set_seed(32) #乱数を固定

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])

def funcA():
    global batch_size
    batch_size = 16

def funcB():
    global batch_size
    batch_size = 32

def funcC():
    global batch_size
    batch_size = 64

# 3つのうち1つを選び、他の2行をコメントアウトしてbatch_sizeを決めてください。
#---------------------------
funcA()
#funcB()
#funcC()
#---------------------------

model.fit(X_train, y_train, batch_size=batch_size, epochs=3, verbose=1)

score = model.evaluate(X_test, y_test, verbose=0)
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

反復学習

#epoch

通常、ディープラーニングは同じ学習データで学習を継続します。
学習回数 : epoch
少なければ低精度、多ければ科学的学習。

エポキシ数による比較

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Activation, Dense, Dropout
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras import optimizers
from tensorflow.keras.utils import to_categorical

tf.random.set_seed(32) #乱数を固定

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:1000]
X_test = X_test.reshape(X_test.shape[0], 784)[:6000]
y_train = to_categorical(y_train)[:1000]
y_test = to_categorical(y_test)[:6000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
# 今回はDropoutを使いません。
#model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])

def funcA():
    global epochs
    epochs = 5

def funcB():
    global epochs
    epochs = 10

def funcC():
    global epochs
    epochs = 50

# 3つのうち1つを選び、他の2行をコメントアウトしてエポック数を決めてください。
#---------------------------
funcA()
funcB()
funcC()
#---------------------------

history = model.fit(X_train, y_train, batch_size=32, epochs=epochs, verbose=1, validation_data=(X_test, y_test))

#acc, val_accのプロット
plt.plot(history.history["accuracy"], label="acc", ls="-", marker="o")
plt.plot(history.history["val_accuracy"], label="val_acc", ls="-", marker="x")
plt.ylabel("accuracy")
plt.xlabel("epoch")
plt.legend(loc="best")
plt.show()

score = model.evaluate(X_test, y_test, verbose=0)
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

まとめ

添削問題

カリフォルニアの住宅価格予測

import numpy as np

import tensorflow as tf

import pandas as pd

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Activation, Dense, Dropout, Input, BatchNormalization

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_squared_error

from sklearn.datasets import fetch_california_housing

import matplotlib.pyplot as plt

  

# 出力結果の固定

tf.random.set_seed(0)

  

%matplotlib inline

  

# sklearnからデータセットを読み込みます

california_housing = fetch_california_housing()

  

X = pd.DataFrame(california_housing.data, columns=california_housing.feature_names)

Y = pd.Series(california_housing.target)

  

# 説明変数のデータから緯度・経度（Latitude・Longitude）のデータを削除します

X=X.drop(columns=['Latitude','Longitude'])

  

# テストデータとトレーニングデータに分割します

X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.25, random_state=42)

  
  

model = Sequential()

model.add(Dense(32, input_dim=6))

model.add(Activation('relu'))

#上にならって、ユニット数128の中間層をmodel.addで追加してください。

model.add(Dense(128))

#上にならって、活性化関数reluをmodel.addで追加してください。

model.add(Activation("relu"))

model.add(Dense(1))

  

# 損失関数にmse、最適化関数にadamを採用

model.compile(loss='mse', optimizer='adam')

  
  

# モデルを学習させます

history = model.fit(X_train, y_train,

                    epochs=30,   # エポック数

                    batch_size=16,  # バッチサイズ

                    verbose=1,

                    validation_data=(X_test, y_test) )

  

# 予測値を出力します

y_pred = model.predict(X_test)# model.predictにX_testのデータを入れて予測値を出力させてください

  

# 二乗誤差を出力します

mse= mean_squared_error(y_test, y_pred)

print("REG RMSE : %.2f" % (mse** 0.5))

  

# epoch毎の予測値の正解データとの誤差を表しています

# バリデーションデータのみ誤差が大きい場合、過学習を起こしています

  

train_loss=history.history['loss']

val_loss=history.history['val_loss']

epochs=len(train_loss)

  

plt.plot(range(epochs), train_loss, marker = '.', label = 'train_loss')

plt.plot(range(epochs), val_loss, marker = '.', label = 'val_loss')

plt.legend(loc = 'best')

plt.grid()

plt.xlabel('epoch')

plt.ylabel('loss')

plt.show()