Código de Python - Evaluación con datos MINIST.

Evaluación con datos MINIST.

Python

Publicado el 10 de Marzo del 2024 por Hilario (122 códigos)

259 visualizaciones desde el 10 de Marzo del 2024

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

*******************************************************************************************************************
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

Requerimientos

************************************************************
-------------------------------------------------------------------
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

----------------------------------------------

PROCURAR.
La imagen de muestra sobre escrita en negro, sobre
nitido fondo blanco.
***************************************************

V-0.

Publicado el 10 de Marzo del 2024

gráfica de visualizaciones de la versión: V-0.

260 visualizaciones desde el 10 de Marzo del 2024

100

101

102

103

104

105

106

107

108

109

110

111

#Ejecución bajo consola Linux.

#python3 Aula_18_Evaluar_CNN_Datos_Minist.py

import tensorflow as tf

print("TensorFlow version:", tf.__version__)

print("Por favor, ESPERA A REALIZAR LAS 10 EPOCHS")

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

from tensorflow.keras import Model

import numpy as np

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()

x_train, x_test = x_train / 255.0, x_test / 255.0

# Add a channels dimension

x_train = x_train[..., tf.newaxis].astype("float32")

x_test = x_test[..., tf.newaxis].astype("float32")

train_ds = tf.data.Dataset.from_tensor_slices(

    (x_train, y_train)).shuffle(10000).batch(32)

test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)

class MyModel(Model):

  def __init__(self):

    super().__init__()

    self.conv1 = Conv2D(32, 3, activation='relu')

    self.flatten = Flatten()

    self.d1 = Dense(128, activation='relu')

    self.d2 = Dense(10)

  def call(self, x):

    x = self.conv1(x)

    x = self.flatten(x)

    x = self.d1(x)

    return self.d2(x)

# Create an instance of the model

model = MyModel()

loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

optimizer = tf.keras.optimizers.Adam()

train_loss = tf.keras.metrics.Mean(name='train_loss')

train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

test_loss = tf.keras.metrics.Mean(name='test_loss')

test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')

@tf.function

def train_step(images, labels):

  with tf.GradientTape() as tape:

    # training=True is only needed if there are layers with different

    # behavior during training versus inference (e.g. Dropout).

    predictions = model(images, training=True)

    loss = loss_object(labels, predictions)

  gradients = tape.gradient(loss, model.trainable_variables)

  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

  train_loss(loss)

  train_accuracy(labels, predictions)

@tf.function

def test_step(images, labels):

  # training=False is only needed if there are layers with different

  # behavior during training versus inference (e.g. Dropout).

  predictions = model(images, training=False)

  t_loss = loss_object(labels, predictions)

  test_loss(t_loss)

  test_accuracy(labels, predictions)

EPOCHS = 10

for epoch in range(EPOCHS):

  # Reset the metrics at the start of the next epoch

  train_loss.reset_states()

  train_accuracy.reset_states()

  test_loss.reset_states()

  test_accuracy.reset_states()

  for images, labels in train_ds:

    train_step(images, labels)

  for test_images, test_labels in test_ds:

    test_step(test_images, test_labels)

  print(

    f'Epoch {epoch + 1}, '

    f'Loss: {train_loss.result()}, '

    f'Accuracy: {train_accuracy.result() * 100}, '

    f'Test Loss: {test_loss.result()}, '

    f'Test Accuracy: {test_accuracy.result() * 100}'

print("Salvamos MI-MODULO-MINIST")

model.save('/home/margarito/python/MI-MODULO-MINIST', save_format='tf')

# Cargar la imagen que contiene el número a identificar

ruta_de_la_imagen = '/home/margarito/python/numero.jpg'

img = tf.keras.preprocessing.image.load_img(ruta_de_la_imagen, target_size=(28, 28), color_mode='grayscale')

img_array = tf.keras.preprocessing.image.img_to_array(img)

img_array = np.expand_dims(img_array, axis=0)

img_array /= 255.0  # Normalizar la imagen

# Realizar la predicción

predicciones = model.predict(img_array)

# Obtener el porcentaje de precisión para la clase predicha

precision = np.max(predicciones) * 100

clase_predicha = np.argmax(predicciones)

# Imprimir el resultado

print(f'Número predicho: {clase_predicha}')

print(f'Porcentaje de precisión: {precision:.2f}%')

Comentarios sobre la versión: V-0. (0)

No hay comentarios

Comentar la versión: V-0.

http://lwp-l.com/s7502

Tags:
minist

Stock Monitor

InceptionV3

Código de Python - Evaluación con datos MINIST.

Requerimientos

V-0.

Comentarios sobre la versión: V-0. (0)

Comentar la versión: V-0.

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.