Crear la red neural, definir capas, compilar, entrenar, evaluar y predicciones

Curso Profesional de Redes Neuronales con TensorFlow

Contenido del curso

Cómo utilizar TensorFlow 2.0 con Python

Manejo y preprocesamiento de datos para redes neuronales

Optimización de precisión de modelos

Almacenamiento y carga de modelos

Fundamentos de aprendizaje por transferencia

Resultados de entrenamiento

Cursos Empresas Blog Live Conf Eventos Precios

0:0014:35

Crear la red neural, definir capas, compilar, entrenar, evaluar y predicciones

Curso Profesional de Redes Neuronales con TensorFlow

Clase 11 de 28

Clase 11 / 28

Claro, puedo ayudarte a analizar estas gráficas.

### Análisis de las Gráficas de Accuracy y Loss

1. **Gráfica de Accuracy (Izquierda):**

- **Entrenamiento (verde):** La precisión del modelo en el conjunto de entrenamiento aumenta rápidamente y alcanza un nivel muy alto, cercano al 100%.

- **Validación (rojo):** La precisión en el conjunto de validación alcanza un pico alrededor del 75-80%, pero luego parece estabilizarse o incluso mostrar una leve tendencia a la baja en las últimas épocas.

- **Posible sobreajuste (overfitting):** La gran diferencia entre la precisión de entrenamiento y la precisión de validación indica que el modelo podría estar sobreajustando. Está aprendiendo muy bien el conjunto de entrenamiento, pero no generaliza bien en el conjunto de validación.

2. **Gráfica de Loss (Derecha):**

- **Entrenamiento (verde):** La pérdida en el conjunto de entrenamiento disminuye rápidamente y alcanza valores cercanos a cero, lo cual es consistente con el alto valor de precisión en este conjunto.

- **Validación (rojo):** La pérdida en el conjunto de validación también disminuye inicialmente, pero luego empieza a aumentar ligeramente o a estabilizarse, lo que es otro indicio de sobreajuste.

### Conclusiones y Recomendaciones

- **Sobreajuste:** Este comportamiento es típico de un modelo que sobreajusta, especialmente si la diferencia entre el accuracy de entrenamiento y validación es alta y la pérdida en validación aumenta después de algunas épocas.

- **Posibles soluciones:**

- **Regularización:** Puedes intentar técnicas como Dropout, L2 regularization o Batch Normalization para reducir el sobreajuste.

- **Aumentar los datos:** Si es posible, intenta aumentar la cantidad de datos de entrenamiento, lo que podría ayudar a mejorar la generalización.

- **Early Stopping:** Implementa una técnica de parada temprana (early stopping) para detener el entrenamiento cuando la pérdida de validación comienza a aumentar.

Aquí tienes una guía paso a paso sobre cómo crear una red neuronal con TensorFlow y Keras para realizar clasificación de imágenes. Estos pasos incluyen definir las capas, compilar el modelo, entrenarlo, evaluarlo y hacer predicciones.

### 1. Importar las Bibliotecas Necesarias

Primero, importamos TensorFlow y Keras, y configuramos el entorno.


import tensorflow as tf

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D

from tensorflow.keras.datasets import mnist  # Dataset de ejemplo

from tensorflow.keras.utils import to\_categorical

### 2. Preparar los Datos

Usaremos el dataset MNIST de dígitos escritos a mano como ejemplo. Esto incluye cargar y preprocesar los datos.


\# Cargar los datos

(X\_train, y\_train), (X\_test, y\_test) = mnist.load\_data()



\# Normalizar los datos de imágenes (escalado entre 0 y 1)

X\_train, X\_test = X\_train / 255.0, X\_test / 255.0



\# Redimensionar los datos para añadir una dimensión de canal

X\_train = X\_train.reshape(X\_train.shape\[0], 28, 28, 1)

X\_test = X\_test.reshape(X\_test.shape\[0], 28, 28, 1)



\# Convertir las etiquetas en una codificación categórica

y\_train = to\_categorical(y\_train, 10)

y\_test = to\_categorical(y\_test, 10)

### 3. Crear la Red Neuronal y Definir las Capas

Creamos un modelo secuencial con capas de convolución, max pooling y capas densas.


model = Sequential(\[

&#x20;   Conv2D(32, (3, 3), activation='relu', input\_shape=(28, 28, 1)),

&#x20;   MaxPooling2D((2, 2)),

&#x20;   Conv2D(64, (3, 3), activation='relu'),

&#x20;   MaxPooling2D((2, 2)),

&#x20;   Flatten(),

&#x20;   Dense(128, activation='relu'),

&#x20;   Dense(10, activation='softmax')

])

### 4. Compilar el Modelo

Configura el optimizador, la función de pérdida y la métrica de precisión.


model.compile(optimizer='adam',

&#x20;             loss='categorical\_crossentropy',

&#x20;             metrics=\['accuracy'])

### 5. Entrenar el Modelo

Ahora entrenamos el modelo usando el conjunto de datos de entrenamiento y validación.


history = model.fit(X\_train, y\_train, epochs=10, batch\_size=32, validation\_split=0.2)

### 6. Evaluar el Modelo

Evaluamos el modelo en el conjunto de prueba.


test\_loss, test\_accuracy = model.evaluate(X\_test, y\_test)

print(f'Precisión en el conjunto de prueba: {test\_accuracy:.4f}')

### 7. Hacer Predicciones

Finalmente, hacemos predicciones sobre nuevas muestras.


predictions = model.predict(X\_test)

\# Convertir a etiquetas predichas

predicted\_classes = predictions.argmax(axis=1)



\# Ejemplo de predicción en una sola imagen

import numpy as np

image\_index = 0  # Cambia el índice para ver otra imagen

plt.imshow(X\_test\[image\_index].reshape(28, 28), cmap='gray')

plt.title(f'Predicción: {predicted\_classes\[image\_index]}')

plt.show()

### 8. Visualizar el Rendimiento (Opcional)

Puedes visualizar la precisión y pérdida del modelo en cada época.


import matplotlib.pyplot as plt



\# Precisión

plt.plot(history.history\['accuracy'], label='Entrenamiento')

plt.plot(history.history\['val\_accuracy'], label='Validación')

plt.title('Precisión del modelo')

plt.xlabel('Épocas')

plt.ylabel('Precisión')

plt.legend()

plt.show()



\# Pérdida

plt.plot(history.history\['loss'], label='Entrenamiento')

plt.plot(history.history\['val\_loss'], label='Validación')

plt.title('Pérdida del modelo')

plt.xlabel('Épocas')

plt.ylabel('Pérdida')

plt.legend()

plt.show()

Estos pasos cubren todo el flujo de trabajo básico para crear, entrenar, evaluar y hacer predicciones con una red neuronal en TensorFlow y Keras.