Transformar CSV a TFRecord

El código usado para crear los TFRecords está basado en TensorFlow 1.x, esta versión de TensorFlow no debería ser usada para nuevos proyectos, aquí les preparé una implementación con TensorFlow 2.x si tienen comentarios y/o correcciones, son bienvenidos:

def class_text_to_int(row_label):
    if row_label == MOTORCYCLE_LABEL:
        return 1
    elif row_label == CAR_LABEL:
        return 2
    else: return None


def split(df, group):
    """ Create a namedtuple with the filename and all data related to cars 
    and/or motorcycles found on the picture"""
    data = namedtuple('data', ['filename', 'object'])
    gb = df.groupby(group)  # group DataFrame by filename
    return [data(filename, gb.get_group(x)) for filename, x in zip(gb.groups.keys(), gb.groups)]


def create_tf_example(group, path):
    """ Create TFRecord files"""
    image  = tf.keras.utils.load_img(os.path.join(DATASET_PATH, group.filename))
    width, height = image.size
    image_format = image.format.encode('utf8')
    image = tf.io.encode_jpeg(tf.keras.utils.img_to_array(image))

    filename = group.filename.encode('utf8')
    
    # check if the image format is matching with your images.
    xmins = []
    xmaxs = []
    ymins = []
    ymaxs = []
    classes_text = []
    classes = []

    for index, row in group.object.iterrows():
        xmins.append(row['xmin'] / width)
        xmaxs.append(row['xmax'] / width)
        ymins.append(row['ymin'] / height)
        ymaxs.append(row['ymax'] / height)
        classes_text.append(row['classname'].encode('utf8'))
        classes.append(class_text_to_int(row['classname']))

    tf_example = tf.train.Example(features=tf.train.Features(feature={
        'image/height': dataset_util.int64_feature(height),
        'image/width': dataset_util.int64_feature(width),
        'image/filename': dataset_util.bytes_feature(filename),
        'image/source_id': dataset_util.bytes_feature(filename),
        'image/encoded': dataset_util.bytes_feature(image.numpy()),
        'image/format': dataset_util.bytes_feature(image_format),
        'image/object/bbox/xmin': dataset_util.float_list_feature(xmins),
        'image/object/bbox/xmax': dataset_util.float_list_feature(xmaxs),
        'image/object/bbox/ymin': dataset_util.float_list_feature(ymins),
        'image/object/bbox/ymax': dataset_util.float_list_feature(ymaxs),
        'image/object/class/text': dataset_util.bytes_list_feature(classes_text),
        'image/object/class/label': dataset_util.int64_list_feature(classes),
    }))
    return tf_example

Proceso de instalación de la librería object detection:

