Decodificaci贸n del c贸digo de vestimenta 馃憲 Aprendizaje profundo para la detecci贸n automatizada de prendas de moda

'Decodificaci贸n de c贸digo de vestimenta 馃憲 Aprendizaje profundo para detecci贸n automatizada de moda'

Foto original de Tamara Bellis en Unsplash, procesada por el autor.

En el vibrante mundo del comercio electr贸nico, la industria de la moda es su propia pasarela. Pero, 驴qu茅 pasar铆a si pudi茅ramos descifrar el c贸digo de vestimenta de esta pasarela, no con el ojo de un dise帽ador, sino con la precisi贸n del Aprendizaje Profundo (DL, por sus siglas en ingl茅s)? Hoy, vamos a desentra帽ar los hilos de esta intrigante posibilidad. Utilizaremos un modelo pre-entrenado y PyTorch Lightning鹿 para automatizar el proceso de etiquetado de productos, transformando una tarea que consume mucho tiempo en un proceso r谩pido y eficiente. Esto no es solo un pase tras bambalinas al mundo del DL en la moda, sino un asiento de primera fila en una revoluci贸n en las operaciones de comercio electr贸nico. Entonces, si est谩s listo para ver c贸mo el aprendizaje profundo puede descifrar el c贸digo de vestimenta del mundo de la moda digital, 隆prep谩rate!

Este blog se divide en dos partes clave: ‘ Ajuste fino de un modelo pre-entrenado ‘ e ‘ Inferencia ‘. La parte de ‘ Ajuste fino de un modelo pre-entrenado ‘ comienza en la pr贸xima secci贸n hasta la secci贸n de Ajuste fino con Pytorch Lightning, donde proporciono una demostraci贸n detallada de c贸mo podemos ajustar un modelo pre-entrenado para adaptarlo mejor a nuestras necesidades espec铆ficas de detecci贸n de elementos de moda. Mientras tanto, la parte de ‘ Inferencia ‘ est谩 dedicada a aquellos que desean utilizar de inmediato el modelo para la detecci贸n de m煤ltiples elementos de moda. Si est谩s ansioso por ver el modelo en acci贸n, si茅ntete libre de saltar directamente a la secci贸n de Inferencia.

PREPARANDO EL ESCENARIO

Para comenzar nuestro desfile de moda, debemos preparar el escenario configurando nuestro entorno de Python con PyTorch Lightning鹿, un envoltorio de PyTorch que simplifica la gesti贸n de c贸digo y acelera el entrenamiento del modelo. Adem谩s, incorporaremos los paquetes esenciales a continuaci贸n para el entrenamiento y la inferencia:

# Instalar paquetespip install torch==2.0.0pip install pytorch-lightning==2.0.1pip install datasets==2.11.0pip install transformers==4.30.1pip install huggingface_hub==0.14.1

A continuaci贸n, importemos los siguientes m贸dulos:

# Importar bibliotecas necesarias para la manipulaci贸n y visualizaci贸n de datosimport randomimport numpy as npimport matplotlib.pyplot as pltimport shutilimport globimport os# Bibliotecas para el procesamiento de im谩genesfrom PIL import Image, ImageDraw# Utilidad para descargar un archivo del repositorio de modelos de Hugging Facefrom huggingface_hub import hf_hub_download# Funci贸n para dividir tus datos en conjuntos de entrenamiento y pruebafrom sklearn.model_selection import train_test_split# Bibliotecas para manejar conjuntos de datosimport datasetsfrom datasets import load_dataset, concatenate_datasets, DatasetDict# PyTorch Lightning para entrenamiento de alto rendimientoimport lightning as plfrom lightning import Trainer# PyTorch para construir y entrenar redes neuronalesimport torchimport torch.nn as nn# DataLoader para crear un iterable sobre el conjunto de datosfrom torch.utils.data import DataLoader# Bibliotecas para transformaciones de im谩genesfrom torchvision import transformsfrom torchvision.transforms import ToPILImage, ToTensor# Biblioteca Transformers para manejar modelosfrom transformers import AutoModelForObjectDetectionfrom transformers import YolosFeatureExtractor, YolosForObjectDetection

CARGANDO LOS DATOS

