Códigos Fuente de Python

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.

Este es un programa en el que inicialmente pide que indiques el dinero que llevas. A continuación empieza el proceso de creación de la pizza. Finalmente indica si te llega o no el dinero, y, en caso de que te llegue, indica el total a devolver.

Aula_38_Imagen_Filtrada.py.
+++++++++++++++++++++


En este diminuto ejemplo, hablaremos un poco de la filtración, o suavización de la imagen, antes de someterla a las diversas convoluciones.

La filtración de una imagen antes de aplicar convoluciones o técnicas más avanzadas tiene varias razones. Aquí hay algunas de las razones más comunes:

Reducción de Ruido:

Las imágenes a menudo contienen ruido, que son variaciones no deseadas o errores en los datos. La filtración previa puede ayudar a reducir el ruido y mejorar la calidad de la imagen antes de realizar operaciones más complejas.

Eliminación de Detalles Innecesarios:

En algunas aplicaciones, como la detección de bordes o características, es beneficioso eliminar detalles innecesarios antes de aplicar técnicas más avanzadas. Esto puede mejorar la eficiencia computacional y evitar que se capturen detalles no deseados.
Suavizado de la Imagen:

Filtrar una imagen con técnicas como el filtro Gaussiano puede suavizar la imagen, lo que puede ser útil para preservar características importantes mientras se atenúan detalles finos. Esto puede ser especialmente útil en tareas de procesamiento de imágenes donde se necesita resaltar características más prominentes.

Mejora del Contraste:

Algunos filtros pueden ayudar a mejorar el contraste en la imagen, resaltando las diferencias entre regiones de la imagen. Esto puede ser beneficioso antes de aplicar técnicas que dependan del contraste.
Preprocesamiento para Algoritmos de Aprendizaje Automático:

Cuando se utilizan imágenes como entrada para algoritmos de aprendizaje automático, a menudo se realiza un preprocesamiento para reducir la complejidad y garantizar que el modelo se enfoque en características relevantes.
Mejora de la Estabilidad Numérica:

En algunos casos, filtrar la imagen antes de ciertas operaciones puede mejorar la estabilidad numérica y evitar problemas como la amplificación de ruido numérico.
Es importante señalar que la necesidad de filtrar una imagen antes de la convolución puede depender de la tarea específica y del conjunto de datos. En algunas situaciones, la filtración puede ser crucial, mientras que en otras puede no ser necesaria. La elección del tipo de filtro y sus parámetros dependerá de la naturaleza de la imagen y los requisitos de la tarea que estás abordando.

TIPOS MÁS IMPORTANTES DE SUAVIZACIÓN DE IMAGENES.
--------------------------------------------------------------------------------------------
Existen varios tipos de filtros que se pueden utilizar para procesar imágenes y cada uno tiene aplicaciones específicas. Aquí hay algunos tipos comunes de filtrado de imágenes:

Filtro de Suavizado (Blur):

Promedio (Average): Reemplaza cada píxel por el promedio de los píxeles vecinos.
Gaussiano: Aplica un filtro Gaussiano para suavizar la imagen, reduciendo el ruido y los detalles finos.
Filtro de Realce (Sharpening):

Enfasis (Unsharp Masking): Crea una versión borrosa de la imagen original y la sustrae para resaltar bordes y detalles.
Máscaras de Realce: Utiliza máscaras diseñadas para realzar características específicas.
Filtro de Detección de Bordes:

Sobel, Prewitt, Roberts: Estos filtros se utilizan para detectar bordes en una imagen realzando las diferencias de intensidad.
Operador Laplaciano: Resalta los cambios de intensidad en una imagen.
Filtro de Mediana:

Reemplaza cada píxel por el valor de la mediana de los píxeles vecinos. Es eficaz para eliminar el ruido impulsivo (salt-and-pepper).
Filtro de Bilateral:

Conserva los bordes mientras suaviza la imagen. Es útil para suavizar la imagen sin perder detalles importantes.
Filtro de Adaptación Local de Contraste (CLAHE):

Mejora el contraste local en áreas de la imagen. Útil para resaltar detalles locales.
Filtro de Transformada Wavelet:

Utiliza la transformada wavelet para realizar suavizado o realce de la imagen en diferentes escalas y direcciones.
Filtro de Color:

Corrección de Color: Ajusta el equilibrio de color y mejora la apariencia visual de la imagen.
Espacio de Color YUV: Puede aplicarse para modificar la luminancia y los componentes de color independientemente.
Estos son solo algunos ejemplos, y la elección del filtro dependerá de la tarea específica y los requisitos de procesamiento de la imagen. Además, a menudo es beneficioso realizar ajustes y experimentar con diferentes filtros y parámetros para obtener los resultados deseados.

