Keras - Modelos

Como se aprendió anteriormente, el modelo de Keras representa el modelo de red neuronal real. Keras proporciona dos modos para crear el modelo, API secuencial simple y fácil de usar , así como API funcional más flexible y avanzada . Aprendamos ahora a crear modelos usando API secuenciales y funcionales en este capítulo.

Secuencial

La idea central de Sequential APIes simplemente organizar las capas de Keras en un orden secuencial y, por lo tanto, se llama API secuencial . La mayor parte de la ANN también tiene capas en orden secuencial y los datos fluyen de una capa a otra en el orden dado hasta que finalmente llegan a la capa de salida.

Se puede crear un modelo ANN simplemente llamando Sequential() API como se especifica a continuación -

from keras.models import Sequential 
model = Sequential()

Agregar capas

Para agregar una capa, simplemente cree una capa usando la API de capa de Keras y luego pase la capa a través de la función add () como se especifica a continuación:

from keras.models import Sequential 

model = Sequential() 
input_layer = Dense(32, input_shape=(8,)) model.add(input_layer) 
hidden_layer = Dense(64, activation='relu'); model.add(hidden_layer) 
output_layer = Dense(8) 
model.add(output_layer)

Aquí, hemos creado una capa de entrada, una capa oculta y una capa de salida.

Accede al modelo

Keras proporciona algunos métodos para obtener la información del modelo, como capas, datos de entrada y datos de salida. Son los siguientes:

model.layers - Devuelve todas las capas del modelo como lista.

>>> layers = model.layers 
>>> layers 
[
   <keras.layers.core.Dense object at 0x000002C8C888B8D0>, 
   <keras.layers.core.Dense object at 0x000002C8C888B7B8>
   <keras.layers.core.Dense object at 0x 000002C8C888B898>
]

model.inputs - Devuelve todos los tensores de entrada del modelo como lista.

>>> inputs = model.inputs 
>>> inputs 
[<tf.Tensor 'dense_13_input:0' shape=(?, 8) dtype=float32>]

model.outputs - Devuelve todos los tensores de salida del modelo como lista.

>>> outputs = model.outputs 
>>> outputs 
<tf.Tensor 'dense_15/BiasAdd:0' shape=(?, 8) dtype=float32>]

model.get_weights - Devuelve todos los pesos como matrices NumPy.
model.set_weights(weight_numpy_array) - Establecer los pesos del modelo.

Serializar el modelo

Keras proporciona métodos para serializar el modelo en un objeto y json y volver a cargarlo más tarde. Son los siguientes:

get_config() - I Devuelve el modelo como objeto.

config = model.get_config()

from_config() - Acepta el objeto de configuración del modelo como argumento y crea el modelo en consecuencia.

new_model = Sequential.from_config(config)

to_json() - Devuelve el modelo como un objeto json.