El conjunto de datos para este proyecto es el conjunto de datos Fashionpedia虏, alojado en Hugging Face, que contiene m谩s de 46,000 im谩genes con anotaciones de cuadros delimitadores para m煤ltiples objetos de moda. Este conjunto de datos es un subconjunto de Fashionpedia鲁, que es un conjunto de datos de moda a gran escala donde cada imagen est谩 anotada con m谩scaras de segmentaci贸n y atributos de moda de granularidad fina. Es un conjunto de datos completo que es perfecto para nuestra tarea de detecci贸n de elementos de moda.

Para usar el conjunto de datos, cargu茅moslo utilizando la biblioteca de conjuntos de datos de Hugging Face. Para este proyecto, solo utilic茅 el 30% del conjunto de datos para demostrar c贸mo ajustar finamente un modelo pre-entrenado para una tarea de detecci贸n de elementos de moda:

# Cargar el 30% del conjunto de datos de entrenamientodataset = load_dataset("detection-datasets/fashionpedia", split='train[:30%]')# Generar los 铆ndices de divisi贸ntrain_val_test_split = dataset.train_test_split(test_size=0.2, seed=42)  # 80% entrenamiento, 20% para validaci贸n y pruebaval_test_split = train_val_test_split['test'].train_test_split(test_size=0.5, seed=42)  # Dividir el 20% en partes iguales para validaci贸n y prueba# Almacenar las divisiones en un DatasetDictfinal_splits = DatasetDict({    'train': train_val_test_split['train'],    'val': val_test_split['train'],    'test': val_test_split['test']})# Desempaquetar el DatasetDict para obtener conjuntos de datos de entrenamiento, validaci贸n y pruebatrain_dataset, val_dataset, test_dataset = final_splits['train'], final_splits['val'], final_splits['test']

Nuestros conjuntos de datos de entrenamiento, validaci贸n y prueba deber铆an verse as铆:

(Conjunto de datos({     caracter铆sticas: ['image_id', 'image', 'width', 'height', 'objects'],     n煤mero de filas: 10949 }), Conjunto de datos({     caracter铆sticas: ['image_id', 'image', 'width', 'height', 'objects'],     n煤mero de filas: 1369 }), Conjunto de datos({     caracter铆sticas: ['image_id', 'image', 'width', 'height', 'objects'],     n煤mero de filas: 1369 }))

Adem谩s, vamos a mostrar los detalles de una imagen:

test_dataset[0]

{'image_id': 14991, 'image': <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=676x1024>, 'width': 676, 'height': 1024, 'objects': {'bbox_id': [117814, 117815, 117816, 117817, 117818],  'category': [23, 23, 6, 1, 14],  'bbox': [[174.0, 862.0, 299.0, 969.0],   [309.0, 634.0, 420.0, 759.0],   [127.0, 530.0, 380.0, 903.0],   [226.0, 221.0, 420.0, 610.0],   [254.0, 97.0, 395.0, 199.0]],  'area': [6797, 7354, 35017, 30388, 6175]}}

El contenido del conjunto de datos tiene los siguientes campos, como se documenta en su tarjeta de conjunto de datos虏:

{'image_id': Valor(tipo de datos='int64'),'image': Imagen(decodificar=True),'width': Valor(tipo de datos='int64'),'height': Valor(tipo de datos='int64'),'objects': Secuencia(caracter铆stica={  'bbox_id': Valor(tipo de datos='int64'),   'category': EtiquetaClase(n煤mero de clases=46, nombres=['camisa, blusa', 'top, camiseta, sudadera', 'su茅ter', 'c谩rdigan', 'chaqueta', 'chaleco', 'pantalones', 'shorts', 'falda', 'abrigo', 'vestido', 'monos', 'capa', 'gafas', 'sombrero', 'cinta para la cabeza, cubierta para la cabeza, accesorio para el cabello', 'corbata', 'guante', 'reloj', 'cintur贸n', 'calentador de piernas', 'medias, pantimedias', 'calcet铆n', 'zapato', 'bolso, cartera', 'bufanda', 'paraguas', 'capucha', 'cuello', 'solapa', 'hombrera', 'manga', 'bolsillo', 'escote', 'hebilla', 'cremallera', 'aplique', 'cuentas', 'lazo', 'flor', 'borla', 'cinta', 'remache', 'volante', 'lentejuela', 'borla']}),   'bbox': Secuencia(caracter铆stica=Valor(tipo de datos='float64'), longitud=4),   'area': Valor(tipo de datos='int64')}, longitud=-1)}