import os
%cd /content
!git clone --quiet https://github.com/tensorflow/models.git
%cd /content/models/
!git checkout 58d19c67e1d30d905dd5c6e5092348658fed80af
!apt-get update && apt-get install -y -qq protobuf-compiler python-pil python-lxml python-tk
!pip install -q Cython contextlib2 pillow lxml matplotlib
!pip install -q pycocotools
%cd /content/models/research
!protoc object_detection/protos/*.proto --python_out=.
os.environ['PYTHONPATH'] += ':/content/models/research/:/content/models/research/slim/'
!python object_detection/builders/model_builder_test.py

Ejecutar esta linea para instalar la libreria object detection:

!pip install tensorflow-object-detection-api

esto resuelve el problema marcado en amarillo que aparece al copiar y pegar el contenido de “Converting from *.csv to *.record” en el enlace que comparte el profe

Para transformar un archivo CSV a TFRecord, aquí tienes una guía detallada paso a paso. Supongamos que tu archivo `dataset.csv` tiene las siguientes columnas: ```csv filename, label imagen\_001.jpg, 0 imagen\_002.jpg, 1 ``` \### Pasos para convertir el CSV a TFRecord 1\. \*\*Importar las bibliotecas necesarias\*\* ```python import os import tensorflow as tf import pandas as pd ``` 2\. \*\*Definir las funciones de ayuda para la conversión a TFRecord\*\* Cada característica en los datos debe transformarse al formato adecuado (`bytes`, `int64` o `float`), y se utiliza un `tf.train.Example` para almacenar la información en el formato TFRecord. ```python def \_bytes\_feature(value): """Retorna un Feature en formato bytes.""" return tf.train.Feature(bytes\_list=tf.train.BytesList(value=\[value])) def \_int64\_feature(value): """Retorna un Feature en formato int64.""" return tf.train.Feature(int64\_list=tf.train.Int64List(value=\[value])) def create\_example(row): """Crea un tf.train.Example para cada fila en el CSV.""" \# Lee la imagen en bytes with open(row\['filename'], 'rb') as img\_file: image\_data = img\_file.read() \# Crear un diccionario de características feature = { 'image': \_bytes\_feature(image\_data), 'label': \_int64\_feature(int(row\['label'])) } \# Retorna el ejemplo serializado return tf.train.Example(features=tf.train.Features(feature=feature)) ``` 3\. \*\*Cargar el archivo CSV y escribir los datos en el archivo TFRecord\*\* Lee el archivo CSV con `pandas`, luego convierte cada fila en un `tf.train.Example` y escribe los ejemplos en un archivo TFRecord. ```python \# Definir ruta del archivo CSV y carpeta de imágenes csv\_file = 'dataset.csv' output\_tfrecord = 'dataset.tfrecord' \# Leer el archivo CSV df = pd.read\_csv(csv\_file) \# Crear el archivo TFRecord y escribir los ejemplos with tf.io.TFRecordWriter(output\_tfrecord) as writer: for \_, row in df.iterrows(): example = create\_example(row) writer.write(example.SerializeToString()) print("Archivo TFRecord creado correctamente.") ``` 4\. \*\*Leer y verificar el archivo TFRecord\*\* Ahora puedes cargar el archivo TFRecord para verificar que los datos se almacenaron correctamente. ```python \# Definir función para leer el archivo TFRecord def parse\_tfrecord\_fn(example\_proto): \# Descripción de características para decodificar feature\_description = { 'image': tf.io.FixedLenFeature(\[], tf.string), 'label': tf.io.FixedLenFeature(\[], tf.int64), } return tf.io.parse\_single\_example(example\_proto, feature\_description) \# Cargar el archivo TFRecord raw\_dataset = tf.data.TFRecordDataset(output\_tfrecord) parsed\_dataset = raw\_dataset.map(parse\_tfrecord\_fn) \# Mostrar algunos ejemplos for parsed\_record in parsed\_dataset.take(5): image\_raw = parsed\_record\['image'].numpy() label = parsed\_record\['label'].numpy() print("Etiqueta:", label) print("Imagen (bytes):", len(image\_raw), "bytes") # Verifica el tamaño en bytes ``` \### Explicación de los pasos \- \*\*Conversión de tipos de datos\*\*: Las funciones `\_bytes\_feature` y `\_int64\_feature` convierten los valores de las características al tipo que espera `tf.train.Example`. \- \*\*Creación de `tf.train.Example`\*\*: Se crea un ejemplo con las características necesarias, en este caso la imagen en bytes y la etiqueta. \- \*\*Escritura en TFRecord\*\*: `TFRecordWriter` escribe cada ejemplo en el archivo `dataset.tfrecord`. \- \*\*Lectura de TFRecord\*\*: Con `tf.data.TFRecordDataset`, puedes leer y decodificar cada ejemplo, lo que permite verificar que los datos están almacenados correctamente. Este proceso optimiza el almacenamiento y facilita la carga rápida en TensorFlow para entrenamiento y evaluación en grandes conjuntos de datos.

Urge actualizacion de esta clase: import os import pandas as pd import tensorflow as tf def create\_tf\_example(row, image\_dir): \# Load the image img\_path = os.path.join(image\_dir, row\['filename']) with tf.io.gfile.GFile(img\_path, 'rb') as fid: encoded\_jpg = fid.read() width = int(row\['width']) height = int(row\['height']) filename = row\['filename'].encode('utf8') image\_format = b'jpg' xmins = \[row\['xmin'] / width] xmaxs = \[row\['xmax'] / width] ymins = \[row\['ymin'] / height] ymaxs = \[row\['ymax'] / height] classes\_text = \[row\['class'].encode('utf8')] classes = \[1] # You can modify this based on your label map tf\_example = tf.train.Example(features=tf.train.Features(feature={ 'image/height': tf.train.Feature(int64\_list=tf.train.Int64List(value=\[height])), 'image/width': tf.train.Feature(int64\_list=tf.train.Int64List(value=\[width])), 'image/filename': tf.train.Feature(bytes\_list=tf.train.BytesList(value=\[filename])), 'image/source\_id': tf.train.Feature(bytes\_list=tf.train.BytesList(value=\[filename])), 'image/encoded': tf.train.Feature(bytes\_list=tf.train.BytesList(value=\[encoded\_jpg])), 'image/format': tf.train.Feature(bytes\_list=tf.train.BytesList(value=\[image\_format])), 'image/object/bbox/xmin': tf.train.Feature(float\_list=tf.train.FloatList(value=xmins)), 'image/object/bbox/xmax': tf.train.Feature(float\_list=tf.train.FloatList(value=xmaxs)), 'image/object/bbox/ymin': tf.train.Feature(float\_list=tf.train.FloatList(value=ymins)), 'image/object/bbox/ymax': tf.train.Feature(float\_list=tf.train.FloatList(value=ymaxs)), 'image/object/class/text': tf.train.Feature(bytes\_list=tf.train.BytesList(value=classes\_text)), 'image/object/class/label': tf.train.Feature(int64\_list=tf.train.Int64List(value=classes)), })) return tf\_example def convert\_csv\_to\_tfrecord(csv\_input, image\_dir, output\_path): writer = tf.io.TFRecordWriter(output\_path) df = pd.read\_csv(csv\_input) for index, row in df.iterrows(): tf\_example = create\_tf\_example(row, image\_dir) writer.write(tf\_example.SerializeToString()) writer.close() print(f'Successfully created the TFRecord file: {output\_path}') \# Example usage csv\_input = './type\_file\_labels.csv' # Path to your CSV file image\_dir = './images/' # Path to your image directory output\_path = './train.record' # Output path for the TFRecord \# Convert CSV to TFRecord convert\_csv\_to\_tfrecord(csv\_input, image\_dir, output\_path)