1.Tout d'abord

Aujourd'hui, je vais vous montrer comment obtenir une précision de 75% avec l'ensemble de données CIFAR10. Au début, nous visions 90% ou plus, nous prévoyons donc de continuer à peaufiner à l'avenir.

2. Ce que vous voulez faire

Comme le montre la figure ci-dessous, nous exécuterons tout le contenu qui est généralement fait dans les projets IA.

C'est une caractéristique de cette tâche.

Utilisez CIFAR10 comme ensemble de données. Divisez l'ensemble de données en (Train, Validation, Test) = (0.8, 0.1, 0.1) et utilisez-le.
Utilisez le générateur Keras et l'augmentation des données.
Utilisez l'apprentissage par transfert à l'aide du modèle entraîné VGG16.
Enregistrez le modèle d'entraînement affiné au format h5.
La section de raisonnement appelle le modèle et le teste.
Tracez les résultats du test avec une matrice de confusion.
Séparez les parties d'apprentissage et d'inférence dans des fichiers Python distincts.

3. Transférer le contenu d'apprentissage

VGG16 se compose de cinq blocs de convection et d'une dernière couche connectée complète. Cette fois, nous laisserons les premier au quatrième blocs de convection tels quels et apprendrons le cinquième et dernier Full Connected Layer.

4. Résultat de l'exécution

4.1. Résultats d'apprentissage (train.py)

La figure ci-dessous montre la transition entre la précision de précision et la perte de fonction de perte pendant l'entraînement. L'apprentissage de jusqu'à 200 époques a donné 75% de précision. Cependant, les résultats des données Train et des données Validaion sont séparés, il semble donc qu'un surajustement se produit.

4.2. Résultat d'inférence (Inference.py)

Le résultat de l'inférence. La précision moyenne des données de test est de 74,5%.

test acc: 0.7450000047683716 Le module Confusion Matrix de Scikit Learn a été utilisé pour traiter la Confusion Matrix.

C'est le résultat de l'inférence de 5000 données de test. (5000 pièces = 500 pièces * 10 classes)

Tracez la matrice de confusion textuelle ci-dessus avec Matplotlib.

Il vous indique également les résultats de la précision, du rappel et du score F1 pour chaque classe. (Reportez-vous ici pour l'explication de la précision et du rappel.)

5. Code

学習train.py

Structure du programme

`train.py`


##Import

import os
import keras
from keras.preprocessing.image import ImageDataGenerator
from keras import models, layers
from keras.applications import VGG16
from keras import optimizers
import numpy as np
import matplotlib.pyplot as plt
from keras.callbacks import EarlyStopping




#1.plot loss and accuracy
def plot_acc(hist):
    acc = hist.history['acc']
    val_acc = hist.history['val_acc']
    epochs = range(len(acc))
    plt.plot(epochs, acc, 'bo', label='Training acc')
    plt.plot(epochs, val_acc, 'b', label='Validation acc')
    plt.title('Training and Validation accuracy')
    plt.legend()
    pass

def plot_loss(hist):
    loss = hist.history['loss']
    val_loss = hist.history['val_loss']
    epochs = range(len(loss))
    plt.plot(epochs, loss, 'ro', label='Training loss')
    plt.plot(epochs, val_loss, 'r', label='Validation loss')
    plt.title('Training and Validation loss')
    plt.legend()


def main():

    #Initial Setting
    width_x, width_y = 32, 32
    batch_size = 32
    num_of_train_samples = 40000
    num_of_val_samples = 5000
    num_of_test_samples = 5000 #CIFAR100
    epochs = 1000


    # label_class
    classes = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
    nb_classes = len(classes)

    ## 01. Data Input
    # folder information
    base_dir = 'E:\\Dataset\CIFAR10\cifar10_keras_training'
    train_data_dir = os.path.join(base_dir, 'train')
    val_data_dir = os.path.join(base_dir, 'val')
    test_data_dir = os.path.join(base_dir, 'test')

    print(train_data_dir)
    print(val_data_dir)
    print(test_data_dir)

    # Input Data Generation (with Data Augmentation)
    train_datagen = ImageDataGenerator(rescale=1. / 255,
                                       rotation_range=20,
                                       width_shift_range=0.1,
                                       height_shift_range=0.1,
                                       shear_range=0.1,
                                       zoom_range=0.1,
                                       horizontal_flip=True,
                                       fill_mode='nearest')
    val_datagen = ImageDataGenerator(rescale=1. / 255)
    test_datagen = ImageDataGenerator(rescale=1. / 255)

    train_generator = train_datagen.flow_from_directory(
        train_data_dir,
        target_size=(width_x, width_y),
        color_mode='rgb',
        classes=classes,
        class_mode='categorical',
        batch_size=batch_size,
        shuffle=False)

    val_generator = val_datagen.flow_from_directory(
        val_data_dir,
        target_size=(width_x, width_y),
        color_mode='rgb',
        classes=classes,
        class_mode='categorical',
        batch_size=batch_size,
        shuffle=False)

    test_generator = test_datagen.flow_from_directory(
        test_data_dir,
        target_size=(width_x, width_y),
        color_mode='rgb',
        classes=classes,
        class_mode='categorical',
        batch_size=batch_size,
        shuffle=False)

    ##2. CNN Model
    

    conv_base = VGG16(weights='imagenet',
                      include_top=False,
                      input_shape=(width_x, width_y, 3))
    # conv5 block fine tuning only
    conv_base.trainable = True
    set_trainable = False
    for layer in conv_base.layers:
        if layer.name == 'block5_conv1':
            set_trainable = True
        if set_trainable:
            layer.trainable = True
        else:
            layer.trainable = False

    model = models.Sequential()
    model.add(conv_base)
    model.add(layers.Flatten())
    model.add(layers.Dropout(0.5))
    model.add(layers.Dense(512, activation='relu'))
    model.add(layers.Dense(nb_classes, activation='softmax'))
    model.summary()


    model.compile(loss='categorical_crossentropy',
                  optimizer=optimizers.RMSprop(lr=1e-5),
                  metrics=['acc'])
    model.summary()

    ##3. Training
    # early_stopping = EarlyStopping(patience=20)
    history = model.fit_generator(
        train_generator,
        epochs=epochs,
        steps_per_epoch=num_of_train_samples//batch_size,
        validation_data=val_generator,
        validation_steps= num_of_val_samples//batch_size,
        verbose=2)
    # callbacks=[early_stopping]

    ##5. Model Save
    model.save('./Model/CIFAR10_trained03_seq.h5')

    ##4. Accuracy and Loss Plot
    plot_acc(history)
    plt.figure()
    plot_loss(history)
    plt.show()




## Run code

if __name__=='__main__':
    main()

推論Inference.py