【深層学習入門】Kerasによる分類ニューラルネットワークの実装

from tensorflow.keras.datasets import mnist

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

print(train_images.shape)
print(train_labels.shape)
print(test_images.shape)
print(test_labels.shape)

## 出力
(60000, 28, 28)
(60000,)
(10000, 28, 28)
(10000,)

.
├── requirements.txt
└── app/
    ├── logs/
    ├── model.py
    ├── params.py
    ├── predict.py
    ├── preprocessing.py
    └── train.py

numpy==12.2.4
pandas==1.4.2
matplotlib==3.5.2
seaborn==0.11.2
scikit-learn==1.1.1
nptyping==2.1.1
tensorflow==2.9.1
# tensorflow-macos==2.9.2  # M1macの場合はこちらを使用する
pydot==1.4.2
graphviz==0.20
rich==12.5.1

from datetime import datetime
from pathlib import Path

LOG_DIR = Path('logs/fit') / datetime.now().strftime("%Y%m%d-%H%M%S")

BACHSIZE = 500
EPOCHS = 50
VALIDATION_SPLIT = 0.2

INPUT_SIZE = 784
HIDDEN1_SIZE = 256
HIDDEN2_SIZE = 128
OUTPUT_SIZE = 10

MODEL_FILE_PATH = 'model.h5'

import tensorflow as tf
from keras.api._v2 import keras
from keras.models import Model
from keras.layers import Input, Dense, Dropout

import params


class DNNModel:
    def __init__(
            self,
            input_size: int = params.INPUT_SIZE,
            hidden1_size: int = params.HIDDEN1_SIZE,
            hidden2_size: int = params.HIDDEN2_SIZE,
            output_size: int = params.OUTPUT_SIZE,
            dropout_rate: float = 0.5) -> None:
        self.input: Input = Input(shape=(input_size,), name='input')
        self.hidden1: Dense = Dense(hidden1_size, activation='relu', name='hidden1')
        self.hidden2: Dense = Dense(hidden2_size, activation='relu', name='hidden2')
        self.dropout: Dropout = Dropout(rate=dropout_rate, name='dropout')
        self.output: Dense = Dense(output_size, activation='softmax', name='output')

    def build(self) -> Model:
        input = self.input
        x = self.hidden1(input)
        x = self.hidden2(x)
        x = self.dropout(x)
        output = self.output(x)
        return Model(inputs=input, outputs=output)
        

from typing import Tuple, Optional, Union

import tensorflow as tf
from keras.api._v2 import keras
from keras.utils import to_categorical
from nptyping import NDArray, Shape, Int, Float


# 型情報
Images = NDArray[Shape['Sample, Width, Height'], Int]
Labels = NDArray[Shape['Sample'], Int]
PImages = NDArray[Shape['Sample, Width_x_Height'], Int]
PLabels = NDArray[Shape['Sample, Class'], Int]


def preprocess_dataset(
        images: Images, 
        labels: Optional[Labels] = None) -> Union[PImages, Tuple[PImages, PLabels]]:
    images: PImages = images.reshape((images.shape[0], -1))
    if labels is None:
        return images
    labels: PLabels = to_categorical(labels)
    return images, labels

import tensorflow as tf
from keras.api._v2 import keras
from keras.models import Model
from keras.datasets import mnist
from keras.callbacks import EarlyStopping, ModelCheckpoint, TensorBoard
from keras.utils import plot_model

import params
from preprocessing import preprocess_dataset
from model import DNNModel


def train():
    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
    train_images, train_labels = preprocess_dataset(images=train_images, labels=train_labels)

    model: Model = DNNModel().build()

    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
        metrics=['acc']
    )
    model.summary()
    plot_model(model, to_file='model.pdf', show_shapes=True)

    callbacks = [
        EarlyStopping(patience=5),
        ModelCheckpoint(filepath=params.MODEL_FILE_PATH, save_best_only=True),
        TensorBoard(log_dir=params.LOG_DIR)
    ]

    model.fit(
        x=train_images,
        y=train_labels,
        batch_size=params.BACHSIZE,
        epochs=params.EPOCHS,
        validation_split=params.VALIDATION_SPLIT,
        callbacks=callbacks)

    
if __name__ == '__main__':
    train()

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from keras.api._v2 import keras
from keras.datasets import mnist
from rich import print

import params
from preprocessing import preprocess_dataset


def predict(images):
    model = keras.models.load_model(params.MODEL_FILE_PATH)
    pred = model.predict(images)
    return np.argmax(pred, axis=1)


if __name__ == '__main__':
    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
    test_images, test_labels = test_images[:10], test_labels[:10]  # 10枚だけ推論をおこなう
    test_images = preprocess_dataset(images=test_images)
    pred = predict(test_images)
    print(f'prediction: {pred}')
    print(f'labels: {test_labels}')
    # 推論した画像を表示する
    for idx, image in enumerate(test_images):
        plt.subplot(1, 10, idx+1)
        plt.imshow(image.reshape((28, 28)), 'gray')
        plt.axis("off")    
    plt.show()

$ python train.py

## 出力
Model: "model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input (InputLayer)          [(None, 784)]             0         
                                                                 
 hidden1 (Dense)             (None, 256)               200960    
                                                                 
 hidden2 (Dense)             (None, 128)               32896     
                                                                 
 dropout (Dropout)           (None, 128)               0         
                                                                 
 output (Dense)              (None, 10)                1290      
                                                                 
=================================================================
Total params: 235,146
Trainable params: 235,146
Non-trainable params: 0
_________________________________________________________________
Epoch 1/50
96/96 [==============================] - 1s 5ms/step - loss: 9.6860 - acc: 0.4858 - val_loss: 0.8857 - val_acc: 0.7192
Epoch 2/50
96/96 [==============================] - 0s 5ms/step - loss: 1.2142 - acc: 0.6090 - val_loss: 0.6163 - val_acc: 0.8107
.
.
.
Epoch 24/50
96/96 [==============================] - 0s 4ms/step - loss: 0.1821 - acc: 0.9410 - val_loss: 0.2341 - val_acc: 0.9592
Epoch 25/50
96/96 [==============================] - 0s 4ms/step - loss: 0.1797 - acc: 0.9416 - val_loss: 0.2252 - val_acc: 0.9586

$ tensorboard --logdir ./logs/fit

## 出力
Serving TensorBoard on localhost; to expose to the network, use a proxy or pass --bind_all
TensorBoard 2.9.1 at http://localhost:6006/ (Press CTRL+C to quit)

$ python predict.py

## 出力
prediction: [7 2 1 0 4 1 4 9 5 9]
labels: [7 2 1 0 4 1 4 9 5 9]