Cómo construir un cerebro con Keras y unas pocas líneas de código

Contenido Overview Instalación Introducción Formación, evaluación e inferencia Salvar y serializar Utilice el mismo gráfico de capas para definir múltiples modelos Todos los modelos son llamables, al igual que las capas Manipulación de topologías gráficas complejas Modelos con múltiples entradas y salidas Modelo de juguete ResNet Instalación import numpy as np import tensorflow as tf from tensorflow import keras from keras import layers Introducción Las Keras es una forma de crear modelos que sean más flexibles que los La API funcional puede manejar modelos con topología no lineal, capas compartidas e incluso múltiples entradas o salidas. Funcionamiento del fuego keras.Sequential La idea principal es que un modelo de aprendizaje profundo suele ser un gráfico acíclico dirigido (DAG) de capas. . Gráficos de Layers Considere el siguiente modelo: [Dense (64 unidades, activación relu)] [Dense (64 unidades, activación relu)] [Dense (10 unidades, activación softmax)] (salida: logits de una distribución de probabilidad sobre 10 clases) Este es un gráfico básico con tres capas. Para construir este modelo utilizando la API funcional, comience creando un nodo de entrada: inputs = keras.Input(shape=(784,)) La forma de los datos se establece como un vector de 784 dimensiones.El tamaño del lote siempre se omite ya que sólo se especifica la forma de cada muestra. Si, por ejemplo, tiene una entrada de imagen con una forma de Usted usaría: (32, 32, 3) # Just for demonstration purposes. img_inputs = keras.Input(shape=(32, 32, 3)) El que se devuelve contiene información sobre la forma y de los datos de entrada que alimenta a su modelo. Aquí está la forma: inputs dtype inputs.shape TensorShape([None, 784]) Aquí está el dtype: inputs.dtype tf.float32 Crea un nuevo nodo en el gráfico de capas llamando una capa en este El objeto: inputs dense = layers.Dense(64, activation="relu") x = dense(inputs) La acción "call layer" es como dibujar una flecha de "inputs" a esta capa que ha creado. Lara, y te vas como la producción. dense x Añadiremos algunas capas más al gráfico de capas: x = layers.Dense(64, activation="relu")(x) outputs = layers.Dense(10)(x) En este momento, se puede crear un especificando sus entradas y salidas en el gráfico de capas: Model model = keras.Model(inputs=inputs, outputs=outputs, name="mnist_model") Veamos cómo se ve el resumen del modelo: model.summary() Model: "mnist_model" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) [(None, 784)] 0 dense (Dense) (None, 64) 50240 dense_1 (Dense) (None, 64) 4160 dense_2 (Dense) (None, 10) 650 ================================================================= Total params: 55050 (215.04 KB) Trainable params: 55050 (215.04 KB) Non-trainable params: 0 (0.00 Byte) _________________________________________________________________ También puedes hacer un gráfico con el modelo: keras.utils.plot_model(model, "my_first_model.png") Y, opcionalmente, muestra las formas de entrada y salida de cada capa en el gráfico dibujado: keras.utils.plot_model(model, "my_first_model_with_shape_info.png", show_shapes=True) Esta figura y el código son casi idénticos. En la versión del código, las flechas de conexión son reemplazadas por la operación de llamada. Un "gráfico de capas" es una imagen mental intuitiva para un modelo de aprendizaje profundo, y la API funcional es una manera de crear modelos que reflejen esto de cerca. Formación, evaluación y inferencia El entrenamiento, la evaluación y la inferencia funcionan exactamente de la misma manera para los modelos construidos utilizando la API funcional que para Los modelos. Sequential The La clase ofrece un circuito de entrenamiento integrado (el metodología) y un loop de evaluación integrado (el Tenga en cuenta que puede ser fácilmente para implementar rutinas de capacitación más allá del aprendizaje supervisado (por ejemplo, ) de Model fit() evaluate() Desarrollar estos loop Ganso Aquí, carga los datos de imagen de MNIST, remodelarlo en vectores, ajuste el modelo en los datos (mientras monitorea el rendimiento en una división de validación), luego evalúa el modelo en los datos de prueba: (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() x_train = x_train.reshape(60000, 784).astype("float32") / 255 x_test = x_test.reshape(10000, 784).astype("float32") / 255 model.compile( loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), optimizer=keras.optimizers.RMSprop(), metrics=[keras.metrics.SparseCategoricalAccuracy()], ) history = model.fit(x_train, y_train, batch_size=64, epochs=2, validation_split=0.2) test_scores = model.evaluate(x_test, y_test, verbose=2) print("Test loss:", test_scores[0]) print("Test accuracy:", test_scores[1]) Epoch 1/2 750/750 [==============================] - 4s 3ms/step - loss: 0.3556 - sparse_categorical_accuracy: 0.8971 - val_loss: 0.1962 - val_sparse_categorical_accuracy: 0.9422 Epoch 2/2 750/750 [==============================] - 2s 2ms/step - loss: 0.1612 - sparse_categorical_accuracy: 0.9527 - val_loss: 0.1461 - val_sparse_categorical_accuracy: 0.9592 313/313 - 0s - loss: 0.1492 - sparse_categorical_accuracy: 0.9556 - 463ms/epoch - 1ms/step Test loss: 0.14915992319583893 Test accuracy: 0.9556000232696533 Para más lectura, vea el La guía. Formación y evaluación Salvar y serializar El ahorro del modelo y la serialización funcionan de la misma manera para los modelos construidos utilizando la API funcional como para ellos. La forma estándar de guardar un modelo funcional es llamar Puede recrear el mismo modelo de este archivo más tarde, incluso si el código que construyó el modelo ya no está disponible. Sequential model.save() Este archivo guardado incluye: Modelo arquitectónico Valores de peso modelo (que fueron aprendidos durante el entrenamiento) Model training config, si hay (como pasó a compilar) optimizador y su estado, en su caso (para reiniciar el entrenamiento donde se detuvo) model.save("path_to_my_model.keras") del model # Recreate the exact same model purely from the file: model = keras.models.load_model("path_to_my_model.keras") Para más detalles, lea el modelo La guía. Serialización y ahorro Utilice el mismo gráfico de capas para definir múltiples modelos En la API funcional, los modelos se crean especificando sus entradas y salidas en un gráfico de capas. En el ejemplo siguiente, se utiliza la misma pila de capas para instantizar dos modelos: un modelo que convierte las entradas de imagen en vectores de 16 dimensiones, y un Modelo de entrenamiento. encoder autoencoder encoder_input = keras.Input(shape=(28, 28, 1), name="img") x = layers.Conv2D(16, 3, activation="relu")(encoder_input) x = layers.Conv2D(32, 3, activation="relu")(x) x = layers.MaxPooling2D(3)(x) x = layers.Conv2D(32, 3, activation="relu")(x) x = layers.Conv2D(16, 3, activation="relu")(x) encoder_output = layers.GlobalMaxPooling2D()(x) encoder = keras.Model(encoder_input, encoder_output, name="encoder") encoder.summary() x = layers.Reshape((4, 4, 1))(encoder_output) x = layers.Conv2DTranspose(16, 3, activation="relu")(x) x = layers.Conv2DTranspose(32, 3, activation="relu")(x) x = layers.UpSampling2D(3)(x) x = layers.Conv2DTranspose(16, 3, activation="relu")(x) decoder_output = layers.Conv2DTranspose(1, 3, activation="relu")(x) autoencoder = keras.Model(encoder_input, decoder_output, name="autoencoder") autoencoder.summary() Model: "encoder" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= img (InputLayer) [(None, 28, 28, 1)] 0 conv2d (Conv2D) (None, 26, 26, 16) 160 conv2d_1 (Conv2D) (None, 24, 24, 32) 4640 max_pooling2d (MaxPooling2 (None, 8, 8, 32) 0 D) conv2d_2 (Conv2D) (None, 6, 6, 32) 9248 conv2d_3 (Conv2D) (None, 4, 4, 16) 4624 global_max_pooling2d (Glob (None, 16) 0 alMaxPooling2D) ================================================================= Total params: 18672 (72.94 KB) Trainable params: 18672 (72.94 KB) Non-trainable params: 0 (0.00 Byte) _________________________________________________________________ Model: "autoencoder" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= img (InputLayer) [(None, 28, 28, 1)] 0 conv2d (Conv2D) (None, 26, 26, 16) 160 conv2d_1 (Conv2D) (None, 24, 24, 32) 4640 max_pooling2d (MaxPooling2 (None, 8, 8, 32) 0 D) conv2d_2 (Conv2D) (None, 6, 6, 32) 9248 conv2d_3 (Conv2D) (None, 4, 4, 16) 4624 global_max_pooling2d (Glob (None, 16) 0 alMaxPooling2D) reshape (Reshape) (None, 4, 4, 1) 0 conv2d_transpose (Conv2DTr (None, 6, 6, 16) 160 anspose) conv2d_transpose_1 (Conv2D (None, 8, 8, 32) 4640 Transpose) up_sampling2d (UpSampling2 (None, 24, 24, 32) 0 D) conv2d_transpose_2 (Conv2D (None, 26, 26, 16) 4624 Transpose) conv2d_transpose_3 (Conv2D (None, 28, 28, 1) 145 Transpose) ================================================================= Total params: 28241 (110.32 KB) Trainable params: 28241 (110.32 KB) Non-trainable params: 0 (0.00 Byte) _________________________________________________________________ Aquí, la arquitectura de decodificación es estrictamente simétrica a la arquitectura de codificación, por lo que la forma de salida es la misma que la forma de entrada. . (28, 28, 1) El inverso de A Layer es una A la derecha, y al revés de la Layer es un de Layer. Conv2D Conv2DTranspose MaxPooling2D UpSampling2D Todos los modelos son llamables, al igual que las capas Puedes tratar cualquier modelo como si fuera una capa invocándolo en un Al llamar a un modelo no solo está reutilizando la arquitectura del modelo, también está reutilizando sus pesos. Input Para ver esto en acción, aquí está un ejemplo diferente del autoencoder que crea un modelo de codificador, un modelo de decodificador, y los cadena en dos llamadas para obtener el modelo de autoencodificador: encoder_input = keras.Input(shape=(28, 28, 1), name="original_img") x = layers.Conv2D(16, 3, activation="relu")(encoder_input) x = layers.Conv2D(32, 3, activation="relu")(x) x = layers.MaxPooling2D(3)(x) x = layers.Conv2D(32, 3, activation="relu")(x) x = layers.Conv2D(16, 3, activation="relu")(x) encoder_output = layers.GlobalMaxPooling2D()(x) encoder = keras.Model(encoder_input, encoder_output, name="encoder") encoder.summary() decoder_input = keras.Input(shape=(16,), name="encoded_img") x = layers.Reshape((4, 4, 1))(decoder_input) x = layers.Conv2DTranspose(16, 3, activation="relu")(x) x = layers.Conv2DTranspose(32, 3, activation="relu")(x) x = layers.UpSampling2D(3)(x) x = layers.Conv2DTranspose(16, 3, activation="relu")(x) decoder_output = layers.Conv2DTranspose(1, 3, activation="relu")(x) decoder = keras.Model(decoder_input, decoder_output, name="decoder") decoder.summary() autoencoder_input = keras.Input(shape=(28, 28, 1), name="img") encoded_img = encoder(autoencoder_input) decoded_img = decoder(encoded_img) autoencoder = keras.Model(autoencoder_input, decoded_img, name="autoencoder") autoencoder.summary() Model: "encoder" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= original_img (InputLayer) [(None, 28, 28, 1)] 0 conv2d_4 (Conv2D) (None, 26, 26, 16) 160 conv2d_5 (Conv2D) (None, 24, 24, 32) 4640 max_pooling2d_1 (MaxPoolin (None, 8, 8, 32) 0 g2D) conv2d_6 (Conv2D) (None, 6, 6, 32) 9248 conv2d_7 (Conv2D) (None, 4, 4, 16) 4624 global_max_pooling2d_1 (Gl (None, 16) 0 obalMaxPooling2D) ================================================================= Total params: 18672 (72.94 KB) Trainable params: 18672 (72.94 KB) Non-trainable params: 0 (0.00 Byte) _________________________________________________________________ Model: "decoder" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= encoded_img (InputLayer) [(None, 16)] 0 reshape_1 (Reshape) (None, 4, 4, 1) 0 conv2d_transpose_4 (Conv2D (None, 6, 6, 16) 160 Transpose) conv2d_transpose_5 (Conv2D (None, 8, 8, 32) 4640 Transpose) up_sampling2d_1 (UpSamplin (None, 24, 24, 32) 0 g2D) conv2d_transpose_6 (Conv2D (None, 26, 26, 16) 4624 Transpose) conv2d_transpose_7 (Conv2D (None, 28, 28, 1) 145 Transpose) ================================================================= Total params: 9569 (37.38 KB) Trainable params: 9569 (37.38 KB) Non-trainable params: 0 (0.00 Byte) _________________________________________________________________ Model: "autoencoder" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= img (InputLayer) [(None, 28, 28, 1)] 0 encoder (Functional) (None, 16) 18672 decoder (Functional) (None, 28, 28, 1) 9569 ================================================================= Total params: 28241 (110.32 KB) Trainable params: 28241 (110.32 KB) Non-trainable params: 0 (0.00 Byte) _________________________________________________________________ Como puede ver, el modelo puede ser niñado: un modelo puede contener sub-modelos (puesto que un modelo es como una capa). Por ejemplo, aquí está cómo ensamblar un conjunto de modelos en un único modelo que media sus predicciones: Ensamblaje def get_model(): inputs = keras.Input(shape=(128,)) outputs = layers.Dense(1)(inputs) return keras.Model(inputs, outputs) model1 = get_model() model2 = get_model() model3 = get_model() inputs = keras.Input(shape=(128,)) y1 = model1(inputs) y2 = model2(inputs) y3 = model3(inputs) outputs = layers.average([y1, y2, y3]) ensemble_model = keras.Model(inputs=inputs, outputs=outputs) Manipulación de topologías gráficas complejas Modelos con múltiples entradas y salidas La API funcional hace que sea fácil manipular múltiples entradas y salidas. El fuego. Sequential Por ejemplo, si está construyendo un sistema para clasificar los boletos de emisión de clientes por prioridad y dirigirlos al departamento correcto, entonces el modelo tendrá tres entradas: el título del billete (entrada de texto), el cuerpo de texto del billete (entrada de texto), y cualquier etiqueta añadida por el usuario (entrada categórica) Este modelo tendrá dos salidas: la puntuación de prioridad entre 0 y 1 (salida sigmoide escalar), y el departamento que debe manejar el boleto (output softmax sobre el conjunto de departamentos). Puede construir este modelo en unas pocas líneas con la API funcional: num_tags = 12 # Number of unique issue tags num_words = 10000 # Size of vocabulary obtained when preprocessing text data num_departments = 4 # Number of departments for predictions title_input = keras.Input( shape=(None,), name="title" ) # Variable-length sequence of ints body_input = keras.Input(shape=(None,), name="body") # Variable-length sequence of ints tags_input = keras.Input( shape=(num_tags,), name="tags" ) # Binary vectors of size `num_tags` # Embed each word in the title into a 64-dimensional vector title_features = layers.Embedding(num_words, 64)(title_input) # Embed each word in the text into a 64-dimensional vector body_features = layers.Embedding(num_words, 64)(body_input) # Reduce sequence of embedded words in the title into a single 128-dimensional vector title_features = layers.LSTM(128)(title_features) # Reduce sequence of embedded words in the body into a single 32-dimensional vector body_features = layers.LSTM(32)(body_features) # Merge all available features into a single large vector via concatenation x = layers.concatenate([title_features, body_features, tags_input]) # Stick a logistic regression for priority prediction on top of the features priority_pred = layers.Dense(1, name="priority")(x) # Stick a department classifier on top of the features department_pred = layers.Dense(num_departments, name="department")(x) # Instantiate an end-to-end model predicting both priority and department model = keras.Model( inputs=[title_input, body_input, tags_input], outputs=[priority_pred, department_pred], ) Ahora compone el modelo: keras.utils.plot_model(model, "multi_input_and_output_model.png", show_shapes=True) Cuando compila este modelo, puede asignar diferentes pérdidas a cada salida.También puede asignar diferentes pesos a cada pérdida - para modular su contribución a la pérdida total de entrenamiento. model.compile( optimizer=keras.optimizers.RMSprop(1e-3), loss=[ keras.losses.BinaryCrossentropy(from_logits=True), keras.losses.CategoricalCrossentropy(from_logits=True), ], loss_weights=[1.0, 0.2], ) Dado que las capas de salida tienen diferentes nombres, también puede especificar las pérdidas y los pesos de pérdida con los nombres de capas correspondientes: model.compile( optimizer=keras.optimizers.RMSprop(1e-3), loss={ "priority": keras.losses.BinaryCrossentropy(from_logits=True), "department": keras.losses.CategoricalCrossentropy(from_logits=True), }, loss_weights={"priority": 1.0, "department": 0.2}, ) Entrena el modelo pasando listas de matrizes NumPy de entradas y objetivos: # Dummy input data title_data = np.random.randint(num_words, size=(1280, 10)) body_data = np.random.randint(num_words, size=(1280, 100)) tags_data = np.random.randint(2, size=(1280, num_tags)).astype("float32") # Dummy target data priority_targets = np.random.random(size=(1280, 1)) dept_targets = np.random.randint(2, size=(1280, num_departments)) model.fit( {"title": title_data, "body": body_data, "tags": tags_data}, {"priority": priority_targets, "department": dept_targets}, epochs=2, batch_size=32, ) Epoch 1/2 40/40 [==============================] - 8s 112ms/step - loss: 1.2982 - priority_loss: 0.6991 - department_loss: 2.9958 Epoch 2/2 40/40 [==============================] - 3s 64ms/step - loss: 1.3110 - priority_loss: 0.6977 - department_loss: 3.0666 Cuando se llama a una Objeto, debe producir una tupla de listas como o un tuple de diccionarios como . Dataset ([title_data, body_data, tags_data], [priority_targets, dept_targets]) ({'title': title_data, 'body': body_data, 'tags': tags_data}, {'priority': priority_targets, 'department': dept_targets}) Para una explicación más detallada se refiere al La guía. Formación y evaluación Modelo de juguete ResNet Además de los modelos con múltiples entradas y salidas, la API funcional facilita la manipulación de topologías de conectividad no lineales, modelos con capas que no están conectadas secuencialmente. El fuego no puede manejar. Sequential Un caso común de uso para esto es las conexiones residuales. Vamos a construir un modelo ResNet para CIFAR10 para demostrar esto: inputs = keras.Input(shape=(32, 32, 3), name="img") x = layers.Conv2D(32, 3, activation="relu")(inputs) x = layers.Conv2D(64, 3, activation="relu")(x) block_1_output = layers.MaxPooling2D(3)(x) x = layers.Conv2D(64, 3, activation="relu", padding="same")(block_1_output) x = layers.Conv2D(64, 3, activation="relu", padding="same")(x) block_2_output = layers.add([x, block_1_output]) x = layers.Conv2D(64, 3, activation="relu", padding="same")(block_2_output) x = layers.Conv2D(64, 3, activation="relu", padding="same")(x) block_3_output = layers.add([x, block_2_output]) x = layers.Conv2D(64, 3, activation="relu")(block_3_output) x = layers.GlobalAveragePooling2D()(x) x = layers.Dense(256, activation="relu")(x) x = layers.Dropout(0.5)(x) outputs = layers.Dense(10)(x) model = keras.Model(inputs, outputs, name="toy_resnet") model.summary() Model: "toy_resnet" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== img (InputLayer) [(None, 32, 32, 3)] 0 [] conv2d_8 (Conv2D) (None, 30, 30, 32) 896 ['img[0][0]'] conv2d_9 (Conv2D) (None, 28, 28, 64) 18496 ['conv2d_8[0][0]'] max_pooling2d_2 (MaxPoolin (None, 9, 9, 64) 0 ['conv2d_9[0][0]'] g2D) conv2d_10 (Conv2D) (None, 9, 9, 64) 36928 ['max_pooling2d_2[0][0]'] conv2d_11 (Conv2D) (None, 9, 9, 64) 36928 ['conv2d_10[0][0]'] add (Add) (None, 9, 9, 64) 0 ['conv2d_11[0][0]', 'max_pooling2d_2[0][0]'] conv2d_12 (Conv2D) (None, 9, 9, 64) 36928 ['add[0][0]'] conv2d_13 (Conv2D) (None, 9, 9, 64) 36928 ['conv2d_12[0][0]'] add_1 (Add) (None, 9, 9, 64) 0 ['conv2d_13[0][0]', 'add[0][0]'] conv2d_14 (Conv2D) (None, 7, 7, 64) 36928 ['add_1[0][0]'] global_average_pooling2d ( (None, 64) 0 ['conv2d_14[0][0]'] GlobalAveragePooling2D) dense_6 (Dense) (None, 256) 16640 ['global_average_pooling2d[0][ 0]'] dropout (Dropout) (None, 256) 0 ['dense_6[0][0]'] dense_7 (Dense) (None, 10) 2570 ['dropout[0][0]'] ================================================================================================== Total params: 223242 (872.04 KB) Trainable params: 223242 (872.04 KB) Non-trainable params: 0 (0.00 Byte) __________________________________________________________________________________________________ Descarga el modelo: keras.utils.plot_model(model, "mini_resnet.png", show_shapes=True) Ahora trabaja el modelo: (x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data() x_train = x_train.astype("float32") / 255.0 x_test = x_test.astype("float32") / 255.0 y_train = keras.utils.to_categorical(y_train, 10) y_test = keras.utils.to_categorical(y_test, 10) model.compile( optimizer=keras.optimizers.RMSprop(1e-3), loss=keras.losses.CategoricalCrossentropy(from_logits=True), metrics=["acc"], ) # We restrict the data to the first 1000 samples so as to limit execution time # on Colab. Try to train on the entire dataset until convergence! model.fit(x_train[:1000], y_train[:1000], batch_size=64, epochs=1, validation_split=0.2) 13/13 [==============================] - 4s 39ms/step - loss: 2.3086 - acc: 0.0988 - val_loss: 2.3020 - val_acc: 0.0850 Originalmente publicado en el sitio web de TensorFlow, este artículo aparece aquí bajo un nuevo título y está licenciado bajo CC BY 4.0. Originalmente publicado en la Este artículo aparece aquí bajo un nuevo título y está licenciado bajo CC BY 4.0. TensorFlow TensorFlow