[PYTHON] J'ai implémenté ResNet!

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 ResNet

C'est l'une des méthodes CNN et peut ajouter plus de couches que les autres CNN. Par particularité, à la fin du module, les données d'entrée du module sont ajoutées aux données traitées dans le module (connexion par raccourci). Pour plus d'informations, veuillez visiter ici.

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,  count):
  filter_count = 32
  inputs = Input(shape=input_shape)
  x = Conv2D(32, kernel_size=3, padding="same", activation="relu")(inputs)
  x = BatchNormalization()(x)
  for i in range(count):
    shutcut = x　#Récupérez les données d'entrée du module pour la connexion de raccourci.
    x = Conv2D(filter_count, kernel_size=3, padding="same")(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)
    x = Dropout(rate=0.3)(x)
    x = Conv2D(filter_count, kernel_size=3, padding="same")(x)
    x = BatchNormalization()(x)
    x = Concatenate()([x, shutcut]) #Connexion de raccourci
    if i != count - 1:
      x = MaxPooling2D(pool_size=2)(x)
      filter_count = filter_count * 2
  x = Flatten()(x)
  x = BatchNormalization()(x)
  x = Dense(1024, activation="relu")(x)
  x = Dropout(rate=0.3)(x)
  x = BatchNormalization()(x)
  x = Dense(1024, activation="relu")(x)
  x = Dropout(rate=0.3)(x)
  x = BatchNormalization()(x)
  x = Dense(num_classes, activation="softmax")(x)
  model = Model(inputs=inputs, outputs=x)
  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, 4) #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 Pourquoi ResNet affiche de bonnes performances