Ich habe versucht, ein Modell mit CNN für die handschriftliche Zeichenerkennung zu erstellen, aber ich wusste nicht, wie ich die Hyperparameter einstellen sollte, um ein hochgenaues Modell zu erstellen. Deshalb habe ich mithilfe einer Rastersuche nach den optimalen Parametern gesucht. .. Da ich ein Anfänger im maschinellen Lernen bin, möchte ich Experten nach verschiedenen Möglichkeiten fragen, um die Genauigkeit zu verbessern.
Da die GPU einfach und kostenlos zu verwenden ist, werden wir sie mit Google Colaboratory implementieren. Da die Rastersuche die Genauigkeit bestimmter Hyperparameter durch Runden überprüft, wird empfohlen, die GPU zu verwenden, da dies viel Berechnung erfordert und Zeit in Anspruch nimmt. Die zufällige Suche kann Zeit und Nutzen sparen, aber diesmal verwenden wir die Rastersuche.
Dieses Mal erstellen wir ein CNN-Modell mit 3 versteckten Ebenen. Die Anzahl der vollständig verbundenen Schichten ist entsprechend auf 256.128,64 eingestellt.
Der Einfluss der Schichttiefe und der Anzahl der vollständig verbundenen Schichten auf die Genauigkeit sollte ebenfalls untersucht werden, diesmal wird er jedoch ignoriert.
Nachtrag Ich habe den Wert des CNN-Filters im folgenden Artikel überprüft. 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()
#Setzen Sie den Pixelwert auf 0~Normalisieren Sie zwischen 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)
Lassen Sie uns vorerst überprüfen.
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
Es benötigt viel Zeit. Geben Sie für Hyperparameter an, was Sie im Listentyp einchecken möchten.
#Bereiten Sie Hyperparameter vor
activation = ['relu', 'sigmoid']
optimizer = ['adam', 'sgd']
nb_epoch = [10, 20]
batch_size = [64, 128, 256]
#Sammeln Sie Hyperparameter für die Rastersuche in einem Wörterbuchtyp
param_grid = dict(activation=activation, optimizer=optimizer,nb_epoch=nb_epoch, batch_size=batch_size)
#Erstellen Sie ein Modell
model = KerasRegressor(build_fn = build_model, verbose=False)
#Führen Sie eine Rastersuche durch
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'}
Jetzt können Sie die optimalen Hyperparameter sehen. Lassen Sie uns abschließend ein Modell mit diesem Hyperparameter erstellen und die Genauigkeit überprüfen.
Stellen Sie die zuvor erhaltenen Hyperparameter ein, erstellen Sie ein handgeschriebenes Zeichenerkennungsmodell und überprüfen Sie die Genauigkeit.
#Modell erstellen
model = build_model(activation='relu', optimizer='adam')
#Lernen
history = model.fit(X_train, y_train, epochs=20, batch_size=64)
#Bestätigung der Richtigkeit
model.evaluate(X_test, y_test) # [0.06611067801713943, 0.9872000217437744]
Aus dem oben Gesagten konnten wir ein Modell mit einer Genauigkeit von ca. 98,7% erstellen.
Ich werde nur den Code setzen. Geben Sie im Teil "n_iter" an, wie oft zufällig überprüft werden soll.
Die zufällige Suche spart Zeit, ist jedoch keine Round-Robin-Suche. Daher gibt es möglicherweise bessere Hyperparameter. Daher ist es wichtig, den Wert von n_iter gut festzulegen. Es wird sein.
from sklearn.model_selection import RandomizedSearchCV
#Bereiten Sie Hyperparameter vor
activation = ['relu', 'sigmoid']
optimizer = ['adam', 'sgd']
nb_epoch = [10, 20]
batch_size = [64, 128, 256]
#Sammeln Sie Hyperparameter für die Rastersuche in einem Wörterbuchtyp
param_grid = dict(activation=activation, optimizer=optimizer,nb_epoch=nb_epoch, batch_size=batch_size)
#Erstellen Sie ein Modell
model = KerasRegressor(build_fn = build_model, verbose=False)
#Führen Sie eine zufällige Suche durch
rand = RandomizedSearchCV(estimator=model, param_distributions=param_dict, n_iter=16)
rand_result = rand.fit(X_train, y_train)
Bis zum Ende Danke fürs Lesen. Ich hoffe, es hilft jemandem beim Lernen.