Fine-tuning en detección de objetos: carga de datos

Clase 18 de 31 • Curso de Detección y Segmentación de Objetos con TensorFlow

María Camila Durango Barrera

teacher•

Vamos muy biennn, he amado el curso, lo había terminado hace ratico pero no hice la practica. Ya lo he recomendado a mis amigos y colegas.

Alejandro Zambrano Zabaleta

student•

Para disminuir la cantidad de ciclos for, filtré la información primero antes de iterarla. Asi baja el tiempo en la carga de datos.

# Get only rows whose class id is 3 ('pedestrian')
pedestrian_df = labels_train_df.loc[labels_train_df.class_id==3]

# group by 'frame', count occurrences and
# filter filenames ('frame' values) with 
# a single occurrence
counts = labels_train_df.groupby('frame').size()
single_occurrences = counts[counts == 1].index

# filter dataframe to only include rows with 
# single occurrences of 'frame' and whose 'class_id' is 3
df = pedestrian_df[pedestrian_df['frame'].isin(single_occurrences)]



true_bboxes = [] # Ground truth bounding boxes
images_added = [] # Filename of images added in `true_bboxes`
train_images_np = [] # Numpy array of images to train

for index, row in df.iterrows():
  images_added.append(row.frame)

  bbox = np.array([ [row['ymin']/height, 
                    row['xmin']/width, 
                    row['ymax']/height, 
                    row['xmax']/width] 
                  ], dtype=np.float32)
  true_bboxes.append(bbox)

  im = cv2.imread(f'images/{row.frame}')
  im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)
  train_images_np.append(im)

Willy Samuel Paz Colque

student•

La verdad esta clase me confundió bastantes así que me puse a analizar el código y vi que se puede escribir de esta manera y obteniendo el mismo resultado

SHAPE = (300, 480)
df = pd.read_csv('labels_train.csv')

pedestrian_df = df[df['class_id'] == 3]
pedestrian_df = pedestrian_df.drop_duplicates(subset=['frame'])

pedestrian_df[['ymin', 'xmin', 'ymax', 'xmax']] = pedestrian_df[['ymin', 'xmin', 'ymax', 'xmax']].div([SHAPE[0],                                                                                                     
SHAPE[1], SHAPE[0], SHAPE[1]])

random_idx = np.random.randint(0, len(pedestrian_df) - 1, 30)
pedestrian_df = pedestrian_df.iloc[random_idx]

gt_boxes = pedestrian_df[['ymin', 'xmin', 'ymax', 'xmax']].values.astype(np.float32)
img_added = pedestrian_df['frame'].values.astype(str)

assert len(set(img_added)) == len(img_added) # check for duplicates

train_imgs_np = np.float32([load_image(os.path.join(my_path, image)) for image in img_added])
len(train_imgs_np) # output: 30

Y para la conversion a tensores nada mas es:

label_id_offset = 1
train_image_tensors = tf.convert_to_tensor(
    np.float32(train_imgs_np).reshape(-1, 1, 300, 480, 3)
)
gt_classes_one_hot_tensors = tf.one_hot(tf.convert_to_tensor(
    np.ones(gt_boxes.shape, dtype=np.int32)-label_id_offset),
    num_classes
)
gt_box_tensors = tf.convert_to_tensor(gt_boxes).shape

Notase que en ningún momento fue necesario utilizar for los Dataframes de pandas, los arrays de numpy y los tensores de TF ya soportan operaciones iterativas y son mucho mas rápidas que el código nativo de python

Noe Adrián Acuña Prado

student•

me hace falta una clase de tensores. :)

Mario Alexander Vargas Celis

student•

El *fine-tuning* en detección de objetos es un proceso que involucra la carga y preparación de datos para entrenar un modelo preentrenado en un nuevo conjunto de datos. Para realizar el fine-tuning con un modelo de detección de objetos en TensorFlow, uno de los primeros pasos es cargar y preparar los datos de manera adecuada. Esto generalmente involucra el uso de un formato adecuado para el entrenamiento, como el formato TFRecord que es utilizado por TensorFlow.

### Paso 1: Preparación del conjunto de datos

#### 1.1. Formato TFRecord

TensorFlow usa TFRecord como formato de almacenamiento para los datos de entrenamiento, que es eficiente y facilita el manejo de grandes volúmenes de datos.

Para trabajar con un conjunto de datos de detección de objetos, necesitas convertir las anotaciones de tus imágenes (generalmente en formatos como XML, CSV, JSON, etc.) al formato TFRecord.

**Pasos para convertir tus anotaciones al formato TFRecord:**

1. **Prepara el conjunto de datos**:

Asegúrate de que tus imágenes y anotaciones estén listas en una estructura organizada. Las anotaciones deben contener información como la clase del objeto, las coordenadas de la caja delimitadora (bounding box), y el identificador de la imagen.

2. **Convertir las anotaciones a TFRecord**:

Si tienes tus anotaciones en formato Pascal VOC XML o COCO, puedes usar la herramienta de la API de TensorFlow object\_detection para convertirlas al formato TFRecord.

- Para un conjunto de datos tipo Pascal VOC, puedes usar el siguiente script:

