Mostrar los tags: ini

NÚMERO A PREDECIR.
--------------------------------


*******************************************************************************************************************
Evaluamos como aprendizaje este ejercicio: Aula_18_Evaluar_CNN_Datos_Minist.py.
Este ejercicio propuesto está entrenado con datos MINIST.
Con el fin de que el Alunno, pueda apreciar la configuracion, y la estructura de datos,
guardamos el módulo entrenado en nuestro ordenador, en formato directorio, con el nombre :
MI-MODULO-MINIST

MNIST se refiere a un conjunto de datos muy utilizado
en el ámbito de la visión por computadora y el aprendizaje profundo.

El conjunto de datos MNIST consiste en imágenes de dígitos escritos
a mano, del 0 al 9. Cada imagen es en escala de grises y tiene un
tamaño de 28x28 píxeles. El conjunto está dividido en un conjunto
de entrenamiento y un conjunto de prueba, y se utiliza comúnmente
como punto de partida para probar algoritmos y modelos de aprendizaje
automático, especialmente en el contexto de reconocimiento de dígitos.

En nuestro código, estamos utilizando el conjunto de datos MNIST
proporcionado por TensorFlow para entrenar y evaluar tu red neuronal
convolucional (CNN) en el reconocimiento de estos dígitos manuscritos.

Como podemos apreciar, la evaluación del ejercicio, no es del todo positiva.
El alumno puede modificarlo para intentar ajustarlo.

*********************************************************************

El ejercicio propuesto podríamos describirlo, por pasos de la siguiente
forma:

Importaciones de Bibliotecas:
********************************

Se importa TensorFlow, una biblioteca popular para aprendizaje profundo y otras tareas de machine learning.
Se importan clases y funciones específicas de TensorFlow, como Dense, Flatten, Conv2D, Model, y otras necesarias para construir y entrenar modelos de redes neuronales.
Carga de Datos MNIST:

Utiliza TensorFlow para cargar el conjunto de datos MNIST, que consiste en imágenes de dígitos escritos a mano y sus respectivas etiquetas de clase (números del 0 al 9).
Normaliza las imágenes dividiendo los valores de píxeles por 255.0.

Preparación de Datos:
************************
Añade una dimensión extra a las imágenes para representar los canales de color (en este caso, escala de grises).
Crea conjuntos de datos (train_ds y test_ds) usando TensorFlow Dataset API para facilitar el manejo y la alimentación de datos durante el entrenamiento y prueba.

Definimos el Modelo:
***********************
Define una clase MyModel que hereda de la clase Model. Esta clase representa el modelo de la red neuronal convolucional (CNN) que se construirá.
En el constructor (__init__), se definen capas de convolución, aplanado (flatten), y capas densas.
En el método call, se define la secuencia de operaciones para la propagación hacia adelante.

Configuración de Entrenamiento:
************************************
Define funciones de pérdida, optimizador y métricas para la fase de entrenamiento.
Define funciones train_step y test_step utilizando decoradores de TensorFlow (@tf.function) para ejecutar estas funciones de manera eficiente en modo gráfico.

Bucle de Entrenamiento:
***************************
Itera a través de un número de épocas predefinido (EPOCHS).
En cada época, realiza un bucle de entrenamiento y otro de prueba.
Muestra métricas como pérdida y precisión durante el entrenamiento y la prueba.

Guardamos del Modelo:
*******************
Guarda el modelo entrenado en un directorio especificado.

Carga de Imagen para Predicción:
*******************************
Intenta cargar una imagen (numero.jpg) para realizar una predicción utilizando el modelo entrenado.
Se produce un error debido a que el archivo no se encuentra en la ubicación especificada.

Impresión de Resultados:
*****************************
Imprime el número predicho y el porcentaje de precisión para la clase predicha.

****************************************************************************
SALIDA POR CONSOLA, SIN ACIERTO.

****************************************************************************
SALIDA POR CONSOLA, SIN ACIERTO.

TensorFlow version: 2.13.1
Por favor, ESPERA A REALIZAR LAS 10 EPOCHS
Epoch 1, Loss: 0.13401952385902405, Accuracy: 95.94000244140625, Test Loss: 0.06022726744413376, Test Accuracy: 98.1500015258789
Epoch 2, Loss: 0.04087728634476662, Accuracy: 98.68333435058594, Test Loss: 0.055624209344387054, Test Accuracy: 98.18999481201172
Epoch 3, Loss: 0.02175530232489109, Accuracy: 99.288330078125, Test Loss: 0.05986746773123741, Test Accuracy: 98.12999725341797
Epoch 4, Loss: 0.013109182007610798, Accuracy: 99.57167053222656, Test Loss: 0.05405193939805031, Test Accuracy: 98.32999420166016
Epoch 5, Loss: 0.008494390174746513, Accuracy: 99.70832824707031, Test Loss: 0.06368830800056458, Test Accuracy: 98.44999694824219
Epoch 6, Loss: 0.008195172995328903, Accuracy: 99.7249984741211, Test Loss: 0.07445775717496872, Test Accuracy: 98.33999633789062
Epoch 7, Loss: 0.005741223692893982, Accuracy: 99.8066635131836, Test Loss: 0.07288998365402222, Test Accuracy: 98.38999938964844
Epoch 8, Loss: 0.003435570513829589, Accuracy: 99.8933334350586, Test Loss: 0.08180861920118332, Test Accuracy: 98.32999420166016
Epoch 9, Loss: 0.0059661963023245335, Accuracy: 99.80500030517578, Test Loss: 0.0844760537147522, Test Accuracy: 98.25999450683594
Epoch 10, Loss: 0.002849259879440069, Accuracy: 99.90166473388672, Test Loss: 0.08755964040756226, Test Accuracy: 98.3499984741211
Salvamos MI-MODULO-MINIST
1/1 [==============================] - 0s 49ms/step
Número predicho: 3 <-------------------En esta predicción hemos tenido éxito.
Porcentaje de precisión: 39.92%

************************************************************
-------------------------------------------------------------------
Este ejercicio ha sido realizado bajo una plataforma Linux.
Ubuntu 20.04.6 LTS.
Editado con Sublime text.

El alumno, deberá tener cargadas las librerias necesarias en el sistema.
import tensorflow as tf
from tensorflow.keras.models import load_model
from tensorflow.keras.preprocessing import image
import numpy as np

------------------------------------------------------------
Ejecución bajo consola Linux.
python3 Aula_18_Evaluar_CNN_Datos_Minist.py

Descenso de gradiente Mini Batch.
********************************
MiniBatch-Aula_228-B.py

******************************************************************************************
El descenso de gradiente mini batch, también conocido como Mini Batch Gradient Descent, es una variante del algoritmo de optimización del descenso de gradiente utilizado en el aprendizaje automático y la optimización de modelos de redes neuronales. A diferencia del descenso de gradiente estocástico (SGD) y el descenso de gradiente por lotes (Batch Gradient Descent), el descenso de gradiente mini batch combina características de ambos enfoques.

En el descenso de gradiente mini batch, los datos de entrenamiento se dividen en lotes más pequeños, cada uno de los cuales se utiliza para calcular una actualización parcial de los pesos del modelo. Estos lotes más pequeños se llaman "mini lotes". La idea detrás de esta técnica es encontrar un equilibrio entre la eficiencia de la actualización de parámetros y la variabilidad de las actualizaciones en comparación con el SGD y el Batch Gradient Descent.

Aquí hay una descripción paso a paso del proceso del descenso de gradiente mini batch:

División de los datos: Los datos de entrenamiento se dividen en mini lotes de tamaño fijo. El tamaño del mini lote es un hiperparámetro que se puede ajustar según las necesidades del problema. Por lo general, los tamaños de mini lotes varían desde 16 hasta 256 ejemplos, pero esto puede variar según el conjunto de datos y la arquitectura de la red.

Inicialización de pesos: Se inicializan los pesos del modelo de manera aleatoria o utilizando algún método de inicialización específico.

Cálculo del gradiente: Para cada mini lote, se calcula el gradiente de la función de pérdida con respecto a los pesos del modelo utilizando solo los ejemplos en ese mini lote. Esto se hace utilizando retropropagación (backpropagation).

Actualización de pesos: Los pesos del modelo se actualizan utilizando el gradiente calculado. La fórmula de actualización es similar a la del descenso de gradiente estocástico, pero en lugar de utilizar un solo ejemplo, se promedian los gradientes de todos los ejemplos en el mini lote. Esto suaviza las actualizaciones y reduce la variabilidad en comparación con el SGD.

Iteración: Se repiten los pasos 3 y 4 para cada mini lote. Este proceso se repite a lo largo de múltiples épocas hasta que se alcance un criterio de parada, como un número máximo de épocas o una convergencia satisfactoria.

Ventajas del descenso de gradiente mini batch:

Mayor eficiencia computacional en comparación con el Batch Gradient Descent, ya que se aprovecha el paralelismo en las operaciones matriciales.
Menor variabilidad en las actualizaciones de peso en comparación con el SGD, lo que puede llevar a una convergencia más rápida y estable.
El descenso de gradiente mini batch es una elección común para entrenar modelos de redes neuronales en la práctica, ya que combina las ventajas de SGD y Batch Gradient Descent. El tamaño del mini lote es un hiperparámetro crítico que debe ajustarse según el problema y la memoria disponible.

minicom: Mini Intérprete de comandos.
Programa escrito en lenguaje Python, versión 3.x.
Llamar de la siguiente manera: