Códigos Fuente de Python

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







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

Ejercicios:Aula_28_Softmax.py - Aula_28_softmax_pooling.py

Proponemos dos ejemplos en los utilizamos la función softmax, en una sencilla red convolucional CNN
En el primer ejemplo lo hacemos sin aplicar maxpooling, en el segundo ejemplo lo hacemos aplicando maxpooling

La función Softmax toma un vector de logits y produce una distribución de probabilidad sobre las clases. Esto es útil en problemas de clasificación, ya que permite interpretar las salidas de la red como la probabilidad de que una entrada pertenezca a cada clase posible. La clase con la probabilidad más alta se considera la predicción final de la red. Este enfoque es especialmente útil en problemas de clasificación multiclase, como el reconocimiento de dígitos en el conjunto de datos MNIST.


La función Softmax se utiliza para calcular probabilidades finales en el contexto de clasificación. Después de aplicar Softmax a los logits (las salidas de la red antes de aplicar ninguna función de activación en la capa de salida), obtienes un conjunto de valores que representan las probabilidades de pertenencia a cada clase posible.

Estas probabilidades están normalizadas de manera que sumen 1. Cada valor indica la probabilidad estimada de que la entrada pertenezca a la clase correspondiente. La clase con la probabilidad más alta se considera la predicción final del modelo.

Entonces, en resumen, Softmax toma los logits y los convierte en una distribución de probabilidad sobre las clases, lo que facilita la interpretación y la toma de decisiones al seleccionar la clase con la probabilidad más alta como la predicción final del modelo.

La aplicación de la función Softmax generalmente se realiza en la capa de salida de la red neuronal, justo antes de tomar la decisión final sobre la clase a la que pertenece la entrada. En términos de programación, esto se realiza comúnmente como parte de la definición del modelo en el código.
********************************************************************************************************************

Para realizar este ejercicio tomamos datos MNIST.
MNIST es un conjunto de datos ampliamente utilizado en el campo de la visión por computadora y el aprendizaje profundo. Este conjunto de datos consiste en imágenes en escala de grises de dígitos escritos a mano (0 al 9), cada una de 28x28 píxeles. MNIST se utiliza comúnmente como un punto de partida para probar y desarrollar algoritmos de reconocimiento de imágenes utilizando redes neuronales convolucionales.

El objetivo típico es entrenar un modelo para clasificar correctamente las imágenes en sus respectivas categorías de dígitos. Muchos investigadores y desarrolladores utilizan MNIST como una especie de "Hello World" para la visión por computadora, ya que proporciona un caso de prueba relativamente simple pero efectivo para evaluar el rendimiento de modelos de aprendizaje profundo en tareas de clasificación de imágenes.
********************************************************************************************************************
Ejercicio realizado bajo plataforma Linux.
Ubuntu 20.04.6 LTS
---------------------------------------------------------------
Ejecución bajo consola Linux:
python3 Aula_28_softmax_pooling.py
python3 Aula_28_softmax_pooling.py

--------------------------------------------------------------------
Se deberá tener cargado en el sistema estos módulos:
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import fashion_mnist
import matplotlib.pyplot as plt
-------------------------------------------------------------------
Para que vustro ordenador no produzca desbordamiento:Instrucción ilegal (`core' generado)

Vuestro ordenador deberá tener una cpu que soprte AVX (Advanced Vector Extensions) que es una extensión de instrucciones introducida por Intel y AMD en sus procesadores para realizar operaciones de manera más eficiente, especialmente en tareas que involucran cálculos en paralelo. Cuando se dice que una CPU "soporta AVX", significa que es capaz de ejecutar las instrucciones AVX.

Las instrucciones AVX permiten realizar operaciones en vectores más grandes de datos simultáneamente, lo que puede mejorar significativamente el rendimiento en aplicaciones que están optimizadas para utilizar estas extensiones. Este tipo de instrucciones son particularmente beneficiosas en tareas intensivas en cálculos, como aquellas encontradas en aplicaciones científicas, de inteligencia artificial, gráficos 3D y procesamiento de señales, entre otras.

En el contexto de programación y desarrollo de software, si un procesador es compatible con AVX, los desarrolladores pueden aprovechar estas instrucciones para optimizar sus programas y mejorar el rendimiento en hardware que admite esta tecnología. Sin embargo, es importante destacar que no todos los procesadores admiten AVX y que la capacidad de aprovechar estas instrucciones depende del soporte tanto del hardware como del software.

*******************************************************************************************************************
Si vuestra CPU, no cubre estos requisitos, también se pueden ejecutar con Google Colab.
******************************************************************************************************************

********************************************************************************************************************
En este breve ejercicio, pretendo explicar algunas dudas sobre la utilizacion de ImageDataGenerator.
Esta función se utiliza en las redes convolucionales, para nodificar los parámetros o apariencia de las imagenes
utilizadas para el training, con el propósito principal de mejorar el rendimiento y la generalización del modelo mediante el aumento de datos y la normalización.

Aquí están los objetivos clave:
--------------------------------------

Aumento de Datos para Mejor Generalización:

El aumento de datos implica aplicar transformaciones aleatorias a las imágenes durante el entrenamiento, como rotación, cambio de escala, volteo horizontal, etc. Este proceso aumenta la diversidad del conjunto de datos, permitiendo que el modelo vea variaciones de las imágenes originales. Como resultado, la CNN se vuelve más robusta y generaliza mejor a nuevas imágenes que puede encontrar durante la inferencia.

Prevención de Sobreajuste (Overfitting):

El sobreajuste ocurre cuando un modelo aprende demasiado bien los detalles específicos del conjunto de entrenamiento y tiene dificultades para generalizar a datos no vistos. El aumento de datos ayuda a prevenir el sobreajuste al introducir variaciones artificiales en las imágenes de entrenamiento. Esto es crucial cuando el conjunto de datos es relativamente pequeño.

Normalización para Facilitar el Entrenamiento:

La normalización de píxeles (escalando valores a un rango específico, como [0, 1]) facilita el proceso de entrenamiento. Al tener valores de píxeles en un rango más pequeño, los gradientes durante el entrenamiento son más estables, lo que puede llevar a una convergencia más rápida del modelo.

Manejo Eficiente de Grandes Conjuntos de Datos:

Cuando trabajas con grandes conjuntos de datos que no caben completamente en la memoria, ImageDataGenerator permite cargar y procesar las imágenes de manera eficiente en lotes durante el entrenamiento. Esto es esencial para hacer frente a conjuntos de datos de tamaño considerable.
En resumen, ImageDataGenerator contribuye significativamente a mejorar la capacidad de generalización de una CNN, a hacer que el modelo sea más robusto frente a variaciones en los datos y a facilitar el proceso de entrenamiento, especialmente cuando se trata de conjuntos de datos grandes.

********************************************************************************************************************
Un ejemplo típico de argumentos pasados a ImageDataGenerator sería el siguiente:

datagen = ImageDataGenerator(
rescale=1./255, # Normalización
rotation_range=20, # Rango de rotación aleatoria
width_shift_range=0.2, # Rango de cambio horizontal aleatorio
height_shift_range=0.2, # Rango de cambio vertical aleatorio
shear_range=0.2, # Rango de cizallamiento aleatorio
zoom_range=0.2, # Rango de zoom aleatorio
horizontal_flip=True # Volteo horizontal aleatorio
)

********************************************************************************************************************
********************************************************************************************************************
Este programa ha sido editado y ejecutadoi con Google Colab.
El archivo de jemplo estaba alojado en Drive de Google Colab.

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

Sencillo_Concep_Pixel_Aula_28.py
**********************




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

Con este sencillo y diminuto ejercicio, tratamos de explicar algunas dudas conceptuales sobre el tratamiento y comprensión
del funcionamiento de los pixeles. Aula 28.
-----------------------------------------------------------------------------------------------------------------------

Definición de los valores del píxel:
------------------------------------------------
Se especifican los valores de los canales rojo, verde y azul del píxel. En este caso, son [88, 15, 108].

Visualización de la imagen sin normalización:
---------------------------------------------------------------
Se crea una imagen de 1x1 píxeles con los valores de los canales y se muestra directamente. La escala de colores refleja los valores originales sin ajustes.

Normalización de los valores de los canales:
--------------------------------------------------------------
Se normalizan los valores de los canales dividiéndolos por 255.0. Este paso es común en procesamiento de imágenes para asegurarse de que los valores estén en el rango [0, 1].

Visualización de la imagen normalizada:
--------------------------------------------------------
Se crea una nueva imagen con los valores normalizados y se muestra. La escala de colores ahora refleja los valores ajustados al rango [0, 1].

Impresión de la matriz normalizada:
--------------------------------------------------
La matriz normalizada se imprime en la consola. Esto muestra cómo los valores de los canales se han ajustado a la escala [0, 1].

En resumen, el código realiza dos visualizaciones de un píxel: una con los valores de los canales originales y otra después de normalizar esos valores para asegurarse de que estén en un rango comprensible para la visualización de colores.

Salida por consola de los pixels normalizados.


[[0.34509804 0.05882353 0.42352941]]



***********************************************************************************************
Realizado en Plataforma Linux. Ubuntu 20.04.6 LTS
Editado con Sublime text.
Ejecución:python3 Sencillo_Concep_Pixel_Aula_28.py
************************************************************************************************

La última imagen corresponde a la EPOCH número 3.
-----------------------------------------------------------------------




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


MANUAL PREDICCIÓN PRÓXIMA A DECISIÓN.
------------------------------------

Ejercicio_IA_Aula_08.py
-----------------------

Este código implementa una red convolucional (CNN) utilizando el conjunto de datos CIFAR-10 para clasificación de imágenes. Aquí hay una explicación sencilla de lo que hace el ejercicio:

Carga y Preprocesamiento de Datos:
-----------------------------------------------
Importa las bibliotecas necesarias y carga el conjunto de datos CIFAR-10.
Normaliza las imágenes dividiendo los valores de píxeles por 255.
Convierte las etiquetas de clase a formato categórico.
Creación de Generadores de Datos:

Define generadores de datos para el entrenamiento y la validación, aplicando aumentación de datos en el conjunto de entrenamiento.

Definición del Modelo CNN:
-------------------------
Crea un modelo secuencial de CNN con capas convolucionales, activaciones ReLU, capas de max-pooling, una capa Flatten, capas Dense y una capa de salida con activación softmax.
Utiliza la función de pérdida 'categorical_crossentropy', el optimizador 'rmsprop' y mide la precisión durante el entrenamiento.

Entrenamiento del Modelo:
-----------------------
Entrena el modelo en varios epochs utilizando el generador de entrenamiento y el generador de validación.
Después de cada epoch, muestra algunas imágenes del conjunto de validación junto con las predicciones del modelo.

Mostrar Resultados Finales:
--------------------------
Muestra los resultados finales, incluyendo la precisión alcanzada en la última epoch.
Visualización de Imágenes en Decisiones:

Define una función (show_images_on_decision) para visualizar imágenes del conjunto de validación junto con las predicciones del modelo.

En resumen, este código implementa y entrena una CNN para clasificación de imágenes en el conjunto de datos CIFAR-10, y muestra algunas imágenes junto con las predicciones del modelo después de cada epoch de entrenamiento.

LAS BIBLIOTECAS QUE UTILIZAREMOS SERÁN LOS SIGUIENTES:
------------------------------------------------------

numpy: Módulo de la librería de matemáticas NumPy para trabajar con matrices y vectores
matplotlib: Módulo de la librería de visualización Matplotlib para crear gráficos y visualizaciones
keras.datasets: Módulo de la biblioteca Keras para cargar y trabajar con conjuntos de datos predefinidos
keras.utils: Módulo de la biblioteca Keras para convertir etiquetas de variables categóricas en matrices numéricas
keras.preprocessing.image: Módulo de la biblioteca Keras para preprocesar imágenes
keras.models: Módulo de la biblioteca Keras para crear y administrar modelos de redes neuronales
keras.layers: Módulo de la biblioteca Keras para definir y agregar capas a los modelos de redes neuronales
keras.backend: Módulo de la biblioteca Keras para acceder a las funciones y variables del backend de TensorFlow

****************************************************************************************************************
Establecimiento de parámetros:
-----------------------------
Se establecen algunos parámetros relevantes para el modelo de red neuronal:

modo: Modo de clasificación utilizado, "categorical" para multiclase o "binary" para binaria
dimension: Dimensión de las imágenes de entrenamiento (32x32 en este caso)
Carga del conjunto de datos CIFAR-10

Se carga el conjunto de datos CIFAR-10, que contiene imágenes de 60,000 objetos de 10 clases diferentes. Las imágenes se dividen en conjuntos de entrenamiento y validación.

Preprocesamiento de imágenes:
----------------------------

Las imágenes se convierten en formato float y se escalan entre 0 y 1. Además, se representan en formato categórico para la clasificación multiclase.

Generación de datos con transformación:

Se utilizan dos generadores de datos para preprocesar las imágenes durante el entrenamiento y la validación. Estos generadores aplican transformaciones como escalado, giro y volteo para aumentar la diversidad del dataset y mejorar el rendimiento del modelo.

Creación del modelo de red neuronal:
----------------------------------
Se crea un modelo de red neuronal convolucional secuencial utilizando el módulo Sequential de Keras. El modelo consta de las siguientes capas:

Capas convolucionales:
---------------------
Tres capas convolucionales con filtros de 16, 32 y 64 filtros, respectivamente. Estas capas extraen características espaciales de las imágenes.

Funciones de activación:
-----------------------
Se utiliza la función de activación ReLU después de cada capa convolucional para mejorar la selectividad de las características extraídas.

"Polinización" máxima:
-------------------
Se utiliza la capa de maxpooling después de cada capa convolucional para reducir la dimensionalidad de las representaciones espaciales sin perder información importante.

Flatten:
-------
Se utiliza una capa de aplanamiento para convertir las matrices bidimensionales de características en vectores unidimensionales.

Capas densas:
-----------
Se agregan dos capas densas con 64 y 10 neuronas, respectivamente. Estas capas representan la parte final del modelo, donde se realiza la clasificación.

Función de activación final: La última capa utiliza la función de activación softmax para generar probabilidades de pertenencia a cada una de las 10 clases.

Compilación del modelo.
**********************

Se compila el modelo definiendo las funciones de pérdida y optimizador. La función de pérdida utilizada es la entropía cruzada categórica para la clasificación multiclase, y el optimizador utilizado es el RMSprop, un algoritmo de optimización eficiente para redes neuronales convolucionales.

Entrenamiento del modelo.
***********************
Se entrena el modelo durante 5 épocas, utilizando los conjuntos de entrenamiento y validación. En cada época, el modelo se ajusta a los datos de entrenamiento y se evalúa en los datos de validación para monitorear su progreso.

Función para mostrar imágenes de decisión
****************************************
Se define una función show_images_on_decision que muestra imágenes del conjunto de validación y sus predicciones. Esta función se utiliza después de cada época para visualizar cómo está funcionando el modelo.

Resultados finales
*****************
Al final del entrenamiento, se imprimen los resultados finales, incluyendo la precisión del modelo en el conjunto de validación.

------------------------------------------------------------------------------------------------------------
El ejercicio fue realizado en una plataforma Linux.
Ubuntu 20.04.6 LTS.
Editado en Sublime text.
Ejecución bajo consola de linux:
--------------------------------------------------------------------------------------------
También se puede editar y ejecutar con GOOGLE COLAB.
********************************************************************************************************************

SALIDA DEL EJERCICIO DESPUES DE 5 CICLOS O EPOCH, CON LA PRECISIÓN OBTENIDA.
***************************************************************************

Epoch 1/5
3125/3125 [==============================] - 55s 17ms/step - loss: 1.7981 - accuracy: 0.3388 - val_loss: 1.4368 - val_accuracy: 0.4725
1/1 [==============================] - 0s 122ms/step
Epoch 2/5
3125/3125 [==============================] - 54s 17ms/step - loss: 1.5218 - accuracy: 0.4575 - val_loss: 1.3205 - val_accuracy: 0.5330
1/1 [==============================] - 0s 24ms/step
Epoch 3/5
3125/3125 [==============================] - 54s 17ms/step - loss: 1.4376 - accuracy: 0.5005 - val_loss: 1.2920 - val_accuracy: 0.5522
1/1 [==============================] - 0s 24ms/step
Epoch 4/5
3125/3125 [==============================] - 54s 17ms/step - loss: 1.4429 - accuracy: 0.5088 - val_loss: 1.4771 - val_accuracy: 0.4987
1/1 [==============================] - 0s 24ms/step
Epoch 5/5
3125/3125 [==============================] - 54s 17ms/step - loss: 1.4649 - accuracy: 0.5012 - val_loss: 1.3029 - val_accuracy: 0.5609
1/1 [==============================] - 0s 24ms/step


_____________________________________________________
| Dimension | Capa | Filtro | Precision |
_____________________________________________________
| 32 | 3 | [64] | 50.1240015 |
_____________________________________________________

PREGUNTA DEL EJERCICIO.
------------------------------------------
Considerando que tengo que entrenar mi modelo con datos Cifar 10, Guardandolo en esta ruta:'/home/margarito/python/Mi_Modulo_Hilario.h5'.

Necesito crear un test python -basandonos en el modelo:/Mi_Modulo_Hilario.h5, para determinar la clase de esta imagen que esta en esta ruta:/home/margarito/python/gato.jpg.
Para el ejercicio debes de considerar que el archivo de datos Cifar 10, abarca las siguientes clases:

clase 0: airplane
clase 1: automobile
clase 2: bird
clase 3: cat
clase 4: deer
clase 5: dog
clase 6: frog
clase 7: horse
clase 8: ship
clase 9: truck

En el ejercicio se deberá decir de que clase es la imagen del test.
También se deberá de visualizar la imagen_array), en que te basas para hacer dicha predicción.
***************************************************************************************************************
Bien, podríamos plantear una estructura básica del proyecto como sigue:

Como podría ser una estructura del Proyecto:

Proyecto_Mi_CNN/
│
├── cifar-10/
│ ├── data_batch_2
│ └── ...
│
├── src/
│ ├── __init__.py
│ ├── train_model.py
│ └── test_model.py
│
└── Mi_Modulo_Hilario.h5

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

Para descargar los datos de imagenes Cifar 10, podeis utilizar este enlace:
https://www.cs.toronto.edu/~kriz/cifar.html
Se abrirá un pequeño manual explicativo, y desde el mismo se verán todas las opciones de descarga,
así como el tipo de datos para generar modelos que abarca Cifar 10.
*******************************************************************************************************************
Este ejercicio ha sido realizado bajo platadorma Linux.
Ubuntu 20.04.6 LTS.
Editado con sublime Text.
-------------------------------------------------------------------------------------------------------------
Para la ejecución correcta del programa en Python debereis tener cargadas para importar,
estas librerías:

import tensorflow as tf
from tensorflow.keras.preprocessing import image
from tensorflow.keras.models import load_model
import numpy as np
import matplotlib.pyplot as plt

En el ejercicio: 106, en la línea de codigo referente a la compilacion del modelo:
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])
aparece como paso a la función esta igualdad: optimizer='rmsprop'.

A continuación en el ejercicio: Aula-28_RMSprop.py, explicamos un poco este tipo de descenso de gradiente aplicado
para optimizar el modelo.

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

En el descenso de gradiente normal, la tasa de aprendizaje (cuánto nos movemos en la dirección opuesta al gradiente) es constante. Pero a veces, puede ser beneficioso ajustar esa tasa de aprendizaje.

RMSprop hace lo siguiente:

Miramos los gradientes pasados:

RMSprop lleva un registro de cuán grandes fueron los gradientes que hemos visto antes.
Adaptamos la tasa de aprendizaje:

Si los gradientes han sido grandes, RMSprop reduce la tasa de aprendizaje.
Si los gradientes han sido pequeños, RMSprop aumenta la tasa de aprendizaje.
Evitamos divisiones por cero:

RMSprop utiliza un pequeño número llamado

ϵ para evitar divisiones por cero.
En resumen:

RMSprop ajusta automáticamente la tasa de aprendizaje para cada parámetro en función de cómo fueron los gradientes anteriores.
Esto ayuda a converger más rápido en problemas donde las dimensiones de las características pueden variar mucho.
Imagina que estás en una montaña (la función de pérdida) y quieres bajar (minimizar la pérdida). RMSprop te ayuda a ajustar la rapidez con la que te mueves hacia abajo dependiendo de lo empinada que sea la pendiente. Si la pendiente es pronunciada, te mueves más despacio; si es suave, te mueves más rápido. ¡Es como ajustar el paso mientras caminas
hacia abajo para no caerte!
*****************************************************************************************

SALIDA RELACIÓN ITERACIÓN Y COSTO:
***************************************************
Paso 1: x = 8.0000, y = 73.8936, Costo = 73.8936
Paso 2: x = 7.9002, y = 72.4027, Costo = 72.4027
Paso 3: x = 7.8004, y = 70.8319, Costo = 70.8319
Paso 4: x = 7.7006, y = 69.1814, Costo = 69.1814
Paso 5: x = 7.6007, y = 67.4522, Costo = 67.4522
Paso 6: x = 7.5009, y = 65.6462, Costo = 65.6462
Paso 7: x = 7.4010, y = 63.7664, Costo = 63.7664
Paso 8: x = 7.3011, y = 61.8168, Costo = 61.8168
Paso 9: x = 7.2012, y = 59.8021, Costo = 59.8021
Paso 10: x = 7.1014, y = 57.7281, Costo = 57.7281
Paso 11: x = 7.0015, y = 55.6011, Costo = 55.6011
Paso 12: x = 6.9015, y = 53.4284, Costo = 53.4284
Paso 13: x = 6.8016, y = 51.2177, Costo = 51.2177
Paso 14: x = 6.7017, y = 48.9775, Costo = 48.9775
Paso 15: x = 6.6018, y = 46.7167, Costo = 46.7167
Paso 16: x = 6.5019, y = 44.4446, Costo = 44.4446
Paso 17: x = 6.4020, y = 42.1708, Costo = 42.1708
Paso 18: x = 6.3021, y = 39.9052, Costo = 39.9052
Paso 19: x = 6.2022, y = 37.6576, Costo = 37.6576
Paso 20: x = 6.1023, y = 35.4382, Costo = 35.4382
Paso 21: x = 6.0024, y = 33.2567, Costo = 33.2567
Paso 22: x = 5.9024, y = 31.1228, Costo = 31.1228
Paso 23: x = 5.8025, y = 29.0461, Costo = 29.0461
Paso 24: x = 5.7027, y = 27.0356, Costo = 27.0356
Paso 25: x = 5.6028, y = 25.0999, Costo = 25.0999
Paso 26: x = 5.5029, y = 23.2470, Costo = 23.2470
Paso 27: x = 5.4030, y = 21.4844, Costo = 21.4844
Paso 28: x = 5.3032, y = 19.8188, Costo = 19.8188
Paso 29: x = 5.2034, y = 18.2561, Costo = 18.2561
Paso 30: x = 5.1036, y = 16.8016, Costo = 16.8016
Paso 31: x = 5.0038, y = 15.4594, Costo = 15.4594
Paso 32: x = 4.9041, y = 14.2328, Costo = 14.2328
Paso 33: x = 4.8044, y = 13.1243, Costo = 13.1243
Paso 34: x = 4.7048, y = 12.1353, Costo = 12.1353
Paso 35: x = 4.6053, y = 11.2660, Costo = 11.2660
Paso 36: x = 4.5060, y = 10.5160, Costo = 10.5160
Paso 37: x = 4.4069, y = 9.8837, Costo = 9.8837
Paso 38: x = 4.3082, y = 9.3663, Costo = 9.3663
Paso 39: x = 4.2102, y = 8.9604, Costo = 8.9604
Paso 40: x = 4.1135, y = 8.6612, Costo = 8.6612
Paso 41: x = 4.0196, y = 8.4625, Costo = 8.4625
Paso 42: x = 3.9329, y = 8.3549, Costo = 8.3549
Paso 43: x = 3.8667, y = 8.3192, Costo = 8.3192
Paso 44: x = 3.8413, y = 8.3156, Costo = 8.3156
Paso 45: x = 3.8379, y = 8.3156, Costo = 8.3156
Paso 46: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 47: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 48: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 49: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 50: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 51: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 52: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 53: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 54: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 55: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 56: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 57: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 58: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 59: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 60: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 61: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 62: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 63: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 64: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 65: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 66: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 67: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 68: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 69: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 70: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 71: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 72: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 73: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 74: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 75: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 76: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 77: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 78: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 79: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 80: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 81: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 82: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 83: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 84: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 85: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 86: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 87: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 88: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 89: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 90: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 91: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 92: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 93: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 94: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 95: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 96: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 97: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 98: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 99: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 100: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 101: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 102: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 103: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 104: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 105: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 106: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 107: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 108: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 109: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 110: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 111: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 112: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 113: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 114: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 115: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 116: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 117: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 118: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 119: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 120: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 121: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 122: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 123: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 124: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 125: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 126: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 127: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 128: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 129: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 130: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 131: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 132: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 133: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 134: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 135: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 136: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 137: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 138: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 139: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 140: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 141: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 142: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 143: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 144: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 145: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 146: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 147: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 148: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 149: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 150: x = 3.8375, y = 8.3156, Costo = 8.3156
Paso 151: x = 3.8375, y = 8.3156, Costo = 8.3156
[Finished in 4.5s]

*****************************************************************************************
Ejercicio realizado en plataforma Linux, concretamente: Ubuntu 20.04.6 LTS.
Editado en Sublime text.

Ejecución:python3 Aula-28_RMSprop.py

Se deberá tener cargado en el sistema:
import numpy as np
import matplotlib.pyplot as plt

python3 Repaso_Aula_28.py
*************************


Ejercicio sencillo para Aula-28.
*******************************
Queremos generar un módulo para posteriores entrenamientos utilizando transferencia de aprendizaje.

A nuestro módulo lo llamaremos:MODULO-HIM.h5
Lo guardaré en esta ruta de mi ordenador: save_path = "/home/margarito/python/MODULO-HIM.h5"

Suponemos que en nuestro ordenador tenemos las imagenes de entrenamiento, que deberán guardar básicamente según este este esquema. En el caso de mi ordenador sería el siguiente:

/home/margarito/python/HIM/
|-- train/
| |-- dog/
| | |-- imagen1.jpg
| | |-- imagen2.jpg
| | |-- ...
| |
| |-- flores/
| | |-- imagen1.jpg
| | |-- imagen2.jpg
| | |-- ...
| |
| |-- ...
|
|-- test/
| |-- dog/
| | |-- imagen1.jpg
| | |-- imagen2.jpg
| | |-- ...
| |
| |-- flores/
| | |-- imagen1.jpg
| | |-- imagen2.jpg
| | |-- ...
| |
| |-- ...

Epoch.
*******
Epoch 1/10
2/2 [==============================] - 3s 615ms/step - loss: 0.6765 - accuracy: 0.5472
Epoch 2/10
2/2 [==============================] - 2s 875ms/step - loss: 0.6293 - accuracy: 0.5660
Epoch 3/10
2/2 [==============================] - 2s 566ms/step - loss: 0.5859 - accuracy: 0.6415
Epoch 4/10
2/2 [==============================] - 2s 880ms/step - loss: 0.5429 - accuracy: 0.8491
Epoch 5/10
2/2 [==============================] - 2s 571ms/step - loss: 0.5003 - accuracy: 0.8679
Epoch 6/10
2/2 [==============================] - 2s 564ms/step - loss: 0.4556 - accuracy: 0.8868
Epoch 7/10
2/2 [==============================] - 2s 889ms/step - loss: 0.4191 - accuracy: 0.8868
Epoch 8/10
2/2 [==============================] - 2s 864ms/step - loss: 0.3714 - accuracy: 0.8491
Epoch 9/10
2/2 [==============================] - 2s 884ms/step - loss: 0.3436 - accuracy: 0.9057
Epoch 10/10
2/2 [==============================] - 2s 869ms/step - loss: 0.3403 - accuracy: 0.9245



*************************************************************************************************************
El ejercicio es realizado en plataforma Linux.
Concretamente en:Ubuntu 20.04.6 LTS.
Fue editado con:Sublime text.
Ejecución bajo consola Linux:python3 Repaso_Aula_28.py
***************************************************************************************************************

Utilizar Google Colab junto con Google Drive es una excelente manera de ejecutar y colaborar en proyectos de aprendizaje profundo sin preocuparte por la capacidad de procesamiento y almacenamiento.
Aquí explicamos paso a paso para utilizar Google Colab y Google Drive para generar un modelo de red neuronal convolucional (CNN):
**********************************************************************************************************************************
Paso 1: Preparar tus datos en Google Drive
Crea una carpeta en Google Drive:
Abre Google Drive y crea una carpeta para tu proyecto. Puedes organizar tus datos, cuadernos de Jupyter y modelos en esta carpeta.

Sube tus datos:
Sube tus datos al directorio creado. Pueden ser conjuntos de entrenamiento, validación y prueba en carpetas separadas. Asegúrate de que tus datos estén organizados de manera adecuada.
****************************************************************************************************************************************
Paso 2: Conectar Google Colab a Google Drive
Abre un nuevo cuaderno de Colab:
Abre Google Colab (https://colab.research.google.com/) y crea un nuevo cuaderno de Jupyter.

Monta Google Drive:
Ejecuta el siguiente código en una celda para montar tu Google Drive en Colab. Esto te pedirá autorización y generará un código que debes ingresar.

from google.colab import drive
drive.mount('/content/drive')

Sigue las instrucciones para autorizar y copia el código de autorización en el cuadro de texto de la celda.

*************************************************************************************************************************************
Accede a tus datos:
Después de montar Google Drive, puedes acceder a tu carpeta del proyecto utilizando la ruta /content/drive/MyDrive/:

project_folder = '/content/drive/MyDrive/TuCarpetaDeProyecto'

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

Paso 3: Cargar y Preprocesar Datos
Carga y preprocesa tus datos:
Utiliza las bibliotecas de Python para cargar y preprocesar tus datos. Por ejemplo, si estás trabajando con imágenes en el conjunto de datos CIFAR-10:

import pickle
import numpy as np
from tensorflow.keras.utils import to_categorical

# Cargar datos desde Google Drive
with open(project_folder + '/data/cifar10_data.pkl', 'rb') as file:
data = pickle.load(file)

# Preprocesar datos
x_train, y_train, x_test, y_test = data['train_images'], data['train_labels'], data['test_images'], data['test_labels']
x_train = x_train / 255.0
x_test = x_test / 255.0
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

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

Paso 4: Construir y Entrenar el Modelo CNN
Definir el modelo CNN:
Construye tu modelo de CNN utilizando TensorFlow y Keras. Aquí hay un ejemplo simple:

from tensorflow.keras import layers, models

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

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

Compilar y entrenar el modelo:
Compila y entrena tu modelo utilizando los datos cargados:

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))

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

Paso 5: Guardar el Modelo en Google Drive
Guardar el modelo:
Después de entrenar el modelo, guárdalo en tu carpeta de Google Drive:

model.save(project_folder + '/modelo_cnn.h5')

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

Paso 6: Descargar el Modelo (opcional)
Descargar el modelo:
Si lo prefieres, puedes descargar el modelo entrenado desde Google Drive:

from google.colab import files
files.download(project_folder + '/modelo_cnn.h5')

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

Estos pasos deberían ayudarte a ejecutar un proyecto de CNN en Google Colab utilizando Google Drive para almacenar tus datos y modelos. Asegúrate de adaptar el código según tus necesidades específicas y estructura de datos.


------------------------------------------------------------------------------------------------------------------------------------
**************************************************************************************************************************************************************************************************************************************
SALIDA CONSOLA PROCESO DE EJECUCIÓN DEL EJERCICIO EN GOOGLE COLAB.
*****************************************************************************************************

Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
170498071/170498071 [==============================] - 12s 0us/step
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
conv2d (Conv2D) (None, 30, 30, 32) 896

max_pooling2d (MaxPooling2 (None, 15, 15, 32) 0
D)

conv2d_1 (Conv2D) (None, 13, 13, 64) 18496

max_pooling2d_1 (MaxPoolin (None, 6, 6, 64) 0
g2D)

conv2d_2 (Conv2D) (None, 4, 4, 64) 36928

flatten (Flatten) (None, 1024) 0

dense (Dense) (None, 64) 65600

dense_1 (Dense) (None, 10) 650

=================================================================
Total params: 122570 (478.79 KB)
Trainable params: 122570 (478.79 KB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________
Epoch 1/10
1563/1563 [==============================] - 187s 119ms/step - loss: 1.7111 - accuracy: 0.3684 - val_loss: 1.3924 - val_accuracy: 0.4950
Epoch 2/10
1563/1563 [==============================] - 186s 119ms/step - loss: 1.4381 - accuracy: 0.4798 - val_loss: 1.2347 - val_accuracy: 0.5591
Epoch 3/10
1563/1563 [==============================] - 188s 120ms/step - loss: 1.3287 - accuracy: 0.5234 - val_loss: 1.1421 - val_accuracy: 0.5922
Epoch 4/10
1563/1563 [==============================] - 185s 118ms/step - loss: 1.2549 - accuracy: 0.5513 - val_loss: 1.1387 - val_accuracy: 0.5944
Epoch 5/10
1563/1563 [==============================] - 185s 118ms/step - loss: 1.1964 - accuracy: 0.5732 - val_loss: 1.0895 - val_accuracy: 0.6132
Epoch 6/10
1563/1563 [==============================] - 181s 116ms/step - loss: 1.1545 - accuracy: 0.5881 - val_loss: 1.1042 - val_accuracy: 0.6162
Epoch 7/10
1563/1563 [==============================] - 181s 116ms/step - loss: 1.1209 - accuracy: 0.6025 - val_loss: 1.0378 - val_accuracy: 0.6406
Epoch 8/10
1563/1563 [==============================] - 179s 115ms/step - loss: 1.0897 - accuracy: 0.6128 - val_loss: 0.9644 - val_accuracy: 0.6558
Epoch 9/10
1563/1563 [==============================] - 180s 115ms/step - loss: 1.0678 - accuracy: 0.6223 - val_loss: 0.9507 - val_accuracy: 0.6730
Epoch 10/10
1563/1563 [==============================] - 180s 115ms/step - loss: 1.0431 - accuracy: 0.6308 - val_loss: 0.8898 - val_accuracy: 0.6875
/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py:3103: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.
saving_api.save_model(

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


Aula-28-Trabajo_Imagenes.py
**********************************

Ejecución: python3 Aula-28-Trabajo_Imagenes.py



Utilizando los ficheros .npy, guardamos el array original de pixels en un fichero que llamamos: imagen.npy. Luego manipulamos la imagen a escala de grises en el fichero: imagen_gris.npy, que tambien guardamos, y abrimos para mostrar su modificación.

El sencillo ejercicio se puede manipular y modificar parámetros para observar resultados. Se tendrá en cuenta en sustituir la ruta de los archivos a tratar, que deben estar en el mismo directorio donde se encuentra: Aula-28-Trabajo_Imagenes.py

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

El ejercicio consiste en cargar una imagen en color, convertirla a escala de grises y guardar la imagen en escala de grises en un archivo.

El código del ejercicio se divide esquemáticamente en dos partes principales:

Parte 1: Cargar la imagen y convertirla a un array NumPy.
Parte 2: Convertir la imagen a escala de grises y guardarla en un archivo.
En la parte 1 del código, se utiliza la función Image.open() para cargar la imagen. A continuación, se utiliza la función resize() para cambiar el tamaño de la imagen a 180x180 píxeles. Por último, se utiliza la función img_to_array() para convertir la imagen a un array NumPy.

En la parte 2 del código, se utiliza la función rgb_to_grayscale() de TensorFlow para convertir la imagen a escala de grises. A continuación, se utiliza la función convert_image_dtype() para convertir la imagen a un tipo de datos NumPy de 8 bits. Por último, se utiliza la función save() para guardar la imagen en escala de grises en un archivo.

El código convierte la imagen original a escala de grises de forma correcta. La imagen en escala de grises conserva la información principal de la imagen original, pero pierde los detalles de color.