J'ai essayé de créer un modèle en utilisant CNN pour la reconnaissance de caractères manuscrits, mais je ne savais pas comment définir les hyper paramètres pour créer un modèle très précis, j'ai donc recherché les paramètres optimaux en utilisant une recherche de grille. .. Étant donné que je suis un débutant en apprentissage automatique, j'aimerais interroger des experts sur les différentes façons d'améliorer la précision.
Étant donné que le GPU est facile à utiliser gratuitement, nous le mettrons en œuvre à l'aide de Google Colaboratory. Puisque la recherche de grille vérifie la précision des hyper paramètres spécifiés en arrondissant, il est recommandé d'utiliser le GPU car cela nécessite beaucoup de calculs et prend du temps. La recherche aléatoire peut gagner du temps et des avantages, mais cette fois, nous utiliserons la recherche par grille.
Cette fois, nous allons créer un modèle CNN avec 3 couches cachées. Le nombre de couches entièrement connectées est réglé de manière appropriée à 256, 128,64.
L'effet de la profondeur de couche et du nombre de couches entièrement connectées sur la précision doit également être étudié, mais cette fois, il sera ignoré.
Postscript J'ai vérifié la valeur du filtre CNN dans l'article suivant. Hyper Parameter Tuning 2
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.layers import Activation, Conv2D, Dense, Flatten, MaxPooling2D
from keras.utils.np_utils import to_categorical
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import GridSearchCV
import numpy as np
(X_train, y_train), (X_test, y_test) = mnist.load_data()
#Définissez la valeur du pixel sur 0~Normaliser entre 1
X_train = X_train / 255.0
X_test = X_test / 255.0
X_train = X_train.reshape(-1, 28, 28, 1)
X_test = X_test.reshape(-1, 28, 28, 1)
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
Vérifions pour le moment.
print(np.shape(X_train)) # (60000, 28, 28, 1)
print(np.shape(y_train)) # (60000, 10)
print(np.shape(X_test)) # (10000, 28, 28, 1)
print(np.shape(y_test)) # (10000, 10)
def build_model(activation , optimizer):
model = Sequential()
model.add(Conv2D(input_shape=(28, 28, 1), filters=32, kernel_size=(3, 3), strides=(1, 1), padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same'))
model.add(Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(1,1)))
model.add(Flatten())
model.add(Dense(256, activation=activation, input_dim=784))
model.add(Dense(128, activation=activation))
model.add(Dense(64, activation=activation))
model.add(Dense(10, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
return model
Ça prend beaucoup de temps. Pour les hyper paramètres, indiquez ce que vous souhaitez archiver dans le type de liste.
#Préparer des hyper paramètres
activation = ['relu', 'sigmoid']
optimizer = ['adam', 'sgd']
nb_epoch = [10, 20]
batch_size = [64, 128, 256]
#Collecter des hyper paramètres pour la recherche de grille dans un type de dictionnaire
param_grid = dict(activation=activation, optimizer=optimizer,nb_epoch=nb_epoch, batch_size=batch_size)
#Créer un modèle
model = KerasRegressor(build_fn = build_model, verbose=False)
#Effectuer une recherche de grille
grid = GridSearchCV(estimator=model, param_grid=param_grid)
grid_result = grid.fit(X_train, y_train)
print(grid_result.best_params_)
# {'activation': 'relu', 'batch_size': 64, 'nb_epoch': 20, 'optimizer': 'adam'}
Vous pouvez maintenant voir les hyper paramètres optimaux. Enfin, créons un modèle en utilisant cet hyper paramètre et vérifions la précision.
Définissez les hyper-paramètres que vous avez obtenus précédemment, créez un modèle de reconnaissance de caractères manuscrits et vérifiez la précision.
#Créer un modèle
model = build_model(activation='relu', optimizer='adam')
#Apprentissage
history = model.fit(X_train, y_train, epochs=20, batch_size=64)
#Confirmation de l'exactitude
model.evaluate(X_test, y_test) # [0.06611067801713943, 0.9872000217437744]
À partir de ce qui précède, nous avons pu créer un modèle avec une précision d'environ 98,7%.
Je ne mettrai que le code. Spécifiez le nombre de fois à vérifier aléatoirement dans la partie n_iter.
La recherche aléatoire fait gagner du temps, mais ce n'est pas une recherche à tour de rôle, il est donc possible que de meilleurs hyperparamètres existent, il est donc important de bien définir la valeur de n_iter. Ce sera.
from sklearn.model_selection import RandomizedSearchCV
#Préparer des hyper paramètres
activation = ['relu', 'sigmoid']
optimizer = ['adam', 'sgd']
nb_epoch = [10, 20]
batch_size = [64, 128, 256]
#Collecter des hyper paramètres pour la recherche de grille dans un type de dictionnaire
param_grid = dict(activation=activation, optimizer=optimizer,nb_epoch=nb_epoch, batch_size=batch_size)
#Créer un modèle
model = KerasRegressor(build_fn = build_model, verbose=False)
#Lancer une recherche aléatoire
rand = RandomizedSearchCV(estimator=model, param_distributions=param_dict, n_iter=16)
rand_result = rand.fit(X_train, y_train)
Jusqu'à la fin Merci d'avoir lu. J'espère que cela aide quelqu'un à apprendre.