Código de Python - Convolución con SciPy

Convolución con SciPy

Python

Publicado el 18 de Diciembre del 2023 por Hilario (123 códigos)

347 visualizaciones desde el 18 de Diciembre del 2023

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.

Figure_1

Requerimientos

Este ejercicio fue realizado y ejecutado bajo plataforma Linux, concretamente:Ubuntu 20.04.6 LTS
Fue editado con Sublime text.

Se ha utilizado Python3, que por defecto deberían tener instalado los módulos necesarios, en este caso:
import numpy as np
import matplotlib.pyplot as plt
from scipy.ndimage import convolve

Se ejecuta bajo consola Linux con este comando:
python3 Aula_28_CNN-repaso.py

Es obvio, que se deberá proponer al ejercicio la ruta de la imagen que se haya elegido, en este caso hemos elegido: luna.jpg, en gris. Si se elige una imagen en color, se deberá tener en cuenta que son 3 canales de profundidad para RGB.

El ejercicio imprime para su mejor comprensión los indices de los pixels convolucionados.

V-0.

Publicado el 18 de Diciembre del 2023

gráfica de visualizaciones de la versión: V-0.

348 visualizaciones desde el 18 de Diciembre del 2023

#Aula_28_CNN-repaso.py

#Ejecución:

#python3 Aula_28_CNN-repaso.py

import numpy as np

import matplotlib.pyplot as plt

from scipy.ndimage import convolve

# Función para analizar las características de la imagen

def analyze_image(image):

    print("Características de la imagen:")

    print(f"Dimensiones: {image.shape}")

    print(f"Valor mínimo: {np.min(image)}")

    print(f"Valor máximo: {np.max(image)}")

    print(f"Valor medio: {np.mean(image)}")

# Función para aplicar la convolución con un filtro

def apply_convolution(image, kernel):

    return convolve(image, kernel, mode='constant', cval=0.0)

# Función para aplicar la activación ReLU

def apply_relu(image):

    return np.maximum(image, 0)

# Cargar la imagen en escala de grises desde tu ordenador

image_path = "/home/python/python/luna.jpg"

original_image = plt.imread(image_path)

# Analizar características de la imagen

analyze_image(original_image)

# Imprimir la imagen de entrada

plt.imshow(original_image, cmap='gray')

plt.title('Imagen de entrada')

plt.show()

# Definir un filtro 3x3 adaptado a las características de la imagen

kernel1 = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])

kernel2 = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])

kernel3 = np.array([[1, 0, -1], [1, 0, -1], [1, 0, -1]])

kernel4 = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]])

# Asegurarse de que los filtros tengan la forma correcta

kernel1 = kernel1.reshape((3, 3, 1))

kernel2 = kernel2.reshape((3, 3, 1))

kernel3 = kernel3.reshape((3, 3, 1))

kernel4 = kernel4.reshape((3, 3, 1))

# Aplicar las convoluciones y activaciones

conv1 = apply_convolution(original_image, kernel1)

conv1_relu = apply_relu(conv1)

conv2 = apply_convolution(conv1_relu, kernel2)

conv2_relu = apply_relu(conv2)

conv3 = apply_convolution(conv2_relu, kernel3)

conv3_relu = apply_relu(conv3)

conv4 = apply_convolution(conv3_relu, kernel4)

conv4_relu = apply_relu(conv4)

# Imprimir la imagen después de la última convolución

plt.imshow(conv4_relu, cmap='gray')

plt.title('Imagen después de la última convolución')

plt.show()

# Imprimir los valores de los píxeles y sus índices

print("\nValores de los píxeles después de la última convolución:")

for i in range(conv4_relu.shape[0]):

    for j in range(conv4_relu.shape[1]):

        print(f"Pixel ({i},{j}): {conv4_relu[i, j, 0]}")

Comentarios sobre la versión: V-0. (0)

No hay comentarios

Comentar la versión: V-0.

http://lwp-l.com/s7470

Tags:
scipy

Calculadora

Cálculo total de un pedido

Código de Python - Convolución con SciPy

Requerimientos

V-0.

Comentarios sobre la versión: V-0. (0)

Comentar la versión: V-0.

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.