----------------------------------------------------------------------------------
En este ejemplo, propongo utilizar el sistema que definimos como la aplicación de un filtro Gaussiano.
La campana de Gauss, también conocida como función gaussiana o distribución normal, es una función matemática que describe una forma de campana simétrica. Con esto tratamos de suavizar el contorno o extemos de la imagen.

Aula_68_EP_IA.py
************************************************************************
Proponemos este nuevo ejercicio prosiguiendo con el aprendizaje sobre convoluciones y max pooling, en el tratamiento de una imagen en OpenCV.
Esquemáticamente este ejercicio implementas varios conceptos importantes:

*Carga de la imagen con cv2
*Conversión a escala de grises
*Definición de un kernel de convolución 3x3
*Aplicación de múltiples convoluciones en loops (8 iteraciones)
*Reducción del tamaño de la imagen con max pooling después de cada convolución
*Impresión de los valores de píxeles resultantes
*Visualización de la imagen original vs la imagen procesada
*Adicionalmente, la función que imprime los valores de pixeles con sus índices es muy útil para inspeccionar los cambios paso a paso después de cada iteración.

La salida debe mostrar efectivamente cómo se suaviza y resalta el contraste en la imagen resultado, después de aplicar las capas de convolución y pooling.

En resumen, el código trata de ser sencillo y didáctico, para mostrar el efecto que tiene aplicar una CNN sobre imágenes. En este caso con 8 convoluciones.

El ejercicio permite modificar parametros para observar nuevos valores y matices en la imagen.

El siguiente paso sería, en otro ejercicio, la aplanación de los valores obtenidos para pasar y entregarlos a una red neuronal con capas Completamente Conectadas (Densas):

Esto quiere decir que después de las capas de convolución y agrupación, la red puede incluir capas completamente conectadas. En estas capas, todas las neuronas están conectadas entre sí, para optener el resultado final que pretendemos en el modelo que vayamos a crear.

Eso tendrá cabida, como dije, en un próximo ejercicio.

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

Representación digital de imágenes.
----------------------------------

Con el fin de ir familiarizandonos con las redes convolucionales. Proponemos este otro ejercicio: Aula-38-Define-Imagen-CNN.py.

En este programa, definimos una imagen de entrada en color (3 canales).
Mediante np.array.
Por otro lado definimos el filtro, o kernel, de la convolución, por medio de otro array.

Realizamos la convolución usando la función convolve de SciPy.
Al final mostramos la imagen original y la imagen convolucionada.

Básicamente en este ejercicio muestra el contexto de la representación digital de imágenes, cada píxel tiene un valor numérico que indica su color. Estos valores suelen estar en forma de un array bidimensional, también conocido como matriz.

En una imagen en escala de grises, cada píxel puede tener un valor numérico que representa la intensidad de gris en esa posición. Los valores comúnmente van desde 0 (negro) hasta 255 (blanco) en una imagen de 8 bits.

En una imagen en color, se utilizan varios canales de color (como rojo, verde y azul en el modelo RGB). Cada canal tiene su propia matriz de píxeles y, cuando se combinan, forman el color de cada píxel. Los valores numéricos en este caso también suelen estar en el rango de 0 a 255.

Por ejemplo, si tienes una imagen de 100x100 píxeles en escala de grises, podrías representarla como una matriz de 100x100, donde cada elemento de la matriz contiene un valor numérico que representa la intensidad de gris en esa posición específica.

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

Pequeño pero util generador de contraseñas hecho en Python3

El presente programa se encarga de aplicar filtros sobre los fotogramas de un archivo de video empleando diferentes funciones. El programa realiza el filtrado frame a frame para a continuación generar un nuevo video con la secuencia de frames procesados (aplicando el frame rate del vídeo original). También usa el software "ffmpeg" para copiar el audio del vídeo original y añadirlo al vídeo resultante.

USO: Primeramente seleccionaremos el vídeo a filtrar mediante el botón "SEARCH". Una vez seleccionado iniciaremos el proceso con "START FILTERING" con el que empezaremos seleccionando la ubicación del nuevo vídeo, para a continuación iniciar el proceso (NOTA: La ruta del directorio de destino no deberá contener espacios en blanco). El proceso de filtrado podrá ser cancelado medinate el botón "CANCEL".
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.

import matplotlib.pyplot as plt
import numpy as np

n_values = np.arange(1, 301, 1)
a_values = (5 - 3 * n_values**2) / (1 - 2 * n_values**2)

plt.plot(n_values, a_values, label=r'$a_n = \frac{5-3n^2}{1-2n^2}$')
plt.xlabel('n')
plt.ylabel('a_n')
plt.title('Gráfico de la función $a_n$')
plt.legend()
plt.show()