Visualizando imágenes con aumentado de datos

Data augmentation

Estuve leyendo la documentación de albumentations y conseguí las siguientes transfomaciones:

El código es el siguiente:

# Definición de transformaciones:
transforms = A.Compose([
    A.HorizontalFlip(p=0.3),
    A.RandomBrightnessContrast(p=0.3),
    A.ChannelShuffle(p=0.3),
    A.CLAHE(p=0.3),
    A.ColorJitter(brightness=(0, 1), contrast=(0, 1), saturation=(0, 1), hue=(-0.3, 0.3), p=0.3),
    A.FancyPCA(p=0.3, alpha=0.2, always_apply=False),
    A.GaussNoise(p=0.3),
    A.InvertImg(p=0.3),
    A.MultiplicativeNoise(p=0.3),
    A.PixelDropout(p=0.3)
], bbox_params = A.BboxParams(format='albumentations'))

# Creación de imágenes tranformadas:
transformed_images = []
transformed_bboxes = []

for i in range(len(transforms)):
  t_im = transforms(image=train_images[0], bboxes=bbox)
  t_bbox = (list(t_im['bboxes'][0])[:-1])
  t_bbox = [t_bbox[1], t_bbox[0], t_bbox[3], t_bbox[2]]
  transformed_images.append(t_im)
  transformed_bboxes.append(t_bbox)

# Visualzación de data augmentation
plt.figure(figsize=(10, 3))

for idx in range(0, 10):
  bboxes = list(gt_boxes.values())[idx]
  dummy_score = np.ones(shape=[bboxes.shape[0]], dtype=np.float32)
  plt.subplot(2, 5, idx+1)
  plt.axis('off')
  plot_detections(
      transformed_images[idx]['image'],
      np.array([transformed_bboxes[idx]]),
      np.ones(shape=[bboxes.shape[0]], dtype=np.int32),
      dummy_score,
      category_index
  )

plt.suptitle('Transformed images')
plt.savefig('transformed_images.png')
plt.show()

Aquí les dejo la documentación de Transformeciones con Albumentations
Saludos 😃

Debo admitir que fue un poco complejo implementar este código para utilizar multiples objetos como había hecho en clases anteriores. Pero si te interesa llegar al siguiente ejemplo:

Puedes leer mis apuntes personales Aumentando Datos con Albumentation

Ahí encontraras una profunda explicación sobre las últimas 3 clases, ejemplo en código y explicación del mismo. 😄

Para evitar repetir segmentos de código, al momento de mostrar las transformaciones, usé la siguiente función:

def _plot_tranform(transform_dict, title='Transformed image'):
  '''
  Plot the first bounding box of a transformed image

  transform_dict: Dictionary whose keys are:
  
      - 'image': numpy array with transformed image.

      - 'bboxes': list with all bounding boxes in 
                  'albumentation' format and class name appended.

                  [(xmin, ymin, xmax, ymax, label_name), (...), (...)]
  '''
  # Get the first bounding box from tranformed image
  # 'bboxes': [(xmin, ymin, xmax, ymax, label_name), ...]
  bbox1_aug = transform_dict['bboxes'][0][:-1]

  # Change bbox format to: [ymin, xmin, ymax, xmax]
  bbox1_aug = [bbox1_aug[1], bbox1_aug[0], bbox1_aug[3], bbox1_aug[2]]

  # Visualize
  plt.figure()
  _plot_detections(image=transform_dict['image'],
                  bboxes=np.array([bbox1_aug]),
                  classes=np.ones(shape=[1], dtype=np.int32),
                  scores=np.ones(shape=[1], dtype=np.float32),
                  category_index=category_index)
  plt.title(title)
  plt.show()

De esta manera cada vez que sed quiera visualizar el primer bbox de una imagen transformada se llama la funcion de esta manera:

# Plot first transformation
_plot_tranform(transform_dict=img_aug1_dict,
               title='Transformed image (aug1)')

Esta funcion permite mostrar la imagen transformada con multiples objetos:

def plot_transformed_image(transformed_image):
    transformed_bboxes_1 = []
    transformed_labels_1 = []
    for bbox in transformed_image["bboxes"]:
        label = bbox[-1]
        transformed_labels_1.append(label)
        bbox = list(bbox[:-1])
        bbox = [bbox[1], bbox[0], bbox[3], bbox[2]]
        transformed_bboxes_1.append(bbox)
    
    plt.figure()
    plot_detections(
        transformed_image["image"],
        np.array(transformed_bboxes_1),
        np.array(transformed_labels_1),
        dummy_scores,
        category_index
    )

Esta es la continuacion de mi comentario anterior.

Para visualizar imágenes después de aplicar aumentos de datos (data augmentation), puedes utilizar la biblioteca `albumentations`, junto con `matplotlib` para mostrar las imágenes. Aquí tienes un ejemplo paso a paso para ver cómo se ven las imágenes con aumentos: \### 1. Instala `albumentations` (si no lo tienes ya instalado) ```bash pip install albumentations ``` \### 2. Define los aumentos y carga una imagen En este ejemplo, aplicaré algunos aumentos de datos comunes como rotación, cambio de brillo, y recorte. ```python import albumentations as A import cv2 from matplotlib import pyplot as plt \# Define las transformaciones transform = A.Compose(\[ A.HorizontalFlip(p=0.5), A.RandomBrightnessContrast(p=0.2), A.Rotate(limit=30, p=0.5), A.RandomCrop(width=200, height=200, p=0.3) ]) \# Cargar una imagen de ejemplo image = cv2.imread('ruta/a/tu/imagen.jpg') image = cv2.cvtColor(image, cv2.COLOR\_BGR2RGB) # Convierte de BGR a RGB para visualizar correctamente en matplotlib ``` \### 3. Aplicar los aumentos y visualizar varias versiones de la imagen Generaremos múltiples versiones de la imagen para ver el efecto de los aumentos. ```python \# Número de versiones aumentadas a mostrar num\_versions = 5 fig, axes = plt.subplots(1, num\_versions, figsize=(15, 5)) for i in range(num\_versions): \# Aplicar los aumentos augmented = transform(image=image) augmented\_image = augmented\['image'] \# Mostrar la imagen aumentada axes\[i].imshow(augmented\_image) axes\[i].axis('off') axes\[i].set\_title(f"Versión {i+1}") plt.tight\_layout() plt.show() ``` \### Explicación \- \*\*Transformaciones\*\*: La transformación `Compose` aplica las operaciones de forma secuencial, en este caso incluye: \- \*\*HorizontalFlip\*\*: Invierte la imagen horizontalmente con una probabilidad de 50%. \- \*\*RandomBrightnessContrast\*\*: Ajusta aleatoriamente el brillo y contraste. \- \*\*Rotate\*\*: Rota la imagen aleatoriamente dentro de un límite de 30 grados. \- \*\*RandomCrop\*\*: Recorta aleatoriamente una sección de la imagen de 200x200 píxeles. \- \*\*Visualización\*\*: Creamos varias subgráficas para ver diferentes versiones aumentadas de la imagen original.