Campos de datos

El conjunto de datos tiene los siguientes campos虏:

  • image_id : Un ID num茅rico 煤nico asignado a cada imagen.
  • image : Una instancia de la clase PIL.Image.Image que representa la imagen.
  • width : El ancho de la imagen.
  • height : La altura de la imagen.
  • objects : Un diccionario que contiene metadatos relacionados con las cajas delimitadoras de los objetos presentes en la imagen.
  • bbox_id : Un ID num茅rico 煤nico asignado a cada anotaci贸n de caja delimitadora.
  • category : La categor铆a del objeto.
  • area : El 谩rea cubierta por la caja delimitadora.
  • bbox : Las coordenadas de la caja delimitadora del objeto en el formato Pascal VOC.

MODELOS PREENTRENADOS Y APRENDIZAJE POR TRANSFERENCIA

Como se mencion贸 anteriormente, en este blog aprovecharemos el poder de los modelos preentrenados. Estos modelos, entrenados en grandes conjuntos de datos, ya han aprendido muchas caracter铆sticas y patrones. Al utilizar estos modelos, podemos aprovechar su aprendizaje y aplicarlo a nuestra tarea espec铆fica. Esto es especialmente 煤til cuando tenemos una cantidad limitada de datos para nuestra tarea o cuando queremos ahorrar tiempo y recursos computacionales.

En nuestro caso, utilizaremos el modelo YOLOs-Fashionpedia鈦, que ha sido preentrenado en la arquitectura YOLO-Small鈦. Este modelo ya ha aprendido a detectar diversos art铆culos de moda, lo que lo convierte en un punto de partida perfecto para nuestra tarea.

FUNCIONES AUXILIARES

En el transcurso de la ejecuci贸n de este proyecto, descubr铆 un recurso importante en el repositorio de GitHub de Valentina Feruere Vega鈦. Este repositorio proporcion贸 una gu铆a exhaustiva sobre el ajuste fino del conjunto de datos Fashionpedia, un proceso que fue fundamental para este proyecto. Para agilizar el manejo de nuestro conjunto de datos y hacerlo compatible con el modelo YOLO-Small, he compilado un conjunto de funciones auxiliares. Estas funciones est谩n dise帽adas espec铆ficamente para reconciliar la discrepancia entre el formato de caja delimitadora (bbox) utilizado en el conjunto de datos Fashionpedia (x1, x2, y1, y2) y el formato requerido por YOLO-Small (x_centro, y_centro, ancho, altura):

def xyxy_to_xcycwh(box):    x1, y1, x2, y2 = box.unbind(dim=1)    ancho = x2-x1    altura = y2-y1    xc = x1 + ancho*0.5    yc = y1 + altura*0.5    b = [xc, yc, ancho, altura]    return torch.stack(b, dim=1)def cxcywh_to_xyxy(x):    x_c, y_c, w, h = x.unbind(1)    x1 = x_c - 0.5 * w    y1 = y_c - 0.5 * h    x2 = x_c + 0.5 * w    y2 = y_c + 0.5 * h    b = [x1, y1, x2, y2]    return torch.stack(b, dim=1)

Para procesar las im谩genes del conjunto de datos, que se almacenan como objetos PILImage, utilizaremos el YOLOS Feature Extractor. Este extractor de caracter铆sticas transformar谩 las im谩genes en un formato de tensor compuesto por valores num茅ricos. Este paso de preprocesamiento es esencial para el an谩lisis y manipulaci贸n posterior de las im谩genes dentro del marco de trabajo YOLOS.

# Cargar nuestro extractor de caracter铆sticas: yolos-smallfeature_extractor = YolosFeatureExtractor.from_pretrained('hustvl/yolos-small', size=816, max_size=864)

Ahora podemos aplicar las siguientes transformaciones para hacerlo compatible con el modelo:

