Decodifica del Codice di Abbigliamento 👗 Deep Learning per la Rilevazione Automatica degli Indumenti di Moda
Decoding Dress Code 👗 Deep Learning for Automatic Fashion Apparel Detection
Foto originale di Tamara Bellis su Unsplash, elaborata dall’autore.
Nel vivace mondo dell’e-commerce, l’industria della moda è una passerella tutta sua. Ma cosa succederebbe se potessimo decodificare il codice di abbigliamento di questa passerella, non con l’occhio di un designer, ma con la precisione del Deep Learning (DL)? Oggi, andremo a svelare i fili di questa intrigante possibilità. Utilizzeremo un modello preaddestrato e PyTorch Lightning¹ per automatizzare il processo di etichettatura dei prodotti, trasformando un compito che richiede molto tempo in un processo rapido ed efficiente. Questo non è solo un pass backstage nel mondo del DL nella moda, è un posto in prima fila per una rivoluzione nelle operazioni di e-commerce. Quindi, se sei pronto a vedere come il deep learning può decodificare il codice di abbigliamento del mondo della moda digitale, mettiti comodo!
Questo blog è diviso in due parti chiave: ‘ Fine-Tuning di un Modello Preaddestrato ‘ e ‘ Inferenza ‘. La parte ‘ Fine-Tuning di un Modello Preaddestrato ‘ inizia nella sezione successiva fino alla sezione Fine Tuning con PyTorch Lightning in cui fornisco una dimostrazione dettagliata di come possiamo regolare un modello preaddestrato per adattarlo meglio alle nostre specifiche esigenze di rilevamento degli articoli di moda. Nel frattempo, la parte ‘ Inferenza ‘ è dedicata a coloro che desiderano utilizzare immediatamente il modello per il rilevamento di più articoli di moda. Sentiti libero di passare direttamente alla sezione Inferenza se sei desideroso di vedere il modello in azione.
PREPARARE IL PALCOSCENICO
Per iniziare il nostro spettacolo di moda, dobbiamo preparare il palcoscenico configurando il nostro ambiente Python con PyTorch Lightning¹ – un wrapper PyTorch che semplifica la gestione del codice e accelera l’addestramento del modello. Inoltre, incorporeremo i pacchetti essenziali di seguito per l’addestramento e l’inferenza:
# Importa le librerie necessarie per la manipolazione e la visualizzazione dei dati
import random
import numpy as np
import matplotlib.pyplot as plt
import shutil
import glob
import os
# Librerie per l'elaborazione delle immagini
from PIL import Image, ImageDraw
# Utility per scaricare un file dal modello Hugging Face Hub
from huggingface_hub import hf_hub_download
# Funzione per dividere i dati in set di addestramento e test
from sklearn.model_selection import train_test_split
# Librerie per la gestione dei dataset
import datasets
from datasets import load_dataset, concatenate_datasets, DatasetDict
# PyTorch Lightning per l'addestramento ad alta performance
import lightning as pl
from lightning import Trainer
# PyTorch per la creazione e l'addestramento di reti neurali
import torch
import torch.nn as nn
# DataLoader per creare un'iterazione sul dataset
from torch.utils.data import DataLoader
# Librerie per le trasformazioni delle immagini
from torchvision import transforms
from torchvision.transforms import ToPILImage, ToTensor
# Libreria Transformers per la gestione dei modelli
from transformers import AutoModelForObjectDetection, YolosFeatureExtractor, YolosForObjectDetection
CARICAMENTO DEI DATI
Il dataset per questo progetto è il dataset Fashionpedia ², ospitato su Hugging Face, che contiene oltre 46.000 immagini con annotazioni di bounding box per più oggetti di moda. Questo dataset è un sottoinsieme di Fashionpedia ³, che è un dataset di moda su larga scala in cui ogni immagine è annotata con maschere di segmentazione e attributi di moda dettagliati. È un dataset ricco che è perfetto per il nostro compito di rilevamento degli articoli di moda.
Per utilizzare il dataset, carichiamolo utilizzando la libreria Hugging Face datasets. Per questo progetto, ho utilizzato solo il 30% del dataset solo per dimostrare come addestrare ulteriormente un modello preaddestrato per un compito di rilevamento degli articoli di moda:
# Carica il 30% del dataset di addestramento
dataset = load_dataset("detection-datasets/fashionpedia", split='train[:30%]')
# Genera gli indici di divisione
train_val_test_split = dataset.train_test_split(test_size=0.2, seed=42) # 80% di addestramento, 20% per validazione e test
val_test_split = train_val_test_split['test'].train_test_split(test_size=0.5, seed=42) # Dividi il 20% in modo equo tra validazione e test
# Salva le divisioni in un DatasetDict
final_splits = DatasetDict({
'train': train_val_test_split['train'],
'val': val_test_split['train'],
'test': val_test_split['test']
})
# Scompatta il DatasetDict in dataset di addestramento, validazione e test
train_dataset, val_dataset, test_dataset = final_splits['train'], final_splits['val'], final_splits['test']
I nostri dataset di allenamento, validazione e test dovrebbero apparire così:
image_id: Un ID numerico unico assegnato a ciascuna immagine.
image: Un’istanza della classe PIL.Image.Image che rappresenta l’immagine.
width: La larghezza dell’immagine.
height: L’altezza dell’immagine.
objects: Un dizionario che contiene metadati relativi ai bounding box degli oggetti presenti nell’immagine.
bbox_id: Un ID numerico unico assegnato a ciascuna annotazione di bounding box.
category: La categoria dell’oggetto.
area: L’area coperta dal bounding box.
bbox: Le coordinate del bounding box dell’oggetto nel formato Pascal VOC.
MODELLI PRETRAINED E TRASFERIMENTO DI APPRENDIMENTO
Come accennato in precedenza, in questo blog sfrutteremo il potere dei modelli pretrained. Questi modelli, allenati su grandi dataset, hanno già imparato molte caratteristiche e pattern. Utilizzando questi modelli, possiamo sfruttare il loro apprendimento e applicarlo al nostro specifico compito. Questo è particolarmente utile quando abbiamo una quantità limitata di dati per il nostro compito o quando vogliamo risparmiare tempo e risorse computazionali.
Nel nostro caso, utilizzeremo il modello YOLOs-Fashionpedia ⁴, che è stato preaddestrato sull’architettura YOLO-Small⁵. Questo modello ha già imparato a rilevare vari articoli di moda, rendendolo un punto di partenza perfetto per il nostro compito.
FUNZIONI DI SUPPORTO
Nel corso dell’esecuzione di questo progetto, ho scoperto una risorsa sostanziale nel repository GitHub di Valentina Feruere Vega⁶. Questo repository forniva una guida completa sulla messa a punto del dataset Fashionpedia, un processo che è stato fondamentale per questo progetto. Per semplificare la gestione del nostro dataset e renderlo compatibile con il modello YOLO-Small, ho compilato un insieme di funzioni di supporto. Queste funzioni sono specificamente progettate per conciliare la discrepanza tra il formato del bounding box (bbox) utilizzato nel dataset Fashionpedia (x1, x2, y1, y2) e il formato richiesto da YOLO-Small (x_center, y_center, width, height):
Per preprocessare le immagini del dataset, che sono memorizzate come oggetti PILImage, utilizzeremo il YOLOS Feature Extractor. Questo estrattore di caratteristiche trasformerà le immagini in un formato tensore composto da valori numerici. Questo passaggio di preprocessing è essenziale per ulteriori analisi e manipolazioni delle immagini all’interno del framework YOLOS.
# Carica il nostro estrattore di caratteristiche: yolos-smallfeature_extractor = YolosFeatureExtractor.from_pretrained('hustvl/yolos-small', size=816, max_size=864)
Ora possiamo applicare le seguenti trasformazioni per renderlo compatibile con il modello:
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": [object['category'] for object in batch['objects']], "image_id": torch.Tensor([batch['image_id']]).int(), "area": [object['area'] for object 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
# Applica le trasformazioni per renderlo compatibile con il modelloprepared_train = train_dataset.with_transform(transform)prepared_val = val_dataset.with_transform(transform)prepared_test = test_dataset.with_transform(transform)
Per semplificare il processo di addestramento con i batch, è necessaria una funzione collator. Questa funzione prende una lista di input, tipicamente dizionari in questo contesto, e li trasforma in un singolo input in cui i dati sono impilati. In altre parole, una lista di dizionari verrà convertita in un dizionario in cui i valori di ciascuna chiave diventano un vettore. Questa funzione collator svolge un ruolo cruciale nell’addestramento efficiente di un modello organizzando i dati in strutture adatte ai batch.
def collate_fn(batch): collated = {} collated["pixel_values"] = feature_extractor.pad([item['pixel_values'] for item in batch], return_tensors="pt")['pixel_values'] collated["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) collated["labels"].append(item['labels']) return collated
# Il seguente sarà utilizzato per caricare i batch nel modelloBATCH_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)
OTTIMIZZAZIONE DEL MODELLO CON PYTORCH LIGHTNING
Con il nostro palcoscenico pronto e i nostri interpreti pronti, è tempo della prova generale.
L’ottimizzazione del modello è simile a una prova generale per il nostro modello. Coinvolge l’addestramento del modello sul nostro compito specifico utilizzando PyTorch Lightning¹, consentendogli di imparare dagli articoli di moda presenti nelle nostre immagini. In questo modo, quando è il momento della performance effettiva, il nostro modello è pronto per identificare e categorizzare accuratamente gli articoli di moda.
Per fare ciò, useremo PyTorch Lightning¹, un wrapper per PyTorch che semplifica il processo di addestramento. Con PyTorch Lightning¹, possiamo facilmente definire il nostro ciclo di addestramento, configurare il nostro ottimizzatore e impostare il nostro scheduler del tasso di apprendimento. Fornisce anche supporto integrato per la registrazione delle metriche, il salvataggio dei checkpoint e altro ancora.
Facciamo l’ottimizzazione di un modello esistente, YOLOs-Fashionpedia⁴, che è già stato ottimizzato per un compito di rilevamento degli articoli di moda. Ecco una versione semplificata del processo di ottimizzazione:
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
# Per salvare e visualizzare i log in seguito logger = CSVLogger("logs", name="detr_logs")
Nell’ottimizzazione di un modello preaddestrato come YOLO-Small utilizzando il transfer learning, viene utilizzato un tasso di apprendimento più basso e una decadimento dei pesi per preservare le caratteristiche utili che il modello ha già appreso e prevenire l’overfitting nel nuovo compito. Un tasso di apprendimento più basso assicura che gli aggiornamenti dei pesi durante l’addestramento siano incrementali e non interrompano i pattern già appresi in precedenza, consentendo così al modello di adattarsi in modo sottile al nuovo compito. Il decadimento dei pesi, d’altra parte, aiuta a mantenere i pesi piccoli, prevenendo così l’overfitting garantendo che il modello non si basi troppo su una particolare caratteristica e rimanga generalizzato. Questi parametri trovano un equilibrio tra sfruttare la potenza del modello preaddestrato e adattarlo efficacemente al nuovo compito.
# Definisci il modello e assegna il tasso di apprendimento e il decadimento dei pesi model = Yolos(lr=2.5e-5, weight_decay=1e-4)
A scopo illustrativo, ho addestrato il modello per un massimo di 3 passaggi di addestramento.
Dopo aver addestrato il modello, è possibile salvarlo e utilizzarlo per l’inferenza.
# Salva il modellotrainer.save_checkpoint('./model/fashion_model.ckpt')
RAGGRUPPAMENTO DELLE CATEGORIE
Una volta che il modello è stato perfezionato, è il momento di metterlo in mostra! Dato un’immagine di una persona che indossa capi di moda, il modello rileverà e classificherà gli articoli in 46 diverse categorie.
Tuttavia, la visualizzazione delle etichette di classe grezze potrebbe non essere il modo più user-friendly per presentare i risultati. Pertanto, ho deciso di raggruppare queste categorie in categorie più ampie come “Tops and Outerwear” (Cime e Giacche), “Bottoms” (Pantaloni e Gonne) e “Footwear” (Calzature). Ad esempio, le categorie ‘shirt, blouse’ (camicia, blusa) e ‘top, t-shirt, sweatshirt’ (top, t-shirt, maglia) rientrano entrambe nella categoria ‘Tops and Outerwear’.
Ecco il codice Python per creare le corrispondenze di gruppo:
# Raggruppa le categorie in base ai tipigroup_tops_outerwear = ['shirt, blouse', 'top, t-shirt, sweatshirt', 'sweater', 'cardigan', 'jacket', 'vest', 'coat', 'cape', 'dress', 'jumpsuit']group_bottoms = ['pants', 'shorts', 'skirt']group_footwear = ['shoe', 'sock']group_accessories = ['glasses', 'hat', 'headband, head covering, hair accessory', 'tie', 'glove', 'watch', 'belt', 'leg warmer', 'tights, stockings', 'bag, wallet', 'scarf', 'umbrella']group_clothing_details = ['hood', 'collar', 'lapel', 'epaulette', 'sleeve', 'pocket', 'neckline', 'buckle', 'zipper']group_embellishments = ['applique', 'bead', 'bow', 'flower', 'fringe', 'ribbon', 'rivet', 'ruffle', 'sequin', 'tassel']group_mapping = {}for category in group_tops_outerwear: group_mapping[category] = 'Tops and Outerwear'for category in group_bottoms: group_mapping[category] = 'Bottoms'for category in group_footwear: group_mapping[category] = 'Footwear'for category in group_accessories: group_mapping[category] = 'Accessori'for category in group_clothing_details: group_mapping[category] = 'Dettagli Abbigliamento'for category in group_embellishments: group_mapping[category] = 'Decorazioni'
Con queste corrispondenze, possiamo tradurre l’output grezzo del modello in categorie più comprensibili. Un utente può inserire un’immagine di una persona che indossa capi di moda e il modello restituirà gli articoli rilevati, raggruppati in categorie come ‘Tops and Outerwear’, ‘Bottoms’, ‘Footwear’, ‘Accessori’, ‘Dettagli Abbigliamento’ e ‘Decorazioni’.
Ecco un’anteprima di come potrebbe apparire l’output:
Tops and Outerwear: top/maglia/sweatshirtDettagli Abbigliamento: tasca, scolloBottoms: pantaloniDecorazioni: rivettoFootwear: scarpa
Ho anche aggiunto una funzione di codifica a colori per queste categorie, rendendo i risultati più attraenti e facili da comprendere.
Per utilizzare il modello per l’inferenza, specificamente per la rilevazione di capi di moda e per l’etichettatura automatica dei prodotti, è sufficiente eseguire i seguenti passaggi:
# Carica l'estratore di caratteristiche preaddestrato dal modello YOLO-smallfeature_extractor = YolosFeatureExtractor.from_pretrained('hustvl/yolos-small')# Carica il modello da un checkpoint, impostando il tasso di apprendimento e la riduzione del peso del modell
ORA DI MOSTRARE!
Lavoriamo su un'immagine. Per farlo, utilizza la funzione process_images().
image_path : accetta una lista di percorsi delle immagini, puoi inserire una stringa di un percorso immagine all'interno di una lista. Esempio: ["images/0.jpg"].
threshold : di default è impostato al 70% o 0.7. Viene utilizzato per mantenere solo quelle previsioni il cui punteggio di confidenza massimo è maggiore della soglia.
show_image : di default è impostato su True. Questo serve per controllare se vuoi visualizzare l'immagine con gli elementi di moda rilevati all'interno dei bounding box (True) o no (False).
Infine, se vuoi utilizzarlo per più immagini, puoi specificare più percorsi immagine all'interno del parametroimage_pathso utilizzare la seguenteprocess_images_in_directory()funzione e fornire il percorso della tua directory immagine.
Opzione 2: utilizzo del percorso della tua directory immagine
def process_images_in_directory(directory='./images', threshold=0.70, show_image=True): # Definisci le estensioni per i file immagine di tuo interesse image_extensions = ['jpg', 'png', 'jpeg', 'JPG', 'PNG'] # Utilizza una list comprehension per creare una lista di file per ogni estensione, quindi combina queste liste image_files = [glob.glob(f'{directory}/*.{ext}') for ext in image_extensions] image_paths = [item for sublist in image_files for item in sublist] # appiattisci 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)
Entrambe le opzioni produrranno quanto segue:
Output #3-1: Prima immagine con elementi di moda rilevati e stampati. Foto originale di Javier Contreras su UnsplashOutput #3–2: Seconda immagine con elementi di moda rilevati e stampati. Foto originale di Khaled Ghareeb su UnsplashOutput #3–3: Terza immagine con rilevamento e stampa di articoli di moda. Foto originale di Tamara Bellis su UnsplashOutput #3–4: Ultima immagine con rilevamento e stampa di articoli di moda. Foto originale di Napat Saeng su Unsplash .
CONCLUSIONI
Il potenziale impatto di questo progetto nel campo dell'e-commerce è notevole. Decodificando il codice di abbigliamento con il rilevamento automatico degli articoli di moda, possiamo accelerare il processo di caricamento dei nuovi prodotti, migliorando l'efficienza operativa. Non si tratta solo di identificare gli articoli di moda; si tratta di migliorare l'esperienza del cliente fornendo descrizioni accurate del prodotto e facilitando la ricerca efficiente del prodotto.
Inoltre, questa tecnologia può essere estesa ad altre applicazioni come la gestione dell'inventario, l'analisi delle tendenze e le esperienze di shopping personalizzate. Si tratta di capire il linguaggio della moda e usarlo a nostro vantaggio.
CONCLUSIONE
In questa esplorazione, abbiamo decodificato il codice di abbigliamento del settore della moda. Abbiamo utilizzato la precisione di DL, un modello preaddestrato, e PyTorch Lightning per automatizzare il processo di rilevamento degli articoli di moda e per dimostrare come possiamo sfruttare il deep learning per eseguire l'etichettatura automatica dei prodotti. Questo può trasformare un compito che richiede tempo in un processo rapido ed efficiente.
Decodificando il codice di abbigliamento, abbiamo aperto un mondo di possibilità nel campo dell'e-commerce. Questo è solo l'inizio. Continuando a perfezionare queste tecnologie, possiamo aspettarci soluzioni ancora più innovative ed efficienti in futuro.
NOTA
Questo post del blog è destinato a scopi educativi e intende fornire una panoramica generale del processo di utilizzo di modelli preaddestrati per il rilevamento degli oggetti nel settore della moda. L'implementazione effettiva potrebbe richiedere passaggi e considerazioni aggiuntive, a seconda dei requisiti specifici del vostro progetto. Ma data la possibilità di automatizzare i compiti, si tratta di un percorso entusiasmante che sicuramente continuerò dopo la laurea.
Potete accedere ai miei file tramite il mio repository GitHub su: https://github.com/erikaglacson/Multiple_Object_Detection.git .
Riferimenti
[1] PyTorch Lightning. (s.d.). Recuperato da https://www.pytorchlightning.ai/
[2] Blin, J. (s.d.). Fashionpedia. Hugging Face. Recuperato il 27 giugno 2023, da 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. In Proceedings of the European Conference on Computer Vision (ECCV).
[4] Feruere Vega, V. (s.d.). YOLOS-fashionpedia. Hugging Face. Recuperato il 27 giugno 2023, da https://huggingface.co/valentinafeve/yolos-fashionpedia
[5] Wang, X. (s.d.). YOLOS-small. Hugging Face. Recuperato il 27 giugno 2023, da https://huggingface.co/hustvl/yolos-small
[6] Feruere Vega, V. (2023, 13 giugno). Fine tuning YOLOs for fashion [Codice sorgente]. GitHub. https://github.com/valentinafeve/fine_tunning_YOLOS_for_fashion