```python

from object_detection.dataset_tools import create_pascal_tf_record

create_pascal_tf_record.convert_dataset(

dataset_dir='/path/to/your/dataset',

output_path='/path/to/save/tfrecords',

label_map_path='/path/to/label_map.pbtxt'

)

```

Si tienes un conjunto de datos en formato CSV, deberías escribir un script para leer esas anotaciones y convertirlas a TFRecord.

#### 1.2. Crear un archivo de mapa de etiquetas (label\_map.pbtxt)

Este archivo contiene las clases que deseas detectar en tu conjunto de datos, con el formato pbtxt. A continuación, se muestra un ejemplo:


item {

&#x20; id: 1

&#x20; name: 'cat'

}

item {

&#x20; id: 2

&#x20; name: 'dog'

}

Este archivo es necesario para convertir las etiquetas de las imágenes en valores numéricos que el modelo pueda procesar.

#### 1.3. Dividir el conjunto de datos en entrenamiento y validación

Debes dividir tu conjunto de datos en dos partes: una para entrenamiento (train.tfrecord) y otra para validación (val.tfrecord). Puedes hacer esto manualmente o utilizando una librería como scikit-learn.


import random

from sklearn.model\_selection import train\_test\_split



\# Divide las rutas de tus imágenes en dos listas: entrenamiento y validación

train\_images, val\_images = train\_test\_split(all\_image\_paths, test\_size=0.2, random\_state=42)

### Paso 2: Configuración del archivo pipeline.config

El archivo pipeline.config contiene todos los parámetros necesarios para el entrenamiento del modelo. Algunos de los valores clave que debes configurar incluyen:

- **Rutas a los datos**: Las rutas a tus archivos TFRecord y el mapa de etiquetas.

- **Número de clases**: El número de clases en tu conjunto de datos.

- **Checkpoint preentrenado**: La ruta al checkpoint del modelo preentrenado.

- **Hiperparámetros**: Como el optimizador, la tasa de aprendizaje, y los pasos de entrenamiento.

**Ejemplo de configuración en el archivo pipeline.config:**


\# Número de clases

num\_classes: 2  # Por ejemplo, 'cat' y 'dog'



\# Rutas a los datos

train\_input\_path: "train.tfrecord"

eval\_input\_path: "val.tfrecord"

label\_map\_path: "label\_map.pbtxt"



\# Checkpoint preentrenado

fine\_tune\_checkpoint: "ssd\_mobilenet\_v2\_fpnlite\_320x320\_coco17\_tpu-8/saved\_model/model.ckpt"



\# Parámetros de entrenamiento

batch\_size: 24

learning\_rate: 0.004

num\_steps: 5000

Asegúrate de que las rutas en tu archivo de configuración sean correctas, y que el número de clases coincida con las que tienes en tu conjunto de datos.

### Paso 3: Entrenamiento del modelo

Una vez que hayas configurado los datos y el archivo de configuración, el siguiente paso es entrenar el modelo. Puedes usar el siguiente comando para entrenar el modelo:


python3 models/research/object\_detection/model\_main\_tf2.py \\

&#x20; \--pipeline\_config\_path=PATH\_TO\_YOUR\_PIPELINE\_CONFIG \\

&#x20; \--model\_dir=PATH\_TO\_SAVE\_MODEL \\

&#x20; \--alsologtostderr

Este comando iniciará el proceso de entrenamiento y guardará los pesos del modelo en la carpeta especificada en model\_dir.

### Paso 4: Evaluación del modelo

Una vez que el modelo esté entrenado, puedes evaluarlo en el conjunto de datos de validación utilizando el siguiente comando:


python3 models/research/object\_detection/model\_main\_tf2.py \\

&#x20; \--pipeline\_config\_path=PATH\_TO\_YOUR\_PIPELINE\_CONFIG \\

&#x20; \--model\_dir=PATH\_TO\_SAVE\_MODEL \\

&#x20; \--checkpoint\_dir=PATH\_TO\_SAVE\_MODEL \\

&#x20; \--eval\_training\_data=True \\

&#x20; \--alsologtostderr

### Paso 5: Exportar el modelo entrenado

Cuando el modelo haya completado el entrenamiento y la evaluación, puedes exportarlo para usarlo en predicciones con el siguiente comando:


python3 models/research/object\_detection/exporter\_main\_v2.py \\

&#x20; \--pipeline\_config\_path=PATH\_TO\_YOUR\_PIPELINE\_CONFIG \\

&#x20; \--trained\_checkpoint\_dir=PATH\_TO\_SAVE\_MODEL \\

&#x20; \--output\_directory=PATH\_TO\_EXPORT\_MODEL

### Resumen del flujo de trabajo para cargar y preparar datos para fine-tuning:

1. **Preparar y convertir los datos**:

- Organiza tus imágenes y anotaciones.

- Convierte las anotaciones a TFRecord.

- Prepara un archivo label\_map.pbtxt con las clases de tu conjunto de datos.

2. **Configurar el archivo pipeline.config**:

- Configura las rutas a tus datos, el número de clases y otros hiperparámetros.

3. **Entrenar el modelo**:

- Usa el script model\_main\_tf2.py para entrenar el modelo.

4. **Evaluar el modelo**:

- Evalúa el modelo con el conjunto de datos de validación.

5. **Exportar el modelo**:

- Exporta el modelo entrenado para hacer predicciones.