def rescale_bboxes(out_bbox, size, down=True):    img_w, img_h = size    if down:        b = torch.Tensor(out_bbox) / torch.tensor([img_w, img_h, img_w, img_h], dtype=torch.float32)    if not down:        b = torch.Tensor(out_bbox) * torch.tensor([img_w, img_h, img_w, img_h], dtype=torch.float32)    return bdef transform(batch):    inputs = {}    inputs['pixel_values'] = feature_extractor(batch['image'], return_tensors='pt')['pixel_values']    labels = []    bbox = [rescale_bboxes(batch['objects'][i]['bbox'], (batch['width'][i], batch['height'][i])) for i in range(len(batch['objects']))]    bbox = [xyxy_to_xcycwh(torch.Tensor(bbox_i)) for bbox_i in bbox]    labels.append({        "boxes": bbox,        "class_labels": [objeto['category'] for objeto in batch['objects']],        "image_id": torch.Tensor([batch['image_id']]).int(),        "area": [objeto['area'] for objeto in batch['objects']],        "iscrowd": torch.Tensor([0 for _ in batch['objects']]).int(),        "orig_size": torch.Tensor([(batch['width'], batch['height'])]).int(),        "size": torch.Tensor([inputs['pixel_values'].shape[1:]])[0].int(),    })    inputs['labels'] = labels    return inputs

# Aplicar transformaciones para hacerlo compatible con el modelo prepared_train = train_dataset.with_transform(transform)prepared_val = val_dataset.with_transform(transform)prepared_test = test_dataset.with_transform(transform)

Para agilizar el proceso de entrenamiento con lotes, es necesario tener una funci贸n de agrupaci贸n. Esta funci贸n toma una lista de entradas, t铆picamente diccionarios en este contexto, y las transforma en una 煤nica entrada donde los datos est谩n apilados. En otras palabras, una lista de diccionarios se convertir谩 en un diccionario donde los valores de cada clave se convierten en un vector. Esta funci贸n de agrupaci贸n desempe帽a un papel crucial para entrenar eficientemente un modelo al organizar los datos en estructuras amigables para lotes.

def collate_fn(batch):    agrupado = {}    agrupado["pixel_values"] = feature_extractor.pad([item['pixel_values'] for item in batch], return_tensors="pt")['pixel_values']    agrupado["labels"] = []    for item in batch:        item['labels']['boxes'] = torch.stack(item['labels']['boxes'])[0]        item['labels']['area'] = torch.Tensor(item['labels']['area'])        item['labels']['class_labels'] = torch.Tensor(item['labels']['class_labels'])[0]        item['labels']['class_labels'] = item['labels']['class_labels'].type(torch.LongTensor)        agrupado["labels"].append(item['labels'])    return agrupado

# Lo siguiente se utilizar谩 para cargar lotes en el modeloBATCH_SIZE = 1train_dataloader = DataLoader(prepared_train, collate_fn=collate_fn, batch_size=BATCH_SIZE)val_dataloader = DataLoader(prepared_val, collate_fn=collate_fn, batch_size=BATCH_SIZE)test_dataloader = DataLoader(prepared_test, collate_fn=collate_fn, batch_size=BATCH_SIZE)

AJUSTE FINO CON PYTORCH LIGHTNING

Con nuestro escenario preparado y nuestros int茅rpretes listos, es hora del ensayo.

El ajuste fino es como un ensayo general para nuestro modelo. Implica entrenar el modelo en nuestra tarea espec铆fica utilizando PyTorch Lightning鹿, permiti茅ndole aprender de los art铆culos de moda presentes en nuestras im谩genes. De esta manera, cuando llegue el momento de la actuaci贸n real, nuestro modelo estar谩 listo para identificar y categorizar los art铆culos de moda de manera precisa.

Para hacer esto, utilizaremos PyTorch Lightning鹿, un envoltorio para PyTorch que simplifica el proceso de entrenamiento. Con PyTorch Lightning鹿, podemos definir f谩cilmente nuestro ciclo de entrenamiento, configurar nuestro optimizador y establecer nuestro programador de tasa de aprendizaje. Tambi茅n proporciona soporte incorporado para registrar m茅tricas, guardar puntos de control y m谩s.

Vamos a ajustar finamente un modelo existente, YOLOs-Fashionpedia鈦, que ya ha sido ajustado finamente en una tarea de detecci贸n de art铆culos de moda. Aqu铆 hay una versi贸n simplificada del proceso de ajuste fino:

class Yolos(pl.LightningModule):        def __init__(self, lr, weight_decay):        super().__init__()        self.model = AutoModelForObjectDetection.from_pretrained("valentinafeve/yolos-fashionpedia",                                                                  num_labels=46,                                                                 ignore_mismatched_sizes=True)        self.lr = lr        self.weight_decay = weight_decay    def forward(self, pixel_values):        outputs = self.model(pixel_values=pixel_values)        return outputs        def common_step(self, batch, batch_idx):        pixel_values = batch["pixel_values"]        labels = [{k: v.to(self.device) for k, v in t.items()} for t in batch["labels"]]        outputs = self.model(pixel_values=pixel_values, labels=labels)        loss = outputs.loss        loss_dict = outputs.loss_dict        return loss, loss_dict    def training_step(self, batch, batch_idx):        loss, loss_dict = self.common_step(batch, batch_idx)             self.log("training_loss", loss)        for k,v in loss_dict.items():            self.log("train_" + k, v.item())                return loss    def validation_step(self, batch, batch_idx):        loss, loss_dict = self.common_step(batch, batch_idx)             self.log("validation_loss", loss)        for k,v in loss_dict.items():            self.log("validation_" + k, v.item())                return loss    def test_step(self, batch, batch_idx):        loss, loss_dict = self.common_step(batch, batch_idx)             self.log("test_loss", loss)        for k,v in loss_dict.items():            self.log("test_" + k, v.item())                return loss    def configure_optimizers(self):        optimizer = torch.optim.AdamW(self.parameters(), lr=self.lr,                                  weight_decay=self.weight_decay)                return optimizer        def train_dataloader(self):        return train_dataloader        def val_dataloader(self):        return val_dataloader        def test_dataloader(self):        return test_dataloader

# Para guardar y ver los registros m谩s tarde  logger = CSVLogger("logs", name="detr_logs")    

En el ajuste fino de un modelo preentrenado como YOLO-Small utilizando transfer learning, se utilizan una tasa de aprendizaje m谩s baja y un decaimiento de peso para preservar las caracter铆sticas 煤tiles que el modelo ya ha aprendido y prevenir el sobreajuste en la nueva tarea. Una tasa de aprendizaje m谩s baja asegura que las actualizaciones de peso durante el entrenamiento sean incrementales y no interrumpan los patrones aprendidos previamente, permitiendo que el modelo se adapte sutilmente a la nueva tarea. Por otro lado, el decaimiento de peso ayuda a mantener pesos peque帽os, evitando as铆 el sobreajuste al asegurarse de que el modelo no dependa demasiado de ninguna caracter铆stica particular y se mantenga generalizado. Estos par谩metros logran un equilibrio entre aprovechar el poder del modelo preentrenado y adaptarlo efectivamente a la nueva tarea.

# Define el modelo y asigna la tasa de aprendizaje y el decaimiento de pesomodel = Yolos(lr=2.5e-5, weight_decay=1e-4)

Con fines ilustrativos, entren茅 el modelo durante un m谩ximo de 3 pasos de entrenamiento.

# Entrenar usando pytorch lightningtrainer = pl.Trainer(max_epochs=3, logger=logger, accelerator="cuda", devices=1)trainer.fit(model, train_dataloader, val_dataloader)

Despu茅s de entrenar el modelo, ahora puedes guardarlo y usarlo para realizar inferencias.

# Guardar el modelotrainer.save_checkpoint('./model/fashion_model.ckpt')

AGRUPANDO CATEGOR脥AS

Una vez que el modelo est谩 ajustado, 隆es hora de mostrarlo! Dada una imagen de una persona modelando prendas de moda, el modelo detectar谩 y clasificar谩 los art铆culos en 46 clases diferentes.

Sin embargo, mostrar las etiquetas de clases en bruto puede no ser la forma m谩s amigable para el usuario de presentar los resultados. Por lo tanto, decid铆 agrupar estas clases en categor铆as m谩s amplias como “Parte superior y prendas exteriores”, “Partes inferiores” y “Calzado”. Por ejemplo, las clases ‘camisa, blusa’ y ‘top, camiseta, sudadera’ se incluyen en la categor铆a ‘Parte superior y prendas exteriores’.

Aqu铆 est谩 el c贸digo Python para crear las correspondencias de grupos:

# Agrupar las categor铆as seg煤n los tiposgroup_tops_outerwear = ['camisa, blusa', 'top, camiseta, sudadera', 'su茅ter', 'c谩rdigan', 'chaqueta', 'chaleco', 'abrigo', 'capa', 'vestido', 'monos']group_bottoms = ['pantalones', 'shorts', 'falda']group_footwear = ['zapato', 'calcet铆n']group_accessories = ['gafas', 'sombrero', 'cinta para la cabeza, cobertura para la cabeza, accesorio para el cabello', 'corbata', 'guante', 'reloj', 'cintur贸n', 'calentador de piernas', 'medias', 'bolso, cartera', 'bufanda', 'paraguas']group_clothing_details = ['capucha', 'cuello', 'solapa', 'hombrera', 'manga', 'bolsillo', 'escote', 'hebilla', 'cremallera']group_embellishments = ['aplique', 'cuentas', 'lazo', 'flor', 'borla', 'cinta', 'remache', 'volante', 'lentejuela', 'borla']group_mapping = {}for category in group_tops_outerwear:    group_mapping[category] = 'Parte superior y prendas exteriores'for category in group_bottoms:    group_mapping[category] = 'Partes inferiores'for category in group_footwear:    group_mapping[category] = 'Calzado'for category in group_accessories:    group_mapping[category] = 'Accesorios'for category in group_clothing_details:    group_mapping[category] = 'Detalles de la ropa'for category in group_embellishments:    group_mapping[category] = 'Adornos'

Con estas correspondencias, podemos traducir la salida en bruto del modelo en categor铆as m谩s comprensibles. Un usuario puede ingresar una imagen de una persona modelando prendas de moda y el modelo mostrar谩 los art铆culos detectados, agrupados en categor铆as como ‘Parte superior y prendas exteriores’, ‘Partes inferiores’, ‘Calzado’, ‘Accesorios’, ‘Detalles de la ropa’ y ‘Adornos’.

Esto es un adelanto de c贸mo podr铆a lucir la salida:

Parte superior y prendas exteriores: top/camiseta/sudaderaDetalles de la ropa: bolsillo, escotePartes inferiores: pantalonesAdornos: remacheCalzado: zapato

Tambi茅n he agregado una funci贸n de codificaci贸n de colores para estas categor铆as, lo que hace que los resultados sean m谩s visualmente atractivos y f谩ciles de entender.

color_mapping = {    'Parte superior y prendas exteriores': '#FFC1E0',       # Rosa claro    'Partes inferiores': '#A7F7C0',                   # Verde claro    'Calzado': '#E1BEE7',                  # Morado claro    'Accesorios': '#FFD8B1',                # Naranja claro    'Detalles de la ropa': '#B3E5FC',           # Azul claro    'Adornos': '#FFF9C4'              # Amarillo claro}

INFERENCIA

Para usar el modelo para inferencia, espec铆ficamente para la detecci贸n de art铆culos de moda y para el etiquetado autom谩tico de productos, solo debes seguir los siguientes pasos:

# Cargar el extractor de caracter铆sticas preentrenado del modelo YOLO-smallfeature_extractor = YolosFeatureExtractor.from_pretrained('hustvl/yolos-small')# Cargar el modelo desde un punto de control, estableciendo la tasa de aprendizaje y la decaimiento del pesomodel_tags = Yolos.load_from_checkpoint(    checkpoint_path='./model/fashion_model.ckpt',  # Ruta hacia el punto de control    lr=2.5e-5,  # Tasa de aprendizaje para ajuste fino    weight_decay=1e-4  # Decaimiento del peso para regularizaci贸n)

Solo ejecuta las siguientes funciones auxiliares para la inferencia. Esto es solo un resumen de las funciones y tareas que mencion茅 anteriormente en este blog:

# Para el posprocesamiento de las cajas delimitadoras de salida en brutodef box_cxcywh_to_xyxy(x):    x_c, y_c, w, h = x.unbind(1)    b = [(x_c - 0.5 * w), (y_c - 0.5 * h),         (x_c + 0.5 * w), (y_c + 0.5 * h)]    return torch.stack(b, dim=1)def rescale_bboxes(out_bbox, size):    img_w, img_h = size    b = box_cxcywh_to_xyxy(out_bbox)    b = b * torch.tensor([img_w, img_h, img_w, img_h], dtype=torch.float32)    return bdef idx_to_text(i):    return cats_list[i]cats_list = ['camisa, blusa', 'top, camiseta, sudadera', 'su茅ter',              'c谩rdigan', 'chaqueta', 'chaleco', 'pantalones', 'shorts', 'falda',              'abrigo',

隆HORA DE MOSTRAR!

Trabajemos en una imagen. Para hacer esto, utiliza la funci贸n process_images().

  • image_path: acepta una lista de rutas de im谩genes, puedes poner una cadena de la ruta de una imagen dentro de una lista. Por ejemplo: ["images/0.jpg"].
  • threshold: por defecto es del 70% o 0.7. Se usa para mantener solo aquellas predicciones cuya puntuaci贸n de confianza m谩xima es mayor que el umbral.
  • show_image: por defecto es Verdadero. Esto es para controlar si deseas mostrar la imagen con los art铆culos de moda detectados dentro de cuadros delimitadores (Verdadero) o no (Falso).

隆Eso es todo! Vamos a probarlo en una sola imagen:

# Una sola imagen, show_image=TrueIMAGE_PATH = ["images/sample_01.jpg"]process_images(IMAGE_PATH, threshold=0.8, show_image=True);
Salida 1: Imagen individual con art铆culos de moda detectados e impresos. Foto original de Napat Saeng en Unsplash.

Si deseas utilizarlo para etiquetar autom谩ticamente art铆culos de moda y obtener solo los resultados impresos, puedes ingresar show_image=False en su lugar:

# Una sola imagen, show_image=FalseIMAGE_PATH = ["images/sample_01.jpg"]process_images(IMAGE_PATH, threshold=0.8, show_image=False);

Salida 2:images/sample_01.jpgAccesorios: reloj, gafasDetalles de la ropa: bolsillo, mangaTops y prendas exteriores: top/camiseta/sudaderaPartes inferiores: pantalones

Finalmente, si deseas utilizarlo para varias im谩genes, puedes especificar m煤ltiples rutas de im谩genes dentro del par谩metro image_paths o utilizar la siguiente funci贸n process_images_in_directory() y proporcionarle la ruta a tu directorio de im谩genes.

Opci贸n 1: m煤ltiples rutas de im谩genes

# M煤ltiples im谩genes, show_image=TrueIMAGE_PATH = ["images/sample_01.jpg", "images/sample_02.jpg", "images/sample_03.jpg", "images/sample_04.jpg"]process_images(IMAGE_PATH, threshold=0.8, show_image=False);

Opci贸n 2: utilizando la ruta de tu directorio de im谩genes

def process_images_in_directory(directory='./images', threshold=0.70, show_image=True):    # Define las extensiones de los archivos de imagen que te interesan    image_extensions = ['jpg', 'png', 'jpeg', 'JPG', 'PNG']    # Utiliza una comprensi贸n de listas para crear una lista de archivos para cada extensi贸n, luego combina estas listas    image_files = [glob.glob(f'{directory}/*.{ext}') for ext in image_extensions]    image_paths = [item for sublist in image_files for item in sublist]  # aplanar la lista    return process_images(image_paths, threshold=threshold, show_image=show_image)process_images_in_directory(directory='./images', threshold=0.8, show_image=True)

Ambas opciones tendr谩n la siguiente salida:

Salida #3-1: Primera imagen con art铆culos de moda detectados e impresos. Foto original de Javier Contreras en Unsplash
Salida #3-2: Segunda imagen con art铆culos de moda detectados e impresos. Foto original de Khaled Ghareeb en Unsplash
Salida #3鈥3: Tercera imagen con art铆culos de moda detectados e impresos. Foto original de Tamara Bellis en Unsplash
Salida #3鈥4: 脷ltima imagen con art铆culos de moda detectados e impresos. Foto original de Napat Saeng en Unsplash.

CONCLUSI脫N

El impacto potencial de este proyecto en el 谩mbito del comercio electr贸nico es considerable. Mediante la decodificaci贸n del c贸digo de vestimenta con la Detecci贸n Automatizada de Art铆culos de Moda, podemos agilizar el proceso de carga de nuevos productos, mejorando la eficiencia operativa. No se trata solo de identificar art铆culos de moda; se trata de mejorar la experiencia del cliente al proporcionar descripciones precisas de los productos y facilitar la b煤squeda eficiente de productos.

Adem谩s, esta tecnolog铆a se puede ampliar a otras aplicaciones como la gesti贸n de inventario, el an谩lisis de tendencias y las experiencias de compra personalizadas. Se trata de comprender el lenguaje de la moda y utilizarlo en nuestro beneficio.

CONCLUSI脫N

En esta exploraci贸n, hemos decodificado el c贸digo de vestimenta de la industria de la moda. Hemos utilizado la precisi贸n del DL, un modelo preentrenado, y PyTorch Lightning para automatizar el proceso de detecci贸n de art铆culos de moda y demostrar c贸mo podemos aprovechar el aprendizaje profundo para realizar el etiquetado autom谩tico de productos. Esto puede transformar una tarea que consume mucho tiempo en un proceso r谩pido y eficiente.

Al decodificar el c贸digo de vestimenta, hemos abierto un mundo de posibilidades en el 谩mbito del comercio electr贸nico. Esto es solo el comienzo. A medida que continuamos refinando estas tecnolog铆as, podemos esperar soluciones a煤n m谩s innovadoras y eficientes en el futuro.

NOTA

Esta publicaci贸n de blog tiene fines educativos y pretende proporcionar una descripci贸n general del proceso de uso de modelos preentrenados para la detecci贸n de objetos en la industria de la moda. La implementaci贸n real puede requerir pasos y consideraciones adicionales, dependiendo de los requisitos espec铆ficos de su proyecto. Pero dado los beneficios de automatizar tareas, es un viaje emocionante en el que definitivamente continuar铆a despu茅s de graduarme.

Puede acceder a mis archivos a trav茅s de mi repositorio de GitHub en: https://github.com/erikaglacson/Multiple_Object_Detection.git.

Referencias

  • [1] PyTorch Lightning. (s. f.). Recuperado de https://www.pytorchlightning.ai/
  • [2] Blin, J. (s. f.). Fashionpedia. Hugging Face. Recuperado el 27 de junio de 2023, de https://huggingface.co/datasets/detection-datasets/fashionpedia
  • [3] Jia, M., Shi, M., Sirotenko, M., Cui, Y., Cardie, C., Hariharan, B., Adam, H., & Belongie, S. (2020). Fashionpedia: Ontology, Segmentation, and an Attribute Localization Dataset. En Proceedings of the European Conference on Computer Vision (ECCV).
  • [4] Feruere Vega, V. (s. f.). YOLOS-fashionpedia. Hugging Face. Recuperado el 27 de junio de 2023, de https://huggingface.co/valentinafeve/yolos-fashionpedia
  • [5] Wang, X. (s. f.). YOLOS-small. Hugging Face. Recuperado el 27 de junio de 2023, de https://huggingface.co/hustvl/yolos-small
  • [6] Feruere Vega, V. (2023, 13 de junio). Fine tunning YOLOs for fashion [C贸digo fuente]. GitHub. https://github.com/valentinafeve/fine_tunning_YOLOS_for_fashion

We will continue to update Zepes; if you have any questions or suggestions, please contact us!

Share:

Was this article helpful?

93 out of 132 found this helpful

Discover more

Inteligencia Artificial

Nuevo ataque afecta a importantes chatbots de IA y nadie sabe c贸mo detenerlo

Investigadores encontraron una forma sencilla de hacer que ChatGPT, Bard y otros chatbots se comporten mal, demostran...

Inteligencia Artificial

Conoce FLM-101B Un decodificador de solo lectura de LLM de c贸digo abierto con 101 mil millones de par谩metros

脷ltimamente, los modelos de lenguaje grandes (LLMs) est谩n destacando en tareas de NLP y multimodalidad, pero se enfre...

Inteligencia Artificial

Anal贸gico y Digital Lo Mejor de Ambos Mundos en un Sistema Eficiente en Energ铆a

Un nuevo dispositivo combina semiconductores bidimensionales ultrafinos y materiales ferroel茅ctricos, con el objetivo...

Inteligencia Artificial

GPT-Engineer Tu nuevo asistente de programaci贸n de IA

GPT-Engineer es un constructor de aplicaciones impulsado por IA que genera bases de c贸digo a partir de descripciones ...