Keras - Compilación de modelos

Anteriormente, estudiamos los conceptos básicos de cómo crear un modelo utilizando API secuencial y funcional. Este capítulo explica cómo compilar el modelo. La compilación es el paso final para crear un modelo. Una vez realizada la compilación, podemos pasar a la fase de entrenamiento.

Aprendamos algunos conceptos necesarios para comprender mejor el proceso de compilación.

Pérdida

En el aprendizaje automático, LossLa función se utiliza para encontrar errores o desviaciones en el proceso de aprendizaje. Keras requiere la función de pérdida durante el proceso de compilación del modelo.

Keras proporciona bastantes funciones de pérdida en el losses módulo y son los siguientes:

• mean_squared_error
• mean_absolute_error
• mean_absolute_percentage_error
• mean_squared_logarithmic_error
• squared_hinge
• hinge
• categorical_hinge
• logcosh
• huber_loss
• categorical_crossentropy
• sparse_categorical_crossentropy
• binary_crossentropy
• kullback_leibler_divergence
• poisson
• cosine_proximity
• is_categorical_crossentropy

Toda la función de pérdida anterior acepta dos argumentos:

• y_true - etiquetas verdaderas como tensores

• y_pred - predicción con la misma forma que y_true

Importe el módulo de pérdidas antes de usar la función de pérdida como se especifica a continuación:

from keras import losses

Optimizador

En el aprendizaje automático, Optimizationes un proceso importante que optimiza los pesos de entrada comparando la predicción y la función de pérdida. Keras proporciona bastantes optimizadores como módulo, optimizadores y son los siguientes:

SGD - Optimizador de descenso de gradiente estocástico.

keras.optimizers.SGD(learning_rate = 0.01, momentum = 0.0, nesterov = False)

RMSprop - Optimizador RMSProp.

keras.optimizers.RMSprop(learning_rate = 0.001, rho = 0.9)

Adagrad - Optimizador Adagrad.

keras.optimizers.Adagrad(learning_rate = 0.01)

Adadelta - Optimizador Adadelta.

keras.optimizers.Adadelta(learning_rate = 1.0, rho = 0.95)

Adam - Optimizador de Adam.

keras.optimizers.Adam(
   learning_rate = 0.001, beta_1 = 0.9, beta_2 = 0.999, amsgrad = False
)

Adamax - Optimizador Adamax de Adam.

