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

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)

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: ```plaintext item { id: 1 name: 'cat' } item { id: 2 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`. ```python 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`:\*\* ```plaintext \# 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: ```bash python3 models/research/object\_detection/model\_main\_tf2.py \\ \--pipeline\_config\_path=PATH\_TO\_YOUR\_PIPELINE\_CONFIG \\ \--model\_dir=PATH\_TO\_SAVE\_MODEL \\ \--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: ```bash python3 models/research/object\_detection/model\_main\_tf2.py \\ \--pipeline\_config\_path=PATH\_TO\_YOUR\_PIPELINE\_CONFIG \\ \--model\_dir=PATH\_TO\_SAVE\_MODEL \\ \--checkpoint\_dir=PATH\_TO\_SAVE\_MODEL \\ \--eval\_training\_data=True \\ \--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: ```bash python3 models/research/object\_detection/exporter\_main\_v2.py \\ \--pipeline\_config\_path=PATH\_TO\_YOUR\_PIPELINE\_CONFIG \\ \--trained\_checkpoint\_dir=PATH\_TO\_SAVE\_MODEL \\ \--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.