El kernel en acción

El kernel de bordes horizontales puede quedar como

img_new_horizontal = nd.convolve(img_gray,kernel.T)

Con el kernel original que definimos en la clase

Por si se preguntaban qué pasa con un Kernel = 0’s

Probando distintos Kernels:

kernel = np.array([[ 0, 0, 0],
[ 0, 0, 0],
[ 0, 0, 0]])

kernel = np.array([[ 1, 0, 1],
[ 0, 0, 0],
[ 1, 0, 1]])

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

Lo convertí en función para ir probando varios kernels más fácil.

def test_kernels(img: np.ndarray, kernel: np.ndarray):
    img_new = nd.convolve(img_gray, kernel)
    fig, axes = plt.subplots(1,2, figsize=(15,10))
    axes[0].imshow(img, cmap=plt.cm.gray)
    axes[0].set_title('Original')
    axes[0].axis('off')

    axes[1].imshow(img_new, cmap=plt.cm.gray)
    axes[1].set_title('New')
    axes[1].axis('off')

test_kernels(img_gray, kernel)

# test con matriz identidad
test_kernels(img_gray, [[1,0,0],[0,1,0],[0,0,1]])

Ustedes sabían que si usan este kernel pueden trasladar la imagen? 😆

s =  55 # kernel's size
kernel= np.zeros((s, s))
kernel[s-1][s//2] = 1

Jugando y creando nuevos kernel

Kernel para bordes verticales:

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

<#kernel, para bordes verticales

kernel = np.array([[-1, 0, 1],
                   [-1, 0, 1],
                   [-1, 0, 1]])
#utilizo la traspuesta de kernel
img_new = nd.convolve(img_gray, kernel.T)
fig, axes = plt.subplots(1,2, figsize=(15,10))
axes[0].imshow(img_gray ,cmap=plt.cm.gray)
axes[0].set_title('Original')
axes[0].axis('off')

axes[1].imshow(img_new ,cmap=plt.cm.gray)
axes[1].set_title('Convolucion')
axes[1].axis('off')
import cv2
cv2.imwrite('kernel.png',img_new)> 

Probando el kernel para bordes horizontales

Código:

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

img_2 = nd.convolve(img_gray, kernel_2)

fig, axes = plt.subplots(1,2, figsize = (15,10))
axes[0].imshow(img_gray, cmap=plt.cm.gray)
axes[0].set_title('Original')
axes[0].axis('off')

axes[1].imshow(img_2, cmap=plt.cm.gray)
axes[1].set_title('Convolution')
axes[1].axis('off')

Hola comunidad! Les comparto las pruebas que yo realice 


El \*\*kernel\*\* es un concepto clave en el campo de las redes neuronales, particularmente en las \*\*redes neuronales convolucionales (CNNs)\*\*. En este contexto, un kernel (o filtro) es una matriz pequeña de números que se desplaza sobre una imagen o matriz de entrada para realizar una operación de convolución. Este proceso permite extraer características importantes como bordes, texturas, o patrones dentro de los datos. \### Conceptos clave: 1\. \*\*Kernel (Filtro)\*\*: \- Es una pequeña matriz de pesos que se aplica a la entrada (como una imagen) a través de una operación de convolución. Normalmente, los kernels en las CNNs tienen un tamaño pequeño, como 3x3 o 5x5, y se inicializan con valores aleatorios que luego se ajustan durante el entrenamiento. 2\. \*\*Operación de Convolución\*\*: \- Durante la convolución, el kernel se desliza sobre la imagen de entrada y realiza una multiplicación punto a punto entre los elementos del kernel y una sección correspondiente de la entrada, generando una nueva matriz (mapa de características) que representa las características detectadas en la imagen. 3\. \*\*Aprendizaje de Características\*\*: \- En una CNN, los kernels son aprendidos automáticamente durante el entrenamiento del modelo a través de la retropropagación, ajustando los pesos para detectar características relevantes. 4\. \*\*Stride y Padding\*\*: \- El \*stride\* es el número de píxeles que el kernel se desplaza en cada paso. Un \*stride\* mayor reduce el tamaño del mapa de características. \- El \*padding\* añade un borde de píxeles a la entrada, permitiendo que el kernel procese los píxeles de los bordes de la imagen. \### Ejemplo básico de convolución con un kernel 3x3 Supongamos que tenemos una imagen en escala de grises de 5x5 píxeles y un kernel de 3x3 que detecta bordes verticales. \#### Imagen de entrada (5x5 píxeles): ``` \[1, 2, 3, 0, 1] \[4, 5, 6, 2, 1] \[7, 8, 9, 1, 2] \[1, 3, 2, 1, 3] \[2, 4, 1, 3, 0] ``` \#### Kernel de detección de bordes (3x3): ``` \[-1, 0, 1] \[-1, 0, 1] \[-1, 0, 1] ``` Este kernel se desliza sobre la imagen, y en cada paso realiza una multiplicación entre los valores correspondientes de la imagen y el kernel, sumando los productos para obtener un valor para la posición actual del mapa de características. \#### Ejemplo de operación de convolución en Python: ```python import numpy as np from scipy.signal import convolve2d import matplotlib.pyplot as plt \# Imagen de entrada (5x5) image = np.array(\[ \[1, 2, 3, 0, 1], \[4, 5, 6, 2, 1], \[7, 8, 9, 1, 2], \[1, 3, 2, 1, 3], \[2, 4, 1, 3, 0] ]) \# Kernel de detección de bordes (3x3) kernel = np.array(\[ \[-1, 0, 1], \[-1, 0, 1], \[-1, 0, 1] ]) \# Aplicar la convolución output = convolve2d(image, kernel, mode='valid') \# Mostrar la imagen de entrada y el resultado de la convolución fig, ax = plt.subplots(1, 2, figsize=(10, 5)) ax\[0].imshow(image, cmap='gray') ax\[0].set\_title('Imagen de entrada') ax\[1].imshow(output, cmap='gray') ax\[1].set\_title('Resultado de la convolución') plt.show() ``` \### Explicación del código: 1\. \*\*Imagen\*\*: Se define una matriz 2D de 5x5 para representar una imagen en escala de grises. 2\. \*\*Kernel\*\*: El filtro de detección de bordes es una matriz de 3x3 diseñada para detectar bordes verticales. 3\. \*\*Convolución\*\*: Usamos la función `convolve2d` de `scipy.signal` para aplicar la operación de convolución entre la imagen y el kernel. 4\. \*\*Visualización\*\*: Usamos `matplotlib` para mostrar la imagen de entrada y el resultado del proceso de convolución. \### Salida: La operación de convolución genera un nuevo mapa de características que resalta los bordes verticales en la imagen de entrada. \### Importancia del kernel en redes convolucionales: \- Los \*\*kernels\*\* permiten que las redes neuronales convolucionales sean especialmente eficaces en tareas de \*\*visión por computadora\*\* como el reconocimiento de imágenes. \- A través de múltiples capas convolucionales, las CNN pueden aprender a detectar características simples como bordes y texturas en las primeras capas, y características más complejas en las capas posteriores. Este enfoque es uno de los motivos por los que las CNN son tan efectivas para el procesamiento de imágenes y han revolucionado campos como la visión por computadora, la segmentación de imágenes y el reconocimiento facial.

 

Creando bordes horizontales  Haciendo la imagen mas borrosa 

Este fue aplicando el outline kernel 

wau, no se si el profesor es muy bueno o que pero hasta el momento he entendido todo muy bien.

Una cosa, podrias hacer una actualizacion al curso de despliegues de machine learning , es que me gustaria ver como tu lo explicas, muchas gracias.

kernel horizontal :  kernel con valores = 0: 

Este fue el kernel que usé para resaltar las caracteristicas horizontales

Este fue el resutlado del ejercicio planteado

Kernel para mostrar lineas horizontales

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