1. Zuallererst

Heute werde ich Ihnen zeigen, wie Sie mit dem CIFAR10-Datensatz eine Genauigkeit von 75% erreichen. Zunächst strebten wir 90% oder mehr an, daher planen wir, die Feinabstimmung auch in Zukunft fortzusetzen.

2. Was Sie tun möchten

Wie in der folgenden Abbildung gezeigt, führen wir alle Inhalte aus, die normalerweise in AI-Projekten erstellt werden.

Dies ist eine Funktion dieser Aufgabe.

Verwenden Sie CIFAR10 als Datensatz. Teilen Sie den Datensatz in (Train, Validation, Test) = (0.8, 0.1, 0.1) und verwenden Sie ihn.
Verwenden Sie den Keras-Generator und die Datenerweiterung.
Verwenden Sie das Transferlernen mit dem trainierten Modell VGG16.
Speichern Sie das fein abgestimmte Trainingsmodell im h5-Format.
Der Argumentationsabschnitt ruft das Modell auf und testet es.
Zeichnen Sie die Testergebnisse mit einer Verwirrungsmatrix auf.
Trennen Sie die Lern- und Inferenzteile in separate Python-Dateien.

3. Lerninhalte übertragen

VGG16 besteht aus fünf Conv-Blöcken und einer endgültigen vollständig verbundenen Schicht. Dieses Mal lassen wir den ersten bis vierten Conv-Block unverändert und lernen die fünfte und letzte vollständig verbundene Ebene.

4. Ausführungsergebnis

4.1. Lernergebnisse (train.py)

Die folgende Abbildung zeigt den Übergang von Genauigkeitsgenauigkeit und Verlust der Verlustfunktion während des Trainings. Das Lernen von bis zu 200 Epochen ergab eine Genauigkeit von 75%. Die Ergebnisse der Zugdaten und der Validaion-Daten sind jedoch getrennt, sodass anscheinend eine Überanpassung auftritt.

4.2. Inferenzergebnis (Inference.py)

Das Ergebnis der Folgerung. Die durchschnittliche Genauigkeit der Testdaten beträgt 74,5%.

test acc: 0.7450000047683716 Das Confusion Matrix-Modul von Scikit Learn wurde zur Verarbeitung der Confusion Matrix verwendet.

Es ist das Inferenzergebnis von 5000 Testdaten. (5000 Stück = 500 Stück * 10 Klassen)

Zeichnen Sie die obige Textverwirrungsmatrix mit Matplotlib.

Außerdem werden die Ergebnisse von Präzision, Rückruf und F1-Punktzahl für jede Klasse angezeigt. (Erläuterungen zu Präzision und Rückruf finden Sie hier.)

5. Code

学習train.py

Programmstruktur

`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