# Tutorial de Keras: ejemplo de aprendizaje profundo con Keras y Python [Keras](https://www.ionos.mx/digitalguide/online-marketing/marketing-para-motores-de-busqueda/que-es-keras/ "¿Qué es Keras?") es una biblioteca de código abierto para crear aplicaciones de aprendizaje profundo. Keras está escrita en Python y ofrece una interfaz uniforme para varios *backends* de aprendizaje profundo, como [TensorFlow](https://www.tensorflow.org/ "TensorFlow") y Theano. El [aprendizaje profundo](https://www.ionos.mx/digitalguide/online-marketing/marketing-para-motores-de-busqueda/deep-learning/ "Deep learning"), o *deep learning*, es una rama del aprendizaje automático y se basa en [redes neuronales artificiales](https://www.ionos.mx/digitalguide/online-marketing/marketing-para-motores-de-busqueda/que-es-una-neural-network/ "¿Qué es una neural network?"). El propósito de Keras es hacer que el *deep learning* nos resulte menos abrumador. En este tutorial de Keras, exploraremos las diferentes funciones de Keras utilizando un simple ejemplo. ## Cómo preparar tu sistema para utilizar Keras La mejor manera de preparar tu sistema para utilizar Keras es instalando el paquete de software [Anaconda](https://www.anaconda.com/ "Anaconda — The World’s Most Popular Data Science Platform")**.** Anaconda es una plataforma libre que se utiliza en la ciencia de datos. Incluye herramientas y bibliotecas útiles y viene con una instalación de Python3 como estándar. ### Cómo instalar Anaconda y Python A continuación, te explicamos e incluimos el código previsto para **usuarios de macOS**. En principio, el código también debería servir para otros sistemas operativos. No obstante, quizás debas realizar algunos ajustes, sobre todo si eres usuario de Windows. Si estás acostumbrado a trabajar con la línea de comandos y tienes el **sistema de gestión de paquetes de *software* libre Homebrew instalado en tu Mac**, puedes utilizarlo para instalar Anaconda. Para ello, abre la línea de comandos (Terminal.App en Mac), copia la siguiente línea de código en el terminal y ejecuta. ```none brew cask install anaconda ``` Si no conoces Homebrew o quieres **instalar Anaconda en Windows o Linux**, puedes descargarte el paquete de instalación adecuado para tu sistema desde la siguiente página: [Anaconda – Individual Edition](https://www.anaconda.com/products/individual "Anaconda – Individual Edition"). ### Prueba de instalación de Anaconda y Python Para asegurarte de haber instalado correctamente Anaconda y Python, ejecuta los siguientes comandos en la línea de comandos: **Para mostrar la versión del gestor de paquetes Conda** ```none conda –version ``` **Para mostrar la versión del intérprete de Python** ```none python --version ``` Si al escribir recibes el mensaje de error “Comando no encontrado”, quizá necesites establecer la ruta a los binarios de Anaconda. Para hacerlo, sigue leyendo. Si la prueba ha funcionado, puedes pasar a la siguiente sección. ### Establecer la ruta a binarios de Anaconda La variable de entorno PATH contiene información sobre **en qué parte del sistema de archivos se encuentran ciertos programas de utilidad.** Las rutas individuales dentro de la variable de entorno se separan con una coma. Puedes incluir más rutas, tal y como te mostramos a continuación para Anaconda en la versión 3: ```none export PATH=/usr/local/anaconda3/bin:"$PATH" ``` Para asegurarte de que la ruta está activa, tienes que almacenar esta línea de código en el sistema. Dependiendo del sistema que tengas y la *shell* que utilices (bash, zsh, etc.), el archivo en el que se hacen los cambios varía. Más abajo, lo ilustramos con un ejemplo para bash en macOS. Ejecuta estás líneas de código en la línea de comando para ajustar la variable de ruta en el archivo “.bash\_profile”: **Variable de ruta para ampliar la instalación Anaconda** ```none echo -n 'export PATH=/usr/local/anaconda3/bin:"$PATH"' >> "$HOME/.bash_profile" ``` **Cargar el archivo “.bash\_profile”** ```none source "$HOME/.bash_profile" ``` --- ### Consejo Utiliza el comando *cat "$HOME/.bash\_profile"* en la línea de comandos para ver el archivo “.bash\_profile” existente. --- A continuación, repite la prueba: **Mostrar versión del administrador de paquetes Conda** ```none conda –version ``` **Mostrar versión del intérprete de Python** ```none python --version ``` Ahora deberías poder ver los números de la versión. Si es así, continúa con los siguientes pasos. ### Actualizar las instalaciones de Anaconda y Python a la última versión Antes de iniciar un nuevo proyecto, **es mejor actualizar las bibliotecas subyacentes**. La plataforma Anaconda viene con el administrador de paquetes Conda. Utiliza los siguientes comandos de Conda para aprovechar las actualizaciones disponibles. **Instalar actualizaciones para el gestor de paquetes Conda** ```none conda update conda ``` **Instalar actualizaciones de Anaconda** ```none conda update anaconda ``` ### Comprobar el número de la versión de los paquetes instalados Keras está escrito en Python y se sustenta en diversos módulos de Python. Ejecuta el siguiente bloque de código en la línea de comandos para mostrar el **número de la versión de los paquetes de *deep learning* de Keras más utilizados**. ```none python << EOF print() # scipy import scipy print('scipy: %s' % scipy.__version__) # numpy import numpy print('numpy: %s' % numpy.__version__) # matplotlib import matplotlib print('matplotlib: %s' % matplotlib.__version__) # pandas import pandas print('pandas: %s' % pandas.__version__) # statsmodels import statsmodels print('statsmodels: %s' % statsmodels.__version__) # scikit-learn import sklearn print('sklearn: %s' % sklearn.__version__) print() EOF ``` ### Instalar Keras en tu sistema Ahora que hemos preparado el sistema, podemos instalar Keras. Para hacerlo, ejecuta las siguientes líneas de código en la línea de comandos: **Instalar TensorFlow** ```none pip install tensorflow ``` **Instalar Keras** ```none pip install keras ``` Igual que antes, es conveniente comprobar la versión de Keras que tienes instalada. Para conocerla, usa esta línea de código: ```none python -c "import keras; print(keras.__version__)" ``` Si hace tiempo que instalaste Keras, no es mala idea **buscar actualizaciones disponibles e instalarlas** si las hay. La siguiente línea de código te las mostrará. Cópiala como siempre y ejecuta el código en la línea de comandos: ```none pip install --upgrade keras ``` ## El deep learning puede ser fácil con Keras: un ejemplo El equipo de Keras publica una [lista con ejemplos de Keras](https://github.com/keras-team/keras/tree/tf-2/examples "Keras/examples at tf-2 keras-team/Keras, GitHub") con una licencia gratuita de GitHub. Examinemos en concreto el [ejemplo “mnist\_cnn.py”](https://github.com/ShawDa/Keras-examples/blob/master/mnist_cnn.py "Keras mnistcnn.py at tf-2 · keras-team/keras · GitHub"). En este caso, el código crea una **red neuronal convolucional (también conocida como CNN o ConvNet)** y la entrena con un *set* de datos de entrenamiento. Para entrenar y testear datos, el ejemplo del *script* de Keras utiliza el *set* de datos MNIST. Se trata de una amplia colección de imágenes pequeñas, cada una de unos 28x28 píxeles. Cada imagen contiene un número escrito a mano. El *set* de datos de MNIST es el estándar del reconocimiento de patrones y Keras lo proporciona. Si quieres saber más, puedes consultar los datos de entrenamiento y *test*. Para ello, copia el bloque de código que mostramos a continuación y ejecútalo en la línea de comandos. Cada vez que lo ejecutes, verás una de las imágenes de entrenamiento. ```none python << EOF # Cargar Keras import keras # Cargar sets de datos de entrenamiento y test MNIST from keras.datasets import mnist # cargar biblioteca para representación gráfica import matplotlib.pyplot as plt # Cargar función para selección aleatoria de imagen from random import randint # Cargar sets de datos (train_images, train_labels), (test_images, test_labels) = mnist.load_data() # Mostrar imagen plt.figure() plt.imshow(train_images[randint(1, len(train_images) - 1)]) plt.grid(False) plt.show() EOF ``` A continuación, entrenaremos la red neuronal para que asigne correctamente los números escritos a mano. **El entrenamiento de la red es computacionalmente demandante** así que no te sorprendas si tu ordenador deje de funcionar correctamente; es normal. Si estás usando un dispositivo móvil, asegúrate de que tiene suficiente batería o conecta el dispositivo a una fuente de alimentación. Primero crearemos una **carpeta de prueba en el escritorio, pasaremos a esa carpeta y montaremos ahí un *script* de Python vacío**. Usa las siguientes líneas de código. Cópialas y ejecútalas en la línea de comandos: **Para crear una carpeta “keras-test” en el escritorio** ```none mkdir "$HOME/Desktop/keras-test/" && cd "$HOME/Desktop/keras-test/" ``` **Para crear un guion vacío de Python** ```none touch keras-test.py ``` Luego, hay que copiar el *script* al archivo “keras-test.py” y guardarlo. Una vez has creado la carpeta de prueba, el siguiente paso es crear el *script* de ejemplo de Keras. Para eso, copia el código que encontrarás al final del artículo y pégalo en un documento de texto vacío. Guarda el documento en la carpeta “keras-test” que acabas de crear en el escritorio dentro del archivo “keras-test.py”. Por último, para ejecutar el *script* de ejemplo de Keras con el intérprete de Python, introduce las líneas de código siguientes en la línea de comandos: ```none cd "$HOME/Desktop/keras-test/" && python keras-test.py ``` Ahora deberías ver información sobre el estado. A continuación, el ***script* empezará a entrenar ConvNet**, mostrando el progreso conforme vas pasando cada *epoch*. Una vez ejecutas el *script*, ConvNet está entrenado y disponible para la clasificación de los números escritos a mano. --- ### Nota Utiliza únicamente un editor de código o un editor de texto plano para guardar el código. No utilices bajo ningún concepto un *software* de procesamiento de texto como Word, OpenOffice o LibreOffice para esto. --- ```none # Guardar código en archivo “keras-test.py” en la carpeta “keras-test” from __future__ import print_function # Cargar Keras import keras # Cargar sets de datos de entrenamiento y test MNIST from keras.datasets import mnist # Cargando modelo secuencial from keras.models import Sequential # Cargar capas de la red neuronal from keras.layers import Dense, Dropout, Flatten from keras.layers import Conv2D, MaxPooling2D from keras import backend as K # Número de diferentes características de datos: dígitos 0–9 num_classes = 10 # Números de pases por entrenar la red neuronal epochs = 12 # Número de archivos usados durante un pase batch_size = 128 # Dimensiones de las pantallas de entrada (28 x 28 píxeles por imagen) img_rows, img_cols = 28, 28 # Cargar datos de entrenamiento y test (train_images, train_labels), (test_images, test_labels) = mnist.load_data() if K.image_data_format() == 'channels_first': train_images = train_images.reshape(train_images.shape[0], 1, img_rows, img_cols) test_images = test_images.reshape(test_images.shape[0], 1, img_rows, img_cols) input_shape = (1, img_rows, img_cols) else: train_images = train_images.reshape(train_images.shape[0], img_rows, img_cols, 1) test_images = test_images.reshape(test_images.shape[0], img_rows, img_cols, 1) input_shape = (img_rows, img_cols, 1) # Establecer tipo de dato de punto flotante train_images = train_images.astype('float32') test_images = test_images.astype('float32') # Normalizar datos de imagen train_images /= 255 test_images /= 255 print('train_images shape:', train_images.shape) print(train_images.shape[0], 'train samples') print(test_images.shape[0], 'test samples') # Convertir vectores de clase en matrices de clase binaria train_labels = keras.utils.to_categorical(train_labels, num_classes) test_labels = keras.utils.to_categorical(test_labels, num_classes) # Crear modelo model = Sequential() # Añadir capas al modelo model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(num_classes, activation='softmax')) # Recopilar capas model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy']) # Entrenar modelo model.fit(train_images, train_labels, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(test_images, test_labels)) # Evaluar modelo score = model.evaluate(test_images, test_labels, verbose=0) print('Test loss:', score[0]) print('Test accuracy:', score[1]) ``` This is a markdown version of: [https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/keras-tutorial/](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/keras-tutorial/) for AI/LLM consumption.