Mostrar los tags: c

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

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(

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

Exponemos aquí un ejemplo de redes neuronales convolucionales CNN,
basadas en transferencia de estilo. Partiendo de una imagen original, y otra imagen que dará
la forma del estilo(en nuestro caso, un cuadro de Picaso), construiremos otra, basada en las dos anteriores.

El programa que citamos aquí está basado en en un ejemplo
del blog RUBENJROMO
https://rubenjromo.com/
Modificados algunos parámetros.
Editado y ejecutado en GoogleColab.
Archivos de muestra, alojados en DRIVE.
https://drive.google.com/

Modelo vgg19-dcbb9e9d.pth bajado de:
"https://download.pytorch.org/models/vgg19-dcbb9e9d.pth

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

Las redes neuronales convolucionales (CNN) y la transferencia de estilo son conceptos distintos en el campo del aprendizaje profundo, pero a veces se combinan para lograr resultados interesantes en el procesamiento de imágenes. Aquí hay una breve descripción de cada uno:

Redes Neuronales Convolucionales (CNN):

Las CNN son un tipo de arquitectura de red neuronal diseñada específicamente para procesar datos de rejilla, como imágenes. Utilizan capas de convolución para extraer características relevantes de la imagen de entrada.
La convolución implica el uso de filtros o kernels que se deslizan sobre la imagen para realizar operaciones locales, lo que permite detectar patrones específicos, como bordes, texturas o formas.
Están compuestas por capas convolucionales, capas de activación (como la ReLU), capas de agrupación (pooling) y capas completamente conectadas.
Transferencia de Estilo:

La transferencia de estilo es una técnica que utiliza redes neuronales para combinar el contenido de una imagen con el estilo de otra imagen de manera creativa.
Se basa en la idea de separar el contenido y el estilo de una imagen. La información de contenido se extrae de una imagen de referencia, mientras que el estilo se toma de otra imagen.
La red neuronal intenta generar una nueva imagen que conserve el contenido de una imagen de entrada pero adopte el estilo de otra imagen de referencia.
Cuando se combinan estas dos ideas, se puede aplicar la transferencia de estilo utilizando una CNN. La idea es utilizar una red preentrenada, como VGG16 o VGG19, para extraer tanto el contenido como el estilo de las imágenes. Luego, se optimiza una nueva imagen para que coincida con el contenido de una imagen de entrada y el estilo de otra imagen de referencia. Este proceso permite crear imágenes que fusionan el contenido de una imagen con el estilo artístico de otra.

En resumen, las CNN son arquitecturas de redes neuronales diseñadas para el procesamiento de imágenes, mientras que la transferencia de estilo es una técnica que utiliza redes neuronales para combinar el contenido y el estilo de diferentes imágenes. Al aplicar la transferencia de estilo con una CNN, se pueden lograr resultados visualmente atractivos y creativos.

Programa para reproducir archivos de audio que incorpora la posibilidad de crear una lista de favoritos.
El programa necesita de un archivo "json" que se generará al ejecutarse por primera vez.
Esta versión incorpora la posibilidad de reproducir secuencialmente la lista de favoritos, para ello se usará el botón "PLAY ALL" (dicha reproducción se podrá finalizar igualmente con el botón "STOP").
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.

Proponemos el sencillo ejercicio: Aula_28_CNN-repaso.py, con el fin de realizar un proceso de convolución, sobre una imagen en color gris, por lo que sólo tendremos un canal de profundidad en la misma.

Según le hemos pedido al programa, la imagen tiene las siguientes características:
Características de la imagen:
Dimensiones: (431, 770, 1)
Valor mínimo: 0
Valor máximo: 249
Valor medio: 23.887129498498407.

La particularidad de este ejercicio, es que utilizamos el modulo scipy, creado inicialmente sobre el año 2000, actualizado en revisiones, y aún bastante utilizado.

Las caracteristicas más importantes de este módulo son las siguientes:
***************************************************************************************
SciPy es una biblioteca de código abierto en Python que se utiliza para realizar operaciones científicas y técnicas. Está construida sobre NumPy y proporciona funcionalidades adicionales para la manipulación de datos y el análisis estadístico. El módulo SciPy se divide en varios submódulos, cada uno de los cuales se centra en un área específica de la computación científica. Algunos de los submódulos más importantes son:

scipy.cluster: Algoritmos para clustering (agrupamiento) de datos.

scipy.constants: Constantes físicas y matemáticas.

scipy.fftpack: Transformada rápida de Fourier.

scipy.integrate: Rutinas de integración numérica.

scipy.interpolate: Interpolación de datos y construcción de splines.

scipy.io: Herramientas para la entrada y salida de datos.

scipy.linalg: Álgebra lineal.

scipy.ndimage: Procesamiento de imágenes n-dimensionales.

scipy.odr: Regresión ortogonal.

scipy.optimize: Optimización de funciones.

scipy.signal: Procesamiento de señales.
-------------------------------------------------------------

scipy.sparse: Estructuras de datos y algoritmos para matrices dispersas.

scipy.spatial: Estructuras y algoritmos espaciales.

scipy.special: Funciones matemáticas especiales.

scipy.stats: Estadísticas y distribuciones de probabilidad.


En nuestro caso que nos aplica, nos fijaremos en El módulo scipy.signal, que proporciona una función llamada convolve que se utiliza para realizar convoluciones entre dos secuencias. La convolución es una operación matemática que combina dos conjuntos de datos para producir un tercer conjunto de datos. En el contexto de procesamiento de señales, la convolución se utiliza, por ejemplo, para suavizar señales, encontrar la respuesta de un sistema a una entrada, o para aplicar filtros.

En la actualidad SciPy sigue siendo una biblioteca muy utilizada en la comunidad científica y de ingeniería en Python. Proporciona herramientas esenciales para tareas relacionadas con la computación científica, como álgebra lineal, optimización, procesamiento de señales, interpolación, integración numérica, estadísticas y más.

La biblioteca SciPy se mantiene y actualiza regularmente para incluir nuevas funcionalidades, mejoras de rendimiento y correcciones de errores. Es una parte integral del ecosistema científico de Python junto con NumPy, Matplotlib y otras bibliotecas relacionadas.

#Aula_28_Convolucion.py
#Ejecutar:
python3 Aula_28_Convolucion.py

Propongo un sencillo ejercicio, sobre el funcionamiento de una capa convolucional (CNN).
Partimos de una imagen, y realizamos una simple convolucion, para apreciar su funcionamiento.
Para hacer más intuitivo el programa le mandamos imprimir los valores de los pixel de la imagen original, con los indices correspondientes.

A continuación describimos esquemáticamente que es una convolución.

La convolución es una operación matemática que combina dos conjuntos de datos para producir un tercer conjunto


Básicamente la convolución en una red neuronal convolucional (CNN) es una operación matemática que se utiliza para procesar imágenes y extraer características importantes. Es esencialmente una forma de explorar la imagen para buscar patrones locales. Aquí hay una explicación simple:

Imagen de Entrada, (en nuestro caso 1.jpeg):

La imagen de entrada es una matriz bidimensional de píxeles, donde cada píxel tiene un valor que representa la intensidad del color en ese punto.
Filtro o Kernel:

La convolución utiliza un filtro (también llamado kernel), que es una pequeña matriz de números.
Este filtro se desliza a lo largo de la imagen original, multiplicando sus valores con los valores correspondientes de la región de la imagen donde se encuentra.
Operación de Convolución:

Para cada posición del filtro, los valores se multiplican y suman para producir un solo valor en la nueva imagen, llamada mapa de características.
Este proceso se repite para cada posición del filtro, generando así todo el mapa de características.

Mapa de Características:

El resultado de la convolución es un mapa de características, que resalta patrones específicos aprendidos por el filtro.
Los primeros filtros en una red suelen capturar detalles simples como bordes, y a medida que avanzas en las capas, los filtros tienden a aprender patrones más complejos y abstractos.

Capas Convolucionales:

Las CNN suelen tener múltiples capas convolucionales apiladas, donde cada capa utiliza varios filtros para aprender diferentes características de la imagen.
La salida de una capa convolucional se utiliza como entrada para la siguiente, permitiendo que la red aprenda representaciones jerárquicas de las características.
En resumen, la convolución en una red convolucional es un proceso clave para detectar y resaltar patrones en una imagen. Es una técnica poderosa para el procesamiento de imágenes y ha demostrado ser muy exitosa en tareas como reconocimiento de objetos, clasificación de imágenes y segmentación de imágenes.