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.
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 classid 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 3df = pedestrian_df[pedestrian_df['frame'].isin(single_occurrences)]true_bboxes =[] # Ground truth bounding boxes
images_added =[] # Filenameof 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)
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
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
me hace falta una clase de tensores. :)
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:
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:
