Python: Identification du genre (développement de l'apprentissage profond) Partie 2

CNN Tout d'abord un bref examen

Définition du modèle

La définition du modèle par le modèle séquentiel de Keras est la suivante.

model = Sequential()
model.add(Couche 1)
model.add(Couche 2)
︙

Chaque couche est définie comme dans l'exemple ci-dessous.

#Couche entièrement connectée
Dense(units, input_dim=784)

#Couche pliante
Conv2D(filters = 32, kernel_size=(2, 2), strides=(1, 1), padding="same", input_shape=(28, 28, 3))

#Couche de regroupement
MaxPooling2D(pool_size=(2, 2), strides=None)

#Couche d'aplatissement
Flatten()

model.add(Activation('sigmoid'))

from keras.utils.vis_utils import plot_model
from keras.layers import Activation, Conv2D, Dense, Flatten, MaxPooling2D
from keras.models import Sequential


#---------------------------
model = Sequential()
model.add(Conv2D(input_shape=(32, 32, 3), filters=32, kernel_size=(2, 2), strides=(1, 1), padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(filters=32, kernel_size=(2, 2), strides=(1, 1), padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation('sigmoid'))
model.add(Dense(128))
model.add(Activation('sigmoid'))
model.add(Dense(10))
model.add(Activation('softmax'))
#---------------------------

#
model.summary()

Les chaînes attribuées à l'activation incluent "sigmoid", "relu" et "softmax". Quand j'écris un modèle, ça ressemble à ça. Sortie de la structure du modèle Après avoir défini le modèle opérationnel du modèle, spécifiez comment modifier le taux d'apprentissage, que faire de la fonction de perte, quel indice de précision afficher, etc., et compilez.

model.compile(optimizer='sgd', loss='mean_squared_error', metrics=['accuracy'])

La formation du modèle est effectuée comme suit.

model.fit(X_train, y_train, batch_size=32, epochs=10)

La prédiction à l'aide du modèle se fait comme suit.

pred = np.argmax(model.predict(data[0]))

Cliquez ici pour un exemple de code

import matplotlib.pyplot as plt
import numpy as np
from keras.utils.vis_utils import plot_model
from keras import optimizers
from keras.applications.vgg16 import VGG16
from keras.datasets import cifar10
from keras.layers import Dense, Dropout, Flatten, Input, Conv2D, MaxPooling2D, Activation
from keras.models import Model, Sequential
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = cifar10.load_data()

X_train = X_train[:1000]
X_test = X_test[:1000]
y_train = to_categorical(y_train)[:1000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Conv2D(input_shape=(32, 32, 3), filters=32, kernel_size=(2, 2), strides=(1, 1), padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(filters=32, kernel_size=(2, 2), strides=(1, 1), padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation('sigmoid'))
model.add(Dense(128))
model.add(Activation('sigmoid'))
model.add(Dense(10))
model.add(Activation('softmax'))


#---------------------------
model.compile(optimizer='sgd', loss='categorical_crossentropy',
              metrics=['accuracy'])
model.fit(X_train, y_train, batch_size=100, epochs=1)
#---------------------------


for i in range(1):
    x = X_test[i]
    plt.imshow(x)
    plt.show()
    pred = np.argmax(model.predict(x.reshape(1,32,32,3)))
    print(pred)

Apprentissage par transfert

#Ici, l'apprentissage par transfert est effectué à l'aide de VGG16. Tout d'abord, créez une instance du modèle VGG.

from keras.applications.vgg16 import VGG16

input_tensor = Input(shape=(32, 32, 3))
vgg16 = VGG16(include_top=False, weights='imagenet', input_tensor=input_tensor)

Donnez le formulaire d'entrée comme input_tersor.

définir include_top sur false Utiliser uniquement la partie d'extraction de fonctionnalités de VGG Les modèles suivants seront combinés avec le modèle que vous avez créé.

Pour ajouter une autre couche après la partie d'extraction d'entités Définissez à l'avance un modèle différent de VGG (top_model dans ce cas) et combinez-les comme suit.

top_model = Sequential()
top_model.add(Flatten(input_shape=vgg16.output_shape[1:]))
top_model.add(Dense(256, activation='relu'))
top_model.add(Dense(10, activation='softmax'))
#L'entrée est vgg.input,La sortie est, top_modèle avec sortie vgg16
model = Model(inputs=vgg16.input, outputs=top_model(vgg16.output))

Le poids de la partie d'extraction d'entités par vgg16 se réduira lors de sa mise à jour, donc corrigez-le comme suit.

#Jusqu'à la 16ème couche du modèle est un modèle vgg
for layer in model.layers[:15]:
    layer.trainable = False

La compilation et l'apprentissage peuvent être effectués de la même manière, mais lors du réglage fin (réglage fin) L'optimisation doit être effectuée dans SGD.

model.compile(loss='categorical_crossentropy',
              optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
              metrics=['accuracy'])

Cliquez ici pour un exemple de code

import matplotlib.pyplot as plt
import numpy as np
from keras.utils.vis_utils import plot_model
from keras import optimizers
from keras.applications.vgg16 import VGG16
from keras.datasets import cifar10
from keras.layers import Dense, Dropout, Flatten, Input
from keras.models import Model, Sequential
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = cifar10.load_data()

X_train = X_train[:1000]
X_test = X_test[:1000]
y_train = to_categorical(y_train)[:1000]
y_test = to_categorical(y_test)[:1000]

#Créer une instance de vgg16
#---------------------------
input_tensor = Input(shape=(32, 32, 3))
vgg16 = VGG16(include_top=False, weights='imagenet', input_tensor=input_tensor)
#---------------------------

top_model = Sequential()
top_model.add(Flatten(input_shape=vgg16.output_shape[1:]))
top_model.add(Dense(256, activation='relu'))
top_model.add(Dense(10, activation='softmax'))

#Concaténation de modèle
#---------------------------
model = Model(inputs=vgg16.input, outputs=top_model(vgg16.output))
#---------------------------

#Poids fixe de vgg16
#---------------------------
for layer in model.layers[:15]:
    layer.trainable = False
#---------------------------

model.compile(loss='categorical_crossentropy',
              optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
              metrics=['accuracy'])

model.fit(X_train, y_train, batch_size=100, epochs=1)

for i in range(1):
    x = X_test[i]
    plt.imshow(x)
    plt.show()
    pred = np.argmax(model.predict(x.reshape(1,32,32,3)))
    print(pred)

Techniques pour améliorer la précision

Lors de la formation d'un modèle de réseau neuronal Un entraînement (surajustement) qui s'applique uniquement aux données d'entraînement se produit souvent.

Ici, nous utilisons une méthode appelée dropout, dans laquelle les données d'entrée sont supprimées de manière aléatoire (écrasées par 0). Empêche le surajustement.

Les abandons rendent les réseaux neuronaux indépendants de la présence de neurones spécifiques Vous découvrirez des fonctionnalités plus générales (qui ne reposent pas uniquement sur les données d'entraînement).

Les abandons peuvent être utilisés de la même manière que les calques ordinaires.

model.add(Dropout(rate=0.5))

rate est la vitesse à laquelle l'unité d'entrée est abandonnée (écrasée par 0).

De plus, Keras peut vérifier la précision de classification d'un modèle comme suit.

score = model.evaluate(X_test, y_test)

X_test et y_test sont des données d'entrée et des données d'enseignant pour les données d'évaluation.

Cliquez ici pour un exemple de code

import matplotlib.pyplot as plt
import numpy as np
from keras.utils.vis_utils import plot_model
from keras import optimizers
from keras.applications.vgg16 import VGG16
from keras.datasets import cifar10
from keras.layers import Dense, Dropout, Flatten, Input
from keras.models import Model, Sequential
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = cifar10.load_data()

X_train = X_train[:1000]
X_test = X_test[:1000]
y_train = to_categorical(y_train)[:1000]
y_test = to_categorical(y_test)[:1000]

#Créer une instance de vgg16
input_tensor = Input(shape=(32, 32, 3))
vgg16 = VGG16(include_top=False, weights='imagenet', input_tensor=input_tensor)

top_model = Sequential()
top_model.add(Flatten(input_shape=vgg16.output_shape[1:]))
top_model.add(Dense(256, activation='relu'))

#Abandonner
#---------------------------
top_model.add(Dropout(rate=0.5))
#---------------------------

top_model.add(Dense(10, activation='softmax'))

#Concaténation de modèle
model = Model(inputs=vgg16.input, outputs=top_model(vgg16.output))

#Poids fixe de vgg16
for layer in model.layers[:15]:
    layer.trainable = False

model.compile(loss='categorical_crossentropy',
              optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
              metrics=['accuracy'])

model.summary()

#Acquisition du processus d'apprentissage
history = model.fit(X_train, y_train, batch_size=100, epochs=1, validation_data=(X_test, y_test))

Résumé

Implémentons le modèle de classification Cifar 10 de CNN.

import keras
from keras.datasets import cifar10
from keras.layers import Activation, Conv2D, Dense, Dropout, Flatten, MaxPooling2D
from keras.models import Sequential, load_model
from keras.utils.np_utils import to_categorical
import numpy as np
import matplotlib.pyplot as plt

#Chargement des données
(X_train, y_train), (X_test, y_test) = cifar10.load_data()

y_train = to_categorical(y_train)
y_test = to_categorical(y_test)


#Définition du modèle
model = Sequential()
model.add(Conv2D(32, (3, 3), padding='same',
                 input_shape=X_train.shape[1:]))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(10))
model.add(Activation('softmax'))

#compiler
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)

# Let's train the model using RMSprop
model.compile(loss='categorical_crossentropy',
              optimizer=opt,
              metrics=['accuracy'])

model.summary()

#Apprentissage
model.fit(X_train, y_train, batch_size=32, epochs=1)

#Évaluation de l'exactitude
scores = model.evaluate(X_test, y_test, verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])

#Visualisation des données (10 premières feuilles de données de test)
for i in range(10):
    plt.subplot(1, 10, i+1)
    plt.imshow(X_test[i])
plt.show()

#Prédiction (10 premières feuilles de données de test)
pred = np.argmax(model.predict(X_test[0:10]), axis=1)
print(pred)