CLASES DE IMAGENES CON UNA MUESTRA DE CADA UNA.
-----------------------------------------------------------------------------------
***************************************************************
IMAGEN PROPUESTA A EVALUAR.
------------------------------------------------------------------------------
****************************************************************************************************************
TUTORIAL DEL EJERCICIO.
--------------------------------------
Este ejercicio que propongo hoy, está realizado con el fin de entender la dinámica, o forma de realizar una red neuronal CNN.
Está compuesto por tres códigos:
1- Aula_28_Descarga_Imagenes.py
-------------------------------
En este primer código accedemos a:
dataset_url = https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz"
De donde descargamos las imagenes necesarias para realizar el posterior modelo.
Las imagenes se guardaran, en nuestro usuario de Linux -Ubuntu-, en un fichero oculto (.Keras),
en un directorio llamado Datasets, en mi caso con la siguiente ruta:
/home/margarito/.keras/datasets/flower_photos.
En el directorio:flower_photos, encontraremos las imagenes de las flores, con las clases a que corresponden.
Tres directorios con imágenes de estas clases:
-flower_photos
--daisy
--dandelion
--roses
--sunflowers
--tulips
Con el fin de utilizar estas imagenes de forma indirecta, copiaremos el directorio:-flower_photos
y lo pegaremos en nuestro directorio de usuario.
Al ejecutar este código, se muestra una imagen de cada clase.
---------------------------------------------------
Librerías necesarias a cargadas en vuestro sistema para la ejecución de este código:
import matplotlib.pyplot as plt
import numpy as np
import os
import PIL
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
import pathlib
*************************************************************************************************************
2-Aula_28_Entreno_Modelo.py
--------------------------
Con este código, lo que hacemos es entrenar el modelo, salvandolo una vez entrenado en nuestro usuario, en el directorio donde tengamos nuestros códigos.
Básicamente este código hace lo siguiente:
Este código en Python utiliza TensorFlow y Keras para construir y entrenar una red
neuronal convolucional (CNN) para clasificar imágenes de flores. Aquí está el desglose de lo que hace cada parte del código:
Importación de bibliotecas:
Importa TensorFlow y algunas clases específicas
de Keras necesarias para el procesamiento de imágenes.
Definición de directorios y ruta del modelo:
Establece las rutas de los directorios donde se encuentran
los datos de entrenamiento de imágenes de flores y donde se guardará el modelo entrenado.
Parámetros de entrenamiento:
Define los parámetros para el entrenamiento,
como el tamaño del lote, la altura y el ancho de las imágenes, y el número de épocas.
Generador de datos de entrenamiento:
Crea un generador de datos de imágenes de entrenamiento
utilizando la clase ImageDataGenerator de Keras.
Esta clase realiza aumento de datos, como escalamiento, recorte, volteo horizontal, etc.
Configuración de generadores de flujo de datos de entrenamiento
y validación:
Configura los generadores de flujo de datos
de entrenamiento y validación utilizando el directorio de datos
de entrenamiento y especificando la división para la validación.
Creación del modelo CNN:
Define el modelo de la CNN utilizando
Sequential de Keras, que es una pila lineal de capas.
El modelo consta de varias capas convolucionales y de agrupación (pooling),
seguidas de capas totalmente conectadas. La última capa utiliza una función
de activación softmax para la clasificación de las clases de flores.
Compilación del modelo:
Compila el modelo especificando el optimizador,
la función de pérdida y las métricas para el entrenamiento.
Entrenamiento del modelo:
Entrena el modelo utilizando los generadores de flujo de datos de entrenamiento y validación.
Guardado del modelo:
Guarda el modelo entrenado en la ruta especificada.
Mensaje de finalización:
Imprime un mensaje para indicar que el modelo ha sido entrenado y guardado correctamente.
Como podéis apreciar, en mi caso de linux, las rutas donde tengo los datos,
y el lugar donde gusrado el modelo, es el siguiente:
# Rutas de los directorios de datos
train_dir = '/home/margarito/python/flower_photos'
model_path = '/home/margarito/python/Mi_Modelo_Hilario.h5'
******************************************************************************************************************
Librerías necesarias a cargadas en vuestro sistema para la ejecución de este código:
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
-------------------------------------------------------------------------------------
3-Aula_28_Probar_Modelo.py
-------------------------
Con este código voy a probar el modelo.
En mi caso he sacado una fotografia, a una flor silvestre de diente de leon,
con el fin de evaluar el acierto de mi programa.
Este programa podría resumirse de la siguiente forma:
Este código realiza la inferencia de una imagen de flor utilizando un modelo de red neuronal convolucional (CNN) previamente entrenado. Aquí está el desglose de lo que hace cada parte del código:
Importación de bibliotecas:
Importa las bibliotecas necesarias, incluyendo NumPy para manipulación de matrices
y TensorFlow para el uso del modelo y la preprocesamiento de imágenes.
Cargar el modelo previamente entrenado:
Carga el modelo de CNN previamente entrenado desde la ruta especificada en modelo_ruta.
Ruta de la imagen de la flor:
Define la ruta de la imagen de la flor que se desea clasificar.
Cargar y redimensionar la imagen:
Carga la imagen de la flor desde la ruta especificada
y la redimensiona al tamaño requerido por el modelo, que es 224x224 píxeles.
Convertir la imagen a un array numpy:
Convierte la imagen cargada en un array numpy para que pueda ser procesada por el modelo.
Preprocesamiento de la imagen:
Realiza cualquier preprocesamiento necesario en la imagen, en este caso,
expandiendo las dimensiones del array para que coincida con el formato de entrada esperado por el modelo.
Normalización de los valores de píxeles:
Normaliza los valores de píxeles de la imagen para que estén en el rango de 0 a 1,
lo que es comúnmente necesario para la entrada de los modelos de redes neuronales.
Hacer la predicción:
Utiliza el modelo cargado para realizar la predicción en la imagen preprocesada.
Obtener la clase predicha:
Identifica la clase predicha asignando etiquetas de clases a las salidas del modelo
y seleccionando la clase con el valor de probabilidad más alto.
Imprimir la clase predicha:
Imprime la clase predicha de la flor en la imagen.
En resumen, este código toma una imagen de una flor,
la procesa adecuadamente para que pueda ser ingresada
al modelo, la clasifica utilizando el modelo
previamente entrenado y luego imprime la
clase predicha de la flor en la imagen.
------------------------------------------------------
Librerías necesarias a cargadas en vuestro sistema para la ejecución de este código:
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing import image
*********************************************************************************
Estos ejercicios han sido realizados y ejecutados bajo consola linux.
Concretamente bajo Ubuntu 20.04.6 LTS.
Fueron editados con Sublime text.
Debereis de tener en cuenta que para la ejecución de los ejercicios
deberéis tener instaladas las librerías y módulos necesarios, segfún se indica en cada código.
----------------------------------------------
SALIDA, EN MI CASO DEL EJERCICIO DE LA IMAGEN PROPUESTA DE EVALUACIÓN:
2024-03-24 12:47:54.765845: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.
2024-03-24 12:47:54.797982: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.
2024-03-24 12:47:54.798348: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.
To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.
2024-03-24 12:47:55.329900: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT
1/1 [==============================] - ETA: 0s
1/1 [==============================] - 0s 114ms/step
La flor en la imagen es: dandelion
[Finished in 2.9s]