keras.optimizers.Adamax(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

Nadam - Optimizador de Nesterov Adam.

keras.optimizers.Nadam(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

Importe el módulo de optimizadores antes de usar los optimizadores como se especifica a continuación:

from keras import optimizers

Métrica

En el aprendizaje automático, Metricsse utiliza para evaluar el rendimiento de su modelo. Es similar a la función de pérdida, pero no se usa en el proceso de entrenamiento. Keras proporciona bastantes métricas como módulo,metrics y son los siguientes

• accuracy
• binary_accuracy
• categorical_accuracy
• sparse_categorical_accuracy
• top_k_categorical_accuracy
• sparse_top_k_categorical_accuracy
• cosine_proximity
• clone_metric

Similar a la función de pérdida, las métricas también aceptan dos argumentos a continuación:

• y_true - etiquetas verdaderas como tensores

• y_pred - predicción con la misma forma que y_true

Importe el módulo de métricas antes de usar las métricas como se especifica a continuación:

from keras import metrics

Compila el modelo

El modelo de Keras proporciona un método, compile()para compilar el modelo. El argumento y el valor predeterminado de lacompile() el método es el siguiente

compile(
   optimizer, 
   loss = None, 
   metrics = None, 
   loss_weights = None, 
   sample_weight_mode = None, 
   weighted_metrics = None, 
   target_tensors = None
)

Los argumentos importantes son los siguientes:

• función de pérdida
• Optimizer
• metrics

Un código de muestra para compilar el modo es el siguiente:

from keras import losses 
from keras import optimizers 
from keras import metrics 

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

dónde,

• la función de pérdida se establece como mean_squared_error

• el optimizador está configurado como sgd

• las métricas se establecen como metrics.categorical_accuracy

Entrenamiento de modelos

Los modelos son entrenados por matrices NumPy usando fit(). El objetivo principal de esta función de ajuste se utiliza para evaluar su modelo en el entrenamiento. Esto también se puede utilizar para graficar el rendimiento del modelo. Tiene la siguiente sintaxis:

model.fit(X, y, epochs = , batch_size = )

Aquí,

• X, y - Es una tupla para evaluar sus datos.

• epochs - ninguna de las veces que es necesario evaluar el modelo durante el entrenamiento.

• batch_size - instancias de formación.

Tomemos un ejemplo simple de numerosos datos aleatorios para usar este concepto.

Crear datos

Creemos datos aleatorios usando numpy para xey con la ayuda del comando mencionado a continuación:

import numpy as np 

x_train = np.random.random((100,4,8)) 
y_train = np.random.random((100,10))

Ahora, cree datos de validación aleatorios,

x_val = np.random.random((100,4,8)) 
y_val = np.random.random((100,10))

Crear modelo

Creemos un modelo secuencial simple:

from keras.models import Sequential model = Sequential()

Agregar capas

Crear capas para agregar modelo -

from keras.layers import LSTM, Dense 

# add a sequence of vectors of dimension 16 
model.add(LSTM(16, return_sequences = True)) 
model.add(Dense(10, activation = 'softmax'))

compilar modelo

Ahora el modelo está definido. Puede compilar usando el siguiente comando:

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

Aplicar ajuste ()

Ahora aplicamos la función fit () para entrenar nuestros datos -

model.fit(x_train, y_train, batch_size = 32, epochs = 5, validation_data = (x_val, y_val))

Crear una ANN de perceptrón multicapa

Hemos aprendido a crear, compilar y entrenar los modelos de Keras.

Apliquemos nuestro aprendizaje y creemos una RNA basada en MPL simple.

Módulo de conjunto de datos

Antes de crear un modelo, debemos elegir un problema, recopilar los datos necesarios y convertir los datos en una matriz NumPy. Una vez que se recopilan los datos, podemos preparar el modelo y entrenarlo utilizando los datos recopilados. La recopilación de datos es una de las fases más difíciles del aprendizaje automático. Keras proporciona un módulo especial, conjuntos de datos para descargar los datos de aprendizaje automático en línea con fines de capacitación. Obtiene los datos del servidor en línea, procesa los datos y devuelve los datos como conjunto de entrenamiento y prueba. Comprobemos los datos proporcionados por el módulo del conjunto de datos de Keras. Los datos disponibles en el módulo son los siguientes,

• Clasificación de imágenes pequeñas CIFAR10
• Clasificación de imágenes pequeñas CIFAR100
• Clasificación de sentimiento de reseñas de películas de IMDB
• Clasificación de temas de Reuters Newswire
• Base de datos MNIST de dígitos escritos a mano
• Base de datos Fashion-MNIST de artículos de moda
• Conjunto de datos de regresión del precio de la vivienda en Boston

Usemos el MNIST database of handwritten digits(o minst) como nuestra entrada. minst es una colección de 60.000 imágenes en escala de grises de 28x28. Contiene 10 dígitos. También contiene 10,000 imágenes de prueba.

El siguiente código se puede usar para cargar el conjunto de datos:

from keras.datasets import mnist 

(x_train, y_train), (x_test, y_test) = mnist.load_data()

dónde

• Line 1 importaciones minst desde el módulo de conjunto de datos de keras.

• Line 3 llama al load_data función, que obtendrá los datos del servidor en línea y devolverá los datos como 2 tuplas, Primera tupla, (x_train, y_train) representar los datos de entrenamiento con forma, (number_sample, 28, 28) y su etiqueta de dígitos con forma, (number_samples, ). Segunda tupla,(x_test, y_test) representan datos de prueba con la misma forma.

También se pueden obtener otros conjuntos de datos utilizando una API similar y cada API también devuelve datos similares, excepto la forma de los datos. La forma de los datos depende del tipo de datos.

Crea un modelo

Elijamos un perceptrón multicapa simple (MLP) como se representa a continuación e intentemos crear el modelo usando Keras.

Las características principales del modelo son las siguientes:

• La capa de entrada consta de 784 valores (28 x 28 = 784).

• Primera capa oculta, Dense consta de 512 neuronas y función de activación 'relu'.

• Segunda capa oculta, Dropout tiene 0,2 como valor.

• Tercera capa oculta, nuevamente Densa, consta de 512 neuronas y la función de activación 'relu'.

• Cuarta capa oculta, Dropout tiene 0,2 como valor.

• La quinta y última capa consta de 10 neuronas y la función de activación 'softmax'.

• Utilizar categorical_crossentropy como función de pérdida.

• Utilizar RMSprop() como Optimizador.

• Utilizar accuracy como métricas.

• Utilice 128 como tamaño de lote.

• Usa 20 como épocas.

Step 1 − Import the modules

Importamos los módulos necesarios.

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout 
from keras.optimizers import RMSprop 
import numpy as np

Step 2 − Load data

Importemos el conjunto de datos mnist.

(x_train, y_train), (x_test, y_test) = mnist.load_data()

Step 3 − Process the data

Cambiemos el conjunto de datos de acuerdo con nuestro modelo, para que se pueda incorporar a nuestro modelo.

x_train = x_train.reshape(60000, 784) 
x_test = x_test.reshape(10000, 784) 
x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 

y_train = keras.utils.to_categorical(y_train, 10) 
y_test = keras.utils.to_categorical(y_test, 10)

Dónde

• reshape se usa para remodelar la entrada de (28, 28) tupla a (784,)

• to_categorical se utiliza para convertir vector a matriz binaria

Step 4 − Create the model

Creemos el modelo real.

model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu'))
model.add(Dropout(0.2)) 
model.add(Dense(10, activation = 'softmax'))

Step 5 − Compile the model

Compilemos el modelo utilizando la función de pérdida seleccionada, el optimizador y las métricas.

model.compile(loss = 'categorical_crossentropy',     
   optimizer = RMSprop(), 
   metrics = ['accuracy'])

Step 6 − Train the model

Entrenemos el modelo usando fit() método.

history = model.fit(
   x_train, y_train, 
   batch_size = 128, 
   epochs = 20, 
   verbose = 1, 
   validation_data = (x_test, y_test)
)

Pensamientos finales

Hemos creado el modelo, hemos cargado los datos y también hemos entrenado los datos al modelo. Todavía necesitamos evaluar el modelo y predecir la salida para la entrada desconocida, lo que aprenderemos en el próximo capítulo.

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout 
from keras.optimizers import RMSprop 
import numpy as np 

(x_train, y_train), (x_test, y_test) = mnist.load_data() 

x_train = x_train.reshape(60000, 784) 
x_test = x_test.reshape(10000, 784) 
x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 

y_train = keras.utils.to_categorical(y_train, 10) 
y_test = keras.utils.to_categorical(y_test, 10) 

model = Sequential() 
model.add(Dense(512, activation='relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2)) 
model.add(Dense(10, activation = 'softmax'))
model.compile(loss = 'categorical_crossentropy', 
   optimizer = RMSprop(), 
   metrics = ['accuracy']) 

history = model.fit(x_train, y_train, 
   batch_size = 128, epochs = 20, verbose = 1, validation_data = (x_test, y_test))

La ejecución de la aplicación dará como resultado el siguiente contenido:

Train on 60000 samples, validate on 10000 samples Epoch 1/20 
60000/60000 [==============================] - 7s 118us/step - loss: 0.2453 
- acc: 0.9236 - val_loss: 0.1004 - val_acc: 0.9675 Epoch 2/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.1023 
- acc: 0.9693 - val_loss: 0.0797 - val_acc: 0.9761 Epoch 3/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.0744 
- acc: 0.9770 - val_loss: 0.0727 - val_acc: 0.9791 Epoch 4/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.0599 
- acc: 0.9823 - val_loss: 0.0704 - val_acc: 0.9801 Epoch 5/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0504 
- acc: 0.9853 - val_loss: 0.0714 - val_acc: 0.9817 Epoch 6/20 
60000/60000 [==============================] - 7s 111us/step - loss: 0.0438 
- acc: 0.9868 - val_loss: 0.0845 - val_acc: 0.9809 Epoch 7/20 
60000/60000 [==============================] - 7s 114us/step - loss: 0.0391 
- acc: 0.9887 - val_loss: 0.0823 - val_acc: 0.9802 Epoch 8/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0364 
- acc: 0.9892 - val_loss: 0.0818 - val_acc: 0.9830 Epoch 9/20 
60000/60000 [==============================] - 7s 113us/step - loss: 0.0308 
- acc: 0.9905 - val_loss: 0.0833 - val_acc: 0.9829 Epoch 10/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0289 
- acc: 0.9917 - val_loss: 0.0947 - val_acc: 0.9815 Epoch 11/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0279 
- acc: 0.9921 - val_loss: 0.0818 - val_acc: 0.9831 Epoch 12/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0260 
- acc: 0.9927 - val_loss: 0.0945 - val_acc: 0.9819 Epoch 13/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0257 
- acc: 0.9931 - val_loss: 0.0952 - val_acc: 0.9836 Epoch 14/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0229 
- acc: 0.9937 - val_loss: 0.0924 - val_acc: 0.9832 Epoch 15/20 
60000/60000 [==============================] - 7s 115us/step - loss: 0.0235 
- acc: 0.9937 - val_loss: 0.1004 - val_acc: 0.9823 Epoch 16/20 
60000/60000 [==============================] - 7s 113us/step - loss: 0.0214 
- acc: 0.9941 - val_loss: 0.0991 - val_acc: 0.9847 Epoch 17/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0219 
- acc: 0.9943 - val_loss: 0.1044 - val_acc: 0.9837 Epoch 18/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0190 
- acc: 0.9952 - val_loss: 0.1129 - val_acc: 0.9836 Epoch 19/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0197 
- acc: 0.9953 - val_loss: 0.0981 - val_acc: 0.9841 Epoch 20/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0198 
- acc: 0.9950 - val_loss: 0.1215 - val_acc: 0.9828