Transforma tu base de datos a TFRecord

Si metemos toda la lógica de carga de datos en una función donde parametrizamos el tipo de dataset podemos evitar tener que cambiar código para cada tipo de dataset, por ejemplo:

def create_csv(data, dataset_type):
	csv_list = []
	for classification in data:
		width, height = classification['width'], classification['height']
		image_name = classification['image']
		for item in classification['tags']:
			name = item['name']
			xmin = item['x']
			ymin = item['y']
			xmax = xmin + item['w']
			ymax = ymin + item['h']
			values = (image_name, width, height, name, xmin, ymin, xmax, ymax)
			csv_list.append(values)
	column_names = ['filename', 'width', 'height', 'classname', 'xmin', 'ymin', 'xmax', 'ymax']
	csv_df = pd.DataFrame(csv_list, columns=column_names)
	csv_df.to_csv(f"/content/{dataset_type}_labels.csv")

El formato \*\*TFRecord\*\* es un formato binario desarrollado por TensorFlow que permite almacenar grandes cantidades de datos de manera eficiente, especialmente útil para conjuntos de datos que contienen imágenes y etiquetas, o cualquier dato que desees procesar con TensorFlow. A continuación, te explico cómo transformar tu base de datos a TFRecord. \### Pasos para convertir una base de datos a TFRecord Supongamos que tienes imágenes y sus etiquetas en un archivo CSV. Para este ejemplo, imaginemos que el archivo `train\_labels.csv` tiene el siguiente formato: ```csv filename,label imagen\_001.jpg,0 imagen\_002.jpg,1 ... ``` 1\. \*\*Importar bibliotecas necesarias\*\*: ```python import os import tensorflow as tf import pandas as pd from PIL import Image ``` 2\. \*\*Definir funciones para la conversión a TFRecord\*\*: La clave está en convertir los datos a un formato compatible con \*\*tf.train.Example\*\* y luego escribirlos en un archivo `.tfrecord`. ```python \# Función para convertir los tipos de datos def \_bytes\_feature(value): return tf.train.Feature(bytes\_list=tf.train.BytesList(value=\[value])) def \_int64\_feature(value): return tf.train.Feature(int64\_list=tf.train.Int64List(value=\[value])) \# Función para crear un tf.train.Example def create\_example(image\_path, label): \# Leer y convertir la imagen a bytes with open(image\_path, 'rb') as img\_file: image\_data = img\_file.read() \# Crear un diccionario de características feature = { 'image': \_bytes\_feature(image\_data), 'label': \_int64\_feature(label) } \# Convertir el diccionario en un tf.train.Example example = tf.train.Example(features=tf.train.Features(feature=feature)) return example ``` 3\. \*\*Cargar etiquetas y escribir el archivo TFRecord\*\*: Lee el archivo CSV y escribe los datos en formato TFRecord. ```python \# Rutas y archivos csv\_file = 'train\_labels.csv' image\_folder = 'path/to/images' output\_tfrecord = 'train\_data.tfrecord' \# Leer el archivo CSV df = pd.read\_csv(csv\_file) \# Crear el archivo TFRecord with tf.io.TFRecordWriter(output\_tfrecord) as writer: for \_, row in df.iterrows(): image\_path = os.path.join(image\_folder, row\['filename']) label = int(row\['label']) \# Crear tf.train.Example para cada imagen y etiqueta example = create\_example(image\_path, label) \# Escribir en el archivo TFRecord writer.write(example.SerializeToString()) ``` 4\. \*\*Leer y verificar el archivo TFRecord\*\*: Una vez que tienes el archivo TFRecord, verifica que los datos se han guardado correctamente. ```python \# Función para leer el TFRecord def parse\_tfrecord\_fn(example): feature\_description = { 'image': tf.io.FixedLenFeature(\[], tf.string), 'label': tf.io.FixedLenFeature(\[], tf.int64), } example = tf.io.parse\_single\_example(example, feature\_description) example\['image'] = tf.io.decode\_jpeg(example\['image']) # Decodifica imagenes JPEG return example\['image'], example\['label'] \# Cargar el dataset desde el archivo TFRecord raw\_dataset = tf.data.TFRecordDataset(output\_tfrecord) parsed\_dataset = raw\_dataset.map(parse\_tfrecord\_fn) \# Imprimir algunos ejemplos for image, label in parsed\_dataset.take(5): print("Etiqueta:", label.numpy()) print("Imagen:", image.numpy().shape) # Mostrar la forma de la imagen ``` \### Explicación de los pasos \- \*\*Conversión de tipos de datos\*\*: `\_bytes\_feature` y `\_int64\_feature` son funciones que convierten los datos a los tipos aceptados por `tf.train.Example`. \- \*\*Creación de `tf.train.Example`\*\*: Esto encapsula los datos de cada ejemplo (imagen + etiqueta) en un formato que puede escribirse en TFRecord. \- \*\*Escritura en TFRecord\*\*: Utilizamos `TFRecordWriter` para escribir cada `Example` en el archivo TFRecord. \- \*\*Lectura de TFRecord\*\*: Utilizamos `tf.data.TFRecordDataset` para leer el archivo y `parse\_tfrecord\_fn` para decodificar los datos almacenados. Este formato es eficiente para proyectos de machine learning, especialmente cuando se trabaja con grandes volúmenes de datos, ya que \*\*TFRecord\*\* permite una lectura rápida en paralelo y una integración perfecta con el flujo de trabajo de TensorFlow.

**Por qué usar TFRecord** **Eficiencia**: Al estar en formato binario, los archivos **TFRecord** son más pequeños y rápidos de procesar en comparación con formatos como CSV o JSON. **Compatibilidad**: TensorFlow maneja eficientemente los archivos **TFRecord**, permitiendo la creación de pipelines de datos escalables para entrenar modelos con grandes volúmenes de datos. **Flexibilidad**: TFRecord puede almacenar cualquier tipo de datos, desde imágenes hasta secuencias de texto, proporcionando una estructura de almacenamiento flexible.

No siempre tendremos herramientas para automatizar muchos de estos procesos por lo que aprender los fundamentos de como funcionan es imprescindible para saber cual herramienta tenemos a nuestro alcance y como utilizarlas.