¿Cómo normalizar imágenes en PyTorch?

La transformación de imágenes es un proceso para cambiar los valores originales de los píxeles de la imagen a un conjunto de valores nuevos. Un tipo de transformación que hacemos en las imágenes es transformar una imagen en un tensor PyTorch. Cuando una imagen se transforma en un tensor PyTorch, los valores de píxel se escalan entre 0,0 y 1,0. En PyTorch, esta transformación se puede realizar mediante torchvision.transforms.ToTensor() . Convierte la imagen PIL con un rango de píxeles de [0, 255] en un PyTorch FloatTensor de forma (C, H, W) con un rango [0.0, 1.0]. 

La normalización de imágenes es una muy buena práctica cuando trabajamos con redes neuronales profundas. Normalizar las imágenes significa transformar las imágenes en valores tales que la media y la desviación estándar de la imagen se conviertan en 0,0 y 1,0 respectivamente. Para hacer esto, primero se resta la media del canal de cada canal de entrada y luego el resultado se divide por la desviación estándar del canal. 

output[channel] = (input[channel] - mean[channel]) / std[channel]

¿Por qué deberíamos normalizar las imágenes?

La normalización ayuda a obtener datos dentro de un rango y reduce la asimetría, lo que ayuda a aprender más rápido y mejor. La normalización también puede abordar los problemas de gradientes decrecientes y explosivos.

Normalización de imágenes en PyTorch

La normalización en PyTorch se realiza mediante torchvision.transforms.Normalize() . Esto normaliza la imagen del tensor con media y desviación estándar. 

Sintaxis: torchvision.transforms.Normalize()

Parámetro:

• media: Secuencia de medias para cada canal.
• std: Secuencia de desviaciones estándar para cada canal.
• inplace: Bool para realizar esta operación en el lugar.

Devuelve: Imagen de tensor normalizada.

Acercarse:

Realizaremos los siguientes pasos mientras normalizamos imágenes en PyTorch:

• Cargue y visualice la imagen y trace los valores de píxeles.
• Transforme la imagen en tensores usando torchvision.transforms.ToTensor()
• Calcular la media y la desviación estándar (std)
• Normalice la imagen usando torchvision.transforms.Normalize() .
• Visualice la imagen normalizada.
• Calcule la media y la estándar después de normalizar y verifíquelos.

Ejemplo: cargando imagen

Imagen de entrada:

Cargue la imagen de entrada anterior usando PIL. Estamos usando la imagen Koala.jpg de arriba en nuestro programa. Y trace los valores de píxeles de la imagen.

# python code to load and visualize
# an image
 
# import necessary libraries
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
 
# load the image
img_path = 'Koala.jpg'
img = Image.open(img_path)
 
# convert PIL image to numpy array
img_np = np.array(img)
 
# plot the pixel values
plt.hist(img_np.ravel(), bins=50, density=True)
plt.xlabel("pixel values")
plt.ylabel("relative frequency")
plt.title("distribution of pixels")

Producción:

Encontramos que los valores de píxel de la imagen RGB oscilan entre 0 y 255.

Transformar imágenes a tensores usando torchvision.transforms.ToTensor()

Convierta la imagen PIL en un tensor PyTorch usando ToTensor() y trace los valores de píxel de esta imagen de tensor. Definimos nuestra función de transformación para convertir la imagen PIL en una imagen de tensor PyTorch.

# Python code for converting PIL Image to
# PyTorch Tensor image and plot pixel values
 
# import necessary libraries
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
 
# define custom transform function
transform = transforms.Compose([
    transforms.ToTensor()
])
 
# transform the pIL image to tensor
# image
img_tr = transform(img)
 
# Convert tensor image to numpy array
img_np = np.array(img_tr)
 
# plot the pixel values
plt.hist(img_np.ravel(), bins=50, density=True)
plt.xlabel("pixel values")
plt.ylabel("relative frequency")
plt.title("distribution of pixels")

Producción:

Encontramos que los valores de píxel de la imagen de tensor oscilan entre 0,0 y 1,0. Notamos que las distribuciones de píxeles de RBG y la imagen de tensor se ven iguales pero difieren en el rango de valores de píxeles.

Cálculo de la media y la desviación estándar (std)

Calculamos la media y el estándar de la imagen. 

# Python code to calculate mean and std
# of image
 
# get tensor image
img_tr = transform(img)
 
# calculate mean and std
mean, std = img_tr.mean([1,2]), img_tr.std([1,2])
 
# print mean and std
print("mean and std before normalize:")
print("Mean of the image:", mean)
print("Std of the image:", std)

Producción:

Aquí calculamos la media y el estándar de la imagen para los tres canales, rojo, verde y azul. Estos valores son antes de la normalización. Usaremos estos valores para normalizar la imagen. Compararemos estos valores con los posteriores a la normalización.

Normalizando las imágenes usando torchvision.transforms.Normalize()

Para normalizar la imagen, aquí usamos la media y el estándar calculados anteriormente de la imagen. También podemos usar la media y el estándar del conjunto de datos de ImageNet si la imagen es similar a las imágenes de ImageNet. La media y el estándar de ImageNet son: promedio = [0,485, 0,456, 0,406] y estándar = [0,229, 0,224, 0,225]. Si la imagen no es similar a ImageNet, como las imágenes médicas, siempre se recomienda calcular la media y el estándar del conjunto de datos y usarlos para normalizar las imágenes.

# python code to normalize the image
 
 
from torchvision import transforms
 
# define custom transform
# here we are using our calculated
# mean & std
transform_norm = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean, std)
])
 
# get normalized image
img_normalized = transform_norm(img)
 
# convert normalized image to numpy
# array
img_np = np.array(img_normalized)
 
# plot the pixel values
plt.hist(img_np.ravel(), bins=50, density=True)
plt.xlabel("pixel values")
plt.ylabel("relative frequency")
plt.title("distribution of pixels")

Producción:

Hemos normalizado la imagen con nuestra media y estándar calculados. El resultado anterior muestra la distribución de los valores de píxeles de la imagen normalizada. Podemos notar la diferencia entre las distribuciones de píxeles de la imagen de tensor (antes de normalizar) y de la imagen normalizada. 

Visualización de la imagen normalizada

Ahora visualiza la imagen normalizada.

# Python Code to visualize normalized image
 
# get normalized image
img_normalized = transform_norm(img)
 
# convert this image to numpy array
img_normalized = np.array(img_normalized)
 
# transpose from shape of (3,,) to shape of (,,3)
img_normalized = img_normalized.transpose(1, 2, 0)
 
# display the normalized image
plt.imshow(img_normalized)
plt.xticks([])
plt.yticks([])

Producción:

Hay claras diferencias, podemos notar, entre la imagen de entrada y la imagen normalizada.

Cálculo de la media y estándar después de normalizar

Calculamos la media y el estándar nuevamente para imágenes/conjunto de datos normalizados. Ahora, después de la normalización, la media debería ser 0,0 y la estándar 1,0.

# Python code to calculate mean and std
# of normalized image
 
# get normalized image
img_nor = transform_norm(img)
 
# cailculate mean and std
mean, std = img_nor.mean([1,2]), img_nor.std([1,2])
 
# print mean and std
print("Mean and Std of normalized image:")
print("Mean of the image:", mean)
print("Std of the image:", std)

Producción:

Aquí encontramos que después de la normalización los valores de media y estándar son 0.0 y 1.0 respectivamente. Esto verifica que después de normalizar la media y la desviación estándar de la imagen se vuelven 0 y 1 respectivamente.