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

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:

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

Recommended Posts

Implémentation de VGG16 à l'aide de Keras créé sans utiliser de modèle entraîné
Détournement de couches de modèle de keras entraînées
Publication d'un modèle entraîné de fastText
Visualisation bidimensionnelle des vecteurs de documents à l'aide du modèle entraîné Word2Vec
Construire un modèle seq2seq à l'aide de l'inférence API fonctionnelle de Keras
Implémentation d'un réseau de neurones convolutifs utilisant uniquement Numpy
Implémentation de TF-IDF à l'aide de gensim
J'ai fait un modèle VGG16 en utilisant TensorFlow (en chemin)
Un mémorandum d'utilisation de eigen3
Essayez de modifier une nouvelle image à l'aide du modèle StyleGAN2 entraîné
Évaluer les performances d'un modèle de régression simple à l'aide de la validation d'intersection LeaveOneOut
Mise en place d'un filtre à particules simple
Implémentation d'un réseau de neurones à deux couches 2
Implémentation des notifications de bureau à l'aide de Python
Implémentation de Light CNN (Python Keras)
Qiskit: Implémentation de QAOA sans Qiskit Aqua
Créer un modèle d'apprentissage à l'aide de MNIST
Reconnaissance d'image des fruits avec VGG16
Créez un modèle de prédiction de survie pour les passagers du Kaggle Titanic sans utiliser Python
[NNabla] Comment ajouter une couche de quantification à la couche intermédiaire d'un modèle entraîné
Implémenter un modèle avec état et comportement (3) - Exemple d'implémentation par décorateur
Obtenir une combinaison d'éléments à l'aide d'itertools
Un mémorandum sur l'utilisation de la fonction d'entrée de Python
Utiliser un modèle scikit-learn formé à PySpark
Implémentation d'un système de dialogue utilisant Chainer [seq2seq]
Impressions d'utilisation de Flask pendant un mois
Somme des variables dans un modèle mathématique
Obtenir un modèle de référence à l'aide de Django Serializer
Implémentation de réseaux neuronaux "flous" avec Chainer
Ajouter une couche à l'aide du backend Keras
Avantages de l'utilisation de slugfield dans le modèle Django
Implémentation Python du modèle Markov caché continu
Mise en place d'un modèle de prédiction des taux de change (taux dollar-yen) par machine learning