>>> json_string = model.to_json() 
>>> json_string '{"class_name": "Sequential", "config": 
{"name": "sequential_10", "layers": 
[{"class_name": "Dense", "config": 
{"name": "dense_13", "trainable": true, "batch_input_shape": 
[null, 8], "dtype": "float32", "units": 32, "activation": "linear", 
"use_bias": true, "kernel_initializer": 
{"class_name": "Vari anceScaling", "config": 
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}},
"bias_initializer": {"class_name": "Zeros", "conf 
ig": {}}, "kernel_regularizer": null, "bias_regularizer": null, 
"activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, 
{" class_name": "Dense", "config": {"name": "dense_14", "trainable": true, 
"dtype": "float32", "units": 64, "activation": "relu", "use_bias": true, 
"kern el_initializer": {"class_name": "VarianceScaling", "config": 
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, 
"bias_initia lizer": {"class_name": "Zeros", 
"config": {}}, "kernel_regularizer": null, "bias_regularizer": null, 
"activity_regularizer": null, "kernel_constraint" : null, "bias_constraint": null}}, 
{"class_name": "Dense", "config": {"name": "dense_15", "trainable": true, 
"dtype": "float32", "units": 8, "activation": "linear", "use_bias": true, 
"kernel_initializer": {"class_name": "VarianceScaling", "config": 
{"scale": 1.0, "mode": "fan_avg", "distribution": " uniform", "seed": null}}, 
"bias_initializer": {"class_name": "Zeros", "config": {}}, 
"kernel_regularizer": null, "bias_regularizer": null, "activity_r egularizer": 
null, "kernel_constraint": null, "bias_constraint": 
null}}]}, "keras_version": "2.2.5", "backend": "tensorflow"}' 
>>>

model_from_json() - Acepta la representación json del modelo y crea un nuevo modelo.

from keras.models import model_from_json 
new_model = model_from_json(json_string)

to_yaml() - Devuelve el modelo como una cadena yaml.

>>> yaml_string = model.to_yaml() 
>>> yaml_string 'backend: tensorflow\nclass_name: 
Sequential\nconfig:\n layers:\n - class_name: Dense\n config:\n 
activation: linear\n activity_regular izer: null\n batch_input_shape: 
!!python/tuple\n - null\n - 8\n bias_constraint: null\n bias_initializer:\n 
class_name : Zeros\n config: {}\n bias_regularizer: null\n dtype: 
float32\n kernel_constraint: null\n 
kernel_initializer:\n cla ss_name: VarianceScaling\n config:\n 
distribution: uniform\n mode: fan_avg\n 
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense_13\n 
trainable: true\n units: 32\n 
use_bias: true\n - class_name: Dense\n config:\n activation: relu\n activity_regularizer: null\n 
bias_constraint: null\n bias_initializer:\n class_name: Zeros\n 
config : {}\n bias_regularizer: null\n dtype: float32\n 
kernel_constraint: null\n kernel_initializer:\n class_name: VarianceScalin g\n 
config:\n distribution: uniform\n mode: fan_avg\n scale: 1.0\n 
seed: null\n kernel_regularizer: nu ll\n name: dense_14\n trainable: true\n 
units: 64\n use_bias: true\n - class_name: Dense\n config:\n 
activation: linear\n activity_regularizer: null\n 
bias_constraint: null\n bias_initializer:\n 
class_name: Zeros\n config: {}\n bias_regu larizer: null\n 
dtype: float32\n kernel_constraint: null\n 
kernel_initializer:\n class_name: VarianceScaling\n config:\n 
distribution: uniform\n mode: fan_avg\n 
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense _15\n 
trainable: true\n units: 8\n 
use_bias: true\n name: sequential_10\nkeras_version: 2.2.5\n' 
>>>

model_from_yaml() - Acepta la representación yaml del modelo y crea un nuevo modelo.

from keras.models import model_from_yaml 
new_model = model_from_yaml(yaml_string)

Resume el modelo

Comprender el modelo es una fase muy importante para utilizarlo correctamente con fines de entrenamiento y predicción. Keras proporciona un método simple, resumen para obtener la información completa sobre el modelo y sus capas.

Un resumen del modelo creado en la sección anterior es el siguiente:

>>> model.summary() Model: "sequential_10" 
_________________________________________________________________ 
Layer (type) Output Shape Param 
#================================================================ 
dense_13 (Dense) (None, 32) 288 
_________________________________________________________________ 
dense_14 (Dense) (None, 64) 2112 
_________________________________________________________________ 
dense_15 (Dense) (None, 8) 520 
================================================================= 
Total params: 2,920 
Trainable params: 2,920 
Non-trainable params: 0 
_________________________________________________________________ 
>>>

Entrenar y predecir el modelo

El modelo proporciona una función para el proceso de entrenamiento, evaluación y predicción. Son los siguientes:

compile - Configurar el proceso de aprendizaje del modelo
fit - Entrena el modelo usando los datos de entrenamiento
evaluate - Evaluar el modelo utilizando los datos de prueba.
predict - Predecir los resultados de una nueva entrada.

API funcional

La API secuencial se utiliza para crear modelos capa por capa. La API funcional es un enfoque alternativo para crear modelos más complejos. Modelo funcional, puede definir múltiples entradas o salidas que comparten capas. Primero, creamos una instancia para el modelo y nos conectamos a las capas para acceder a la entrada y salida del modelo. Esta sección explica brevemente el modelo funcional.

Crea un modelo

Importe una capa de entrada usando el módulo de abajo -

>>> from keras.layers import Input

Ahora, cree una capa de entrada que especifique la forma de la dimensión de entrada para el modelo utilizando el siguiente código:

>>> data = Input(shape=(2,3))

Defina la capa para la entrada usando el módulo siguiente:

>>> from keras.layers import Dense

Agregue una capa densa para la entrada usando la siguiente línea de código:

>>> layer = Dense(2)(data) 
>>> print(layer) 
Tensor("dense_1/add:0", shape =(?, 2, 2), dtype = float32)

Defina el modelo utilizando el módulo siguiente:

from keras.models import Model

Cree un modelo de manera funcional especificando tanto la capa de entrada como la de salida -

model = Model(inputs = data, outputs = layer)

El código completo para crear un modelo simple se muestra a continuación:

from keras.layers import Input 
from keras.models import Model 
from keras.layers import Dense 

data = Input(shape=(2,3)) 
layer = Dense(2)(data) model = 
Model(inputs=data,outputs=layer) model.summary() 
_________________________________________________________________ 
Layer (type)               Output Shape               Param # 
================================================================= 
input_2 (InputLayer)       (None, 2, 3)               0 
_________________________________________________________________ 
dense_2 (Dense)            (None, 2, 2)               8 
================================================================= 
Total params: 8 
Trainable params: 8 
Non-trainable params: 0 
_________________________________________________________________