Código de Python - Capa convolucional.

Imágen de perfil

Capa convolucional.gráfica de visualizaciones


Python

Publicado el 12 de Diciembre del 2023 por Hilario (124 códigos)
207 visualizaciones desde el 12 de Diciembre del 2023
#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.






1
Figure_1

Requerimientos

El ejercicio Aula_28_Convolucion.py, fue realizado en una plataforma Linux, concretamente Ubuntu 20.04.6 LTS.
Fue editado con Sublime text.

Tener en cuenta que se deberán tener cargadas las librerías necesarias, en este caso:
import numpy as np
from scipy.signal import convolve2d
from PIL import Image
import matplotlib.pyplot as plt

También, por supuesto se deberá cambiar la ruta de la imagen.

Ejecución del programa.
python3 Aula_28_Convolucion.py

V-0

Publicado el 12 de Diciembre del 2023gráfica de visualizaciones de la versión: V-0
208 visualizaciones desde el 12 de Diciembre del 2023
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#Aula_28_Convolucion.py
#Ejecutar:python3 Aula_28_Convolucion.py
 
import numpy as np
from scipy.signal import convolve2d
from PIL import Image
import matplotlib.pyplot as plt
 
# Ruta de la imagen original
imagen_path = "/home/margarito/python/1.jpeg"  # Reemplaza con la ruta de tu imagen
 
# Cargar la imagen
imagen = Image.open(imagen_path)
 
# Convertir la imagen a escala de grises
imagen_gris = imagen.convert('L')
 
# Convertir la imagen a un array de numpy
imagen_array = np.array(imagen_gris)
 
# Definir el kernel
kernel = np.array([[1, 2, 3], [3, 1, 1], [4, 1, 2]])
 
# Aplicar la convolución
imagen_convolucionada = convolve2d(imagen_array, kernel, mode='same', boundary='symm')
 
# Normalizar los valores para mantener la imagen en el rango 0-255
imagen_convolucionada = np.clip(imagen_convolucionada, 0, 255).astype(np.uint8)
 
def imprimir_pixels(imagen_path):
    # Cargar la imagen
    imagen = Image.open(imagen_path)
 
    # Obtener los datos de píxeles
    datos_pixels = list(imagen.getdata())
 
    # Imprimir los valores numéricos de los píxeles
    for i, pixel in enumerate(datos_pixels):
        print(f"Píxel {i + 1}: {pixel}")
 
 
# Visualizar la imagen original y la imagen después de la convolución
fig, axs = plt.subplots(1, 2, figsize=(12, 6))
 
axs[0].imshow(imagen, cmap='gray')
axs[0].set_title('Imagen Original')
axs[0].axis('off')
 
axs[1].imshow(imagen_array, cmap='gray')
axs[1].set_title('Imagen después de la convolución')
axs[1].axis('off')
 
plt.show()
# Llamar a la función para imprimir los píxeles
ruta_imagen = "/home/margarito/python/1.jpeg"  # Reemplaza con la ruta de tu imagen
imprimir_pixels(ruta_imagen)



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


No hay comentarios
 

Comentar la versión: V-0

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

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

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad

http://lwp-l.com/s7465