Buscar un código de Python

********************************************************************************************************************
Propongo el ejercicio: Aula_18_Feb_24.py, realizado en python. En el mismo trato de formular una red convolucional, lo más sencilla posible, con el fin ver el desarrollo de nueve capas convolucionales. Tratando de indagar y visualizar la salida después de cada capa utilizando un bucle. Por cada salto de bucle iremos viendo los valores correspondientes de la activación, al mismo tiempo que visualizaremos el resultado de la imagen, que será un tanto incongruente ya que sólo se trata de ver su funcionamiento.

A continuación describo las particularidades de este corto código:
*************************************************************************
Como se aprecia en las llamadas iniciales de importación de módulos, utiliza TensorFlow y Keras para crear un modelo de red neuronal convolucional (CNN) y visualiza las salidas de cada capa convolucional para una imagen de entrada aleatoria. Aquí está la descripción del código:

Importar bibliotecas:
------------------------------
numpy: Para trabajar con matrices y generar imágenes aleatorias.
matplotlib.pyplot: Para visualizar las salidas de cada capa convolucional.
tensorflow.keras.models.Sequential y tensorflow.keras.layers.Conv2D: Para construir la arquitectura del modelo CNN.

Crear el modelo:
---------------------
Se crea un modelo secuencial (Sequential) que representa la arquitectura de la red.

Agregar capas convolucionales:
------------------------------------------------
Se agregan varias capas convolucionales al modelo con diferentes números de filtros y funciones de activación ReLU.

Obtener las salidas de cada capa convolucional:
-----------------------------------------------------------------------
Se crea un modelo de visualización (visualization_model) que toma la entrada del modelo original y produce las salidas de cada capa convolucional.

Generar una imagen de entrada aleatoria:
-----------------------------------------------------------
Se crea una imagen de entrada ficticia con dimensiones (1, 600, 506, 3).
Si se quiere se podría hacer con carácter fijo en vez de aleatorio.

Obtener las activaciones de cada capa:
--------------------------------------------------------
Se obtienen las activaciones de cada capa convolucional para la imagen de entrada utilizando el modelo de visualización.

Visualizar las salidas de cada capa:
----------------------------------------------
Se itera sobre las activaciones y se muestra la salida de cada capa convolucional. Si la salida tiene cuatro dimensiones, se aplanan y visualizan las activaciones en escala de grises.
Como indiqué, este código es útil para entender cómo evoluciona la representación de la imagen a medida que pasa a través de las capas convolucionales de la red. Cada visualización muestra las activaciones de una capa particular, lo que puede ayudar a interpretar cómo la red extrae características en diferentes niveles de abstracción.

******************************************************************************************************************
Este código fue realizado bajo plataforma linux, con Ubuntu 20.04.6 LTS.
Fue editado con Sublime text.
Se deberá tener en cuenta que el sistema tendrá que tener cargado para las importaciones
los siguientes módulos:

import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Conv2D

La Versión de Python en mi ordenador es: Python 3.8.10.
****************************************************************************************
#Ejecución:python3 Aula_18_Feb_24.py

Los kernels Sobel son filtros utilizados comúnmente en procesamiento de imágenes para realizar operaciones de convolución, especialmente en el contexto de detección de bordes. Estos filtros están diseñados para resaltar cambios rápidos en la intensidad de los píxeles en una imagen, lo que generalmente indica la presencia de bordes.

El operador Sobel consiste en dos kernels, uno para la detección de cambios horizontales y otro para cambios verticales. Estos kernels son matrices pequeñas que se aplican a la imagen mediante la operación de convolución. Los kernels Sobel comúnmente utilizados son los siguientes:

Kernel Sobel para detección de bordes horizontales (kernel_sobel_x):

[ -1, 0, 1]
[ -2, 0, 2]
[ -1, 0, 1]

Kernel Sobel para detección de bordes verticales (kernel_sobel_y):

[ 1, 2, 1]
[ 0, 0, 0]
[-1, -2, -1]

La operación de convolución implica deslizar estos kernels sobre la imagen original, multiplicando los valores de los píxeles en la región correspondiente del kernel y sumándolos para obtener un nuevo valor en la posición central. Este proceso se repite para cada píxel en la imagen, generando así dos nuevas imágenes filtradas: una resaltando cambios horizontales y otra resaltando cambios verticales.

La magnitud de los bordes se calcula combinando las respuestas horizontales y verticales mediante una fórmula de magnitud Euclidiana.

Este resultado proporciona una representación de la intensidad de los bordes en la imagen original, lo cual es útil para tareas como detección de contornos. En el código que compartiste anteriormente, estos kernels Sobel se utilizan para realizar la detección de bordes en la imagen cargada.


Este programa en Python: python3 Aula_28_bordes_CNN.py, realiza la detección de bordes en una imagen utilizando el operador Sobel. Aquí tienes una explicación paso a paso:

Cargar la imagen:
Utiliza la biblioteca OpenCV (cv2) para cargar una imagen desde la ruta "/home/margarito/python/tulipanes.jpeg".
Verifica si la carga de la imagen fue exitosa.

Convertir la imagen a formato RGB:
Utiliza la función cv2.cvtColor para convertir la imagen cargada (en formato BGR) a formato RGB.
Muestra la imagen original utilizando la biblioteca matplotlib.

Definir los kernels Sobel:
Define dos kernels Sobel, uno para la detección de bordes horizontales (kernel_sobel_x) y otro para la detección de bordes verticales (kernel_sobel_y).

Aplicar los filtros Sobel:
Utiliza la función cv2.filter2D para aplicar los filtros Sobel a la imagen original, obteniendo dos imágenes resultantes (imagen_bordes_x e imagen_bordes_y), que representan los bordes horizontales y verticales, respectivamente.

Calcular la magnitud de los bordes:
Calcula la magnitud de los bordes combinando las imágenes resultantes de los filtros Sobel mediante la fórmula de la magnitud Euclidiana.

Verificar si hay datos válidos en la matriz antes de normalizar:
Antes de normalizar la magnitud de los bordes, verifica si hay datos válidos en la matriz utilizando np.any.

Convertir a tipo de datos float32 antes de normalizar:
Convierte la matriz de magnitud de bordes a tipo de datos float32. Esto es necesario para evitar problemas de normalización con tipos de datos no compatibles.

Normalizar la imagen:
Utiliza el método de normalización para escalar los valores de la magnitud de los bordes al rango [0, 1]. Esto es importante para visualizar correctamente la imagen de bordes.

Mostrar la imagen con bordes:
Utiliza plt.imshow para mostrar la imagen resultante de la detección de bordes en escala de grises.
Muestra un título indicando que se ha aplicado el operador Sobel para la detección de bordes.

Manejar casos donde la matriz de magnitud de bordes está vacía:
Si la matriz de magnitud de bordes está vacía (todos los elementos son cero), imprime un mensaje indicando que la matriz está vacía o no contiene datos válidos.

En resumen, este programa carga una imagen, aplica el operador Sobel para detectar bordes y muestra la imagen resultante de la detección de bordes. Además, maneja casos donde la matriz de magnitud de bordes no contiene datos válidos.

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







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

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

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

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.