Implémentation de VGG16 à l'aide de Keras créé sans utiliser de modèle entraîné

Lisez cet article sur le lectorat

Ceux qui ont une connaissance de base du réseau de neurones convolutifs (CNN) de Deep Learning et comprennent la signification des mots suivants Exemple) --Pliant

• MaxPooling
• filtre

Qu'est-ce que VGG16

C'est l'une des méthodes de Deep Learning pour analyser les images. Il a été annoncé en 2014 et a des performances élevées afin qu'il puisse toujours être utilisé aujourd'hui. Les modèles formés peuvent également être appelés à partir de Keras et utilisés.

L'article original est ici.

Les éléments suivants sont importants pour la création de VGG16:

• La taille du filtre utilisé pour le pliage est de 3 x 3 --La mise en commun maximale est effectuée lorsque le pliage est effectué plusieurs fois. --Doublez le nombre de canaux de filtre après Max Pooling.

Environnement d'exploitation

GoogleColaboratory

Exemple de programme

#Installation des bibliothèques requises
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

#Une classe qui prend les données CIFAR10 et les convertit en vecteur
class CIFAR10Dataset():
  def __init__(self):
    self.image_shape = (32, 32, 3)
    self.num_classes = 10

  #Acquérir des données d'entraînement et des données de test.
  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

  #S'il s'agit d'une variable objective, changez-la en vecteur de classe. Les variables explicatives sont standardisées.
  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

#Une fonction qui définit et renvoie un modèle d'apprentissage en profondeur
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

#Classe pour former le modèle
class Trainer():
  #Compilez le modèle et définissez les paramètres d'entraînement dans les propriétés privées.
  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
  
  #Apprentissage réel
  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() #Instanciation de l'ensemble de données CIFAR10 pour récupérer des données
model = network(dataset.image_shape, dataset.num_classes) #Obtenir le modèle

x_train, y_train, x_test, y_test = dataset.get_batch()  #Acquisition de données d'entraînement et de données de test
trainer = Trainer(model, loss="categorical_crossentropy", optimizer="adam") #Instanciation du formateur avec modèle, fonction de perte et algorithme d'optimisation comme arguments
model = trainer.fit(x_train, y_train, x_test, y_test) #Apprentissage de modèle

#Évaluation du modèle
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss: ', score[0])
print('Test accuracy: ', score[1])

Les références

Apprentissage en profondeur intuitif