Códigos Fuente de Python

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.

Aplicación para codificar y decodificar mensajes de texto en imágenes.

La imagen se selecciona mediante el botón "SEARCH".
En el modo "Encode" el texto a ocultar se introduce en el espacio superior. (el programa generará un nuevo archivo de imagen cuyo nombre tendrá el prefijo "encoded_" delante del título del archivo original.
En el modo "Decode" el texto oculto se muestra en el espacio superior.

PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.


Repositorio en GitHub:
https://github.com/antonioam82/Steganography

Programa para generar contraseñas de forma aleatoria, de hasta 50 caracteres. Cuenta con un campo "LENGTH" para especificar la longitud de la contraseña, un campo "MIN LOWERCASE" para especificar el número mínimo de caracteres en minúsculas, un campo "MIN UPPERCASE" para el número mínimo de caracteres en mayúsculas y un campo "MIN NUMBERS" para especificar el número mínimo de caracteres numéricos.
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.

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







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

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

Nueva versión del Juego de la Serpiente, en la que se ha incluido sonido y 3 archivos de audio (incluidos en la carpeta). Para usar el programa adecuadamente, simplemente hay que descomprimir la carpeta en la que se encuentra.
BOTONES:
Mover serpiente: Botónes de dirección
Pause y reanudar partida pausada : Barra espaciadora.
Finalizar partida: tecla "q"
PARA CUALQUIER PROBLEMA, NO DUDEN EN COMUNICÁRMELO.

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