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

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

Recommended Posts

J'ai implémenté ResNet!
J'ai implémenté CycleGAN (1)
Qiskit: j'ai implémenté VQE
J'ai essayé d'implémenter VQE avec Blueqat
J'ai essayé d'implémenter Extreme Learning Machine
[Python] J'ai essayé d'implémenter un échantillonnage de Gibbs marginalisé
J'ai essayé d'implémenter Attention Seq2Seq avec PyTorch
J'ai essayé de mettre en œuvre un réseau de neurones à deux couches
J'ai essayé d'implémenter la régularisation Shake-Shake (ShakeNet) avec PyTorch
[Renforcer l'apprentissage] J'ai implémenté / expliqué R2D3 (Keras-RL)
J'ai essayé le réglage fin de CNN avec Resnet
CheckIO (Python)> Éléments non uniques> J'ai essayé de mettre en œuvre
Implémentation de DQN avec TensorFlow (je voulais ...)
J'ai implémenté DCGAN et essayé de générer des pommes
J'ai essayé d'implémenter la fonction gamma inverse en python
J'ai lu et implémenté les variantes de UKR
J'ai essayé d'implémenter Human In The Loop - Partie ① Tableau de bord -