[PYTHON] Implementierung von VGG16 mit Keras, die ohne Verwendung eines trainierten Modells erstellt wurden

Lesen Sie diesen Artikel über die Leserschaft

Diejenigen, die Grundkenntnisse über das Convolutional Neural Network (CNN) von Deep Learning haben und die Bedeutung der folgenden Wörter verstehen Beispiel) --Falten

• MaxPooling
• Filter

Was ist VGG16?

Dies ist eine der Deep-Learning-Methoden zur Analyse von Bildern. Es wurde 2014 angekündigt und hat eine hohe Leistung, so dass es noch heute verwendet werden kann. Geschulte Modelle können auch von Keras aus aufgerufen und verwendet werden.

Der Originalartikel ist hier.

Folgendes ist beim Erstellen von VGG16 wichtig:

• Die Größe des zum Falten verwendeten Filters beträgt 3 x 3 --Max Pooling wird durchgeführt, wenn das Falten mehrmals durchgeführt wird.
• Verdoppeln Sie die Anzahl der Filterkanäle nach Max Pooling.

Betriebsumgebung

GoogleColaboratory

Beispielprogramm

#Installation der erforderlichen Bibliotheken
import tensorflow.keras as keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import MaxPooling2D
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dense
from tensorflow.keras.datasets import cifar10

#Eine Klasse, die CIFAR10-Daten in einen Vektor konvertiert
class CIFAR10Dataset():
  def __init__(self):
    self.image_shape = (32, 32, 3)
    self.num_classes = 10

  #Erfassen Sie Trainingsdaten und Testdaten.
  def get_batch(self):
    (x_train, y_train), (x_test, y_test) = cifar10.load_data()
    x_train, x_test = [self.change_vec(img_data) for img_data in [x_train, x_test]]
    y_train, y_test = [self.change_vec(img_data, label_data=True) for img_data in [y_train, y_test]]
    return x_train, y_train, x_test, y_test

  #Wenn es sich um eine Zielvariable handelt, ändern Sie sie in einen Klassenvektor. Erklärende Variablen sind standardisiert.
  def change_vec(self, img_data, label=False):
    if label:
      data = keras.utils.to_categorical(img_data, self.num_classes)
    else:
      img_data = img_data.astype("float32")
      img_data /= 255
      shape = (img_data.shape[0],) + self.image_shape
      img_data = img_data.reshape(shape)
    return img_data

#Eine Funktion, die ein Deep-Learning-Modell festlegt und zurückgibt
def network(input_shape, num_classes):
  model = Sequential()
  model.add(Conv2D(32, kernel_size=3, padding="same", input_shape=input_shape, activation="relu"))
  model.add(Conv2D(32, kernel_size=3, padding="same", activation="relu"))
  model.add(MaxPooling2D())
  model.add(Conv2D(64, kernel_size=3, padding="same", activation="relu"))
  model.add(Conv2D(64, kernel_size=3, padding="same",  activation="relu"))
  model.add(MaxPooling2D())
  model.add(Conv2D(128, kernel_size=3, padding="same", activation="relu"))
  model.add(Conv2D(128, kernel_size=3, padding="same",  activation="relu"))
  model.add(Conv2D(128, kernel_size=3, padding="same",  activation="relu"))
  model.add(MaxPooling2D())
  model.add(Flatten())
  model.add(Dense(1024, activation="relu"))
  model.add(Dense(1024, activation="relu"))
  model.add(Dense(num_classes, activation="softmax"))
  print(model.summary())
  return model

#Klasse, um das Modell zu trainieren
class Trainer():
  #Kompilieren Sie das Modell und legen Sie die Einstellungen für das Training in privaten Objekten fest.
  def __init__(self, model, loss, optimizer):
    self._model = model
    self._model.compile(
        loss=loss,
        optimizer=optimizer,
        metrics=["accuracy"]
    )
    self._verbose = 1
    self._batch_size = 128
    self._epochs = 30
  
  #Tatsächliches Lernen
  def fit(self, x_train, y_train, x_test, y_test):
    self._model.fit(
        x_train,
        y_train,
        batch_size=self._batch_size,
        epochs=self._epochs,
        verbose=self._verbose,
        validation_data=(x_test, y_test)
    )
    return self._model

dataset = CIFAR10Dataset() #Instanziierung des CIFAR10-Datensatzes zum Abrufen von Daten
model = network(dataset.image_shape, dataset.num_classes) #Holen Sie sich Modell

x_train, y_train, x_test, y_test = dataset.get_batch()  #Erfassung von Trainingsdaten und Testdaten
trainer = Trainer(model, loss="categorical_crossentropy", optimizer="adam") #Trainer-Instanziierung mit Modell, Verlustfunktion und Optimierungsalgorithmus als Argumenten
model = trainer.fit(x_train, y_train, x_test, y_test) #Modelllernen

#Modellbewertung
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss: ', score[0])
print('Test accuracy: ', score[1])

Verweise

Intuitives tiefes Lernen