Déchiffrer le code vestimentaire 👗 Apprentissage profond pour la détection automatisée d’articles de mode
'Décoder le code vestimentaire 🧥 Apprentissage profond pour détecter automatiquement les vêtements'
Photo originale de Tamara Bellis sur Unsplash, traitée par l’auteur.
Dans le monde dynamique du commerce électronique, l’industrie de la mode est un défilé à part entière. Mais et si nous pouvions décoder le code vestimentaire de ce défilé, non pas avec l’œil d’un designer, mais avec la précision de l’apprentissage profond (Deep Learning – DL) ? Aujourd’hui, nous allons démêler les fils de cette possibilité intrigante. Nous utiliserons un modèle pré-entraîné et PyTorch Lightning¹ pour automatiser le processus d’étiquetage des produits, transformant une tâche chronophage en un processus rapide et efficace. Ce n’est pas seulement un pass backstage vers le monde du DL dans la mode, c’est une place au premier rang pour une révolution dans les opérations de commerce électronique. Alors, si vous êtes prêt à voir comment l’apprentissage profond peut décoder le code vestimentaire du monde de la mode numérique, préparez-vous !
Ce blog est divisé en deux parties clés : ‘ Adaptation d’un modèle pré-entraîné ‘ et ‘ Inférence ‘. La partie ‘ Adaptation d’un modèle pré-entraîné ‘ commence dans la prochaine section jusqu’à la section Finetuning avec Pytorch Lightning où je présente une démonstration détaillée de la façon dont nous pouvons ajuster un modèle pré-entraîné pour mieux répondre à nos besoins spécifiques en matière de détection d’articles de mode. Pendant ce temps, la partie ‘ Inférence ‘ est dédiée à ceux qui souhaitent utiliser immédiatement le modèle pour la détection de plusieurs articles de mode. N’hésitez pas à passer directement à la section Inférence si vous êtes impatient de voir le modèle en action.
PRÉPARER LE TERRAIN
Pour commencer notre défilé de mode, nous devons préparer le terrain en configurant notre environnement Python avec PyTorch Lightning¹ – une enveloppe PyTorch qui simplifie la gestion du code et accélère l’entraînement du modèle. De plus, nous allons incorporer les packages essentiels ci-dessous pour l’entraînement et l’inférence :
# Importation des bibliothèques nécessaires à la manipulation et à la visualisation des donnéesimport randomimport numpy as npimport matplotlib.pyplot as pltimport shutilimport globimport os# Bibliothèques pour le traitement des imagesfrom PIL import Image, ImageDraw# Utilitaire pour télécharger un fichier depuis le hub de modèles Hugging Facefrom huggingface_hub import hf_hub_download# Fonction pour diviser vos données en ensembles d'entraînement et de testfrom sklearn.model_selection import train_test_split# Bibliothèques pour la manipulation des ensembles de donnéesimport datasetsfrom datasets import load_dataset, concatenate_datasets, DatasetDict# PyTorch Lightning pour l'entraînement haute performanceimport lightning as plfrom lightning import Trainer# PyTorch pour la construction et l'entraînement de réseaux neuronauximport torchimport torch.nn as nn# DataLoader pour créer un itérable sur l'ensemble de donnéesfrom torch.utils.data import DataLoader# Bibliothèques pour les transformations d'imagesfrom torchvision import transformsfrom torchvision.transforms import ToPILImage, ToTensor# Bibliothèque Transformers pour la gestion des modèlesfrom transformers import AutoModelForObjectDetectionfrom transformers import YolosFeatureExtractor, YolosForObjectDetection
CHARGEMENT DES DONNÉES
Le jeu de données de ce projet est le jeu de données Fashionpedia ², hébergé sur Hugging Face, contenant plus de 46 000 images avec des annotations de boîtes englobantes pour plusieurs objets de mode. Ce jeu de données est un sous-ensemble de Fashionpedia ³ qui est un ensemble de données de mode à grande échelle où chaque image est annotée avec des masques de segmentation et des attributs de mode détaillés. C’est un jeu de données riche qui est parfait pour notre tâche de détection d’articles de mode.
Pour utiliser le jeu de données, chargeons-le en utilisant la bibliothèque de jeux de données Hugging Face. Pour ce projet, j’ai seulement utilisé 30% du jeu de données pour démontrer comment affiner un modèle pré-entraîné existant pour une tâche de détection d’articles de mode :
# Charger 30% de l'ensemble de données d'entraînementdataset = load_dataset("detection-datasets/fashionpedia", split='train[:30%]')# Générer les indices de divisiontrain_val_test_split = dataset.train_test_split(test_size=0.2, seed=42) # 80% d'entraînement, 20% pour la validation et les testsval_test_split = train_val_test_split['test'].train_test_split(test_size=0.5, seed=42) # Diviser les 20% également en validation et en test# Stocker les divisions dans un DatasetDictfinal_splits = DatasetDict({ 'train': train_val_test_split['train'], 'val': val_test_split['train'], 'test': val_test_split['test']})# Déballer le DatasetDict pour obtenir les ensembles d'entraînement, de validation et de testtrain_dataset, val_dataset, test_dataset = final_splits['train'], final_splits['val'], final_splits['test']
Nos ensembles de données d’entraînement, de validation et de test devraient ressembler à ceci :
L’ensemble de données possède les champs suivants² :
image_id : Un ID numérique unique attribué à chaque image.
image : Une instance de la classe PIL.Image.Image qui représente l’image.
width : La largeur de l’image.
height : La hauteur de l’image.
objects : Un dictionnaire contenant des métadonnées relatives aux boîtes englobantes des objets présents dans l’image.
bbox_id : Un ID numérique unique attribué à chaque annotation de boîte englobante.
category : La catégorie de l’objet.
area : La surface couverte par la boîte englobante.
bbox : Les coordonnées de la boîte englobante de l’objet dans le format Pascal VOC.
MODÈLES PRÉENTRAÎNÉS ET TRANSFERT DE CONNAISSANCES
Comme mentionné précédemment, dans ce blog, nous allons exploiter la puissance des modèles préentraînés. Ces modèles, entraînés sur de grands ensembles de données, ont déjà appris de nombreuses caractéristiques et motifs. En utilisant ces modèles, nous pouvons exploiter leur apprentissage et l’appliquer à notre tâche spécifique. Cela est particulièrement utile lorsque nous disposons d’une quantité limitée de données pour notre tâche ou lorsque nous souhaitons économiser du temps et des ressources informatiques.
Dans notre cas, nous utiliserons le modèle YOLOs-Fashionpedia ⁴, qui a été pré-entraîné sur l’architecture YOLO-Small⁵. Ce modèle a déjà appris à détecter divers articles de mode, ce qui en fait un point de départ parfait pour notre tâche.
FONCTIONS D’AIDE
Au cours de l’exécution de ce projet, j’ai découvert une ressource importante dans le référentiel GitHub de Valentina Feruere Vega⁶. Ce référentiel fournissait un guide complet sur l’affinage du jeu de données Fashionpedia, un processus qui était essentiel pour ce projet. Pour simplifier la manipulation de notre jeu de données et le rendre compatible avec le modèle YOLO-Small, j’ai compilé un ensemble de fonctions d’aide. Ces fonctions sont spécifiquement conçues pour concilier la différence entre le format de la boîte englobante (bbox) utilisé dans le jeu de données Fashionpedia (x1, x2, y1, y2) et le format requis par YOLO-Small (x_center, y_center, largeur, hauteur) :
Pour prétraiter les images du jeu de données, qui sont stockées en tant qu’objets PILImage, nous utiliserons le Extracteur de fonctionnalités YOLOS. Cet extracteur de fonctionnalités transformera les images en un format tensoriel composé de valeurs numériques. Cette étape de prétraitement est essentielle pour une analyse et une manipulation ultérieures des images dans le cadre de YOLOS.
Maintenant, nous pouvons appliquer les transformations suivantes pour les rendre compatibles avec le modèle :
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
# Appliquer les transformations pour les rendre compatibles avec le modèleprepared_train = train_dataset.with_transform(transform)prepared_val = val_dataset.with_transform(transform)prepared_test = test_dataset.with_transform(transform)
Pour simplifier le processus de formation avec des lots, une fonction de regroupement est nécessaire. Cette fonction prend une liste d’entrées, généralement des dictionnaires dans ce contexte, et les transforme en une seule entrée où les données sont empilées. En d’autres termes, une liste de dictionnaires sera convertie en un dictionnaire où les valeurs de chaque clé deviennent un vecteur. Cette fonction de regroupement joue un rôle crucial dans la formation efficace d’un modèle en organisant les données dans des structures compatibles avec les lots.
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
# Ce qui suit sera utilisé pour charger les lots dans le modèleBATCH_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)
AFFINAGE AVEC PYTORCH LIGHTNING
Avec notre scène préparée et nos acteurs prêts, il est temps pour les répétitions.
L’affinage est comme une répétition générale pour notre modèle. Cela implique de former le modèle sur notre tâche spécifique en utilisant PyTorch Lightning¹, lui permettant d’apprendre à partir des articles de mode présents dans nos images. De cette façon, lorsque vient le moment de la représentation réelle, notre modèle est prêt à identifier et catégoriser avec précision les articles de mode.
Pour ce faire, nous utiliserons PyTorch Lightning¹, un wrapper pour PyTorch qui simplifie le processus de formation. Avec PyTorch Lightning¹, nous pouvons facilement définir notre boucle d’entraînement, configurer notre optimiseur et mettre en place notre planificateur de taux d’apprentissage. Il offre également une prise en charge intégrée pour l’enregistrement des métriques, la sauvegarde des points de contrôle, et plus encore.
Affinons un modèle existant, YOLOs-Fashionpedia⁴, qui a déjà été affiné pour une tâche de détection d’articles de mode. Voici une version simplifiée du processus d’affinage :
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
# Pour enregistrer et afficher les journaux plus tard logger = CSVLogger("logs", name="detr_logs")
Lors de l’affinage d’un modèle pré-entraîné comme YOLO-Small en utilisant le transfert d’apprentissage, un taux d’apprentissage plus bas et une décroissance du poids sont utilisés pour préserver les caractéristiques utiles que le modèle a déjà apprises et éviter le surajustement à la nouvelle tâche. Un taux d’apprentissage plus bas garantit que les mises à jour de poids pendant l’entraînement sont progressives et ne perturbent pas les motifs déjà appris, permettant ainsi au modèle de s’adapter subtilement à la nouvelle tâche. La décroissance du poids, quant à elle, aide à maintenir de petits poids, évitant ainsi le surajustement en veillant à ce que le modèle ne dépende pas trop d’une caractéristique particulière et reste généralisé. Ces paramètres trouvent un équilibre entre l’exploitation de la puissance du modèle pré-entraîné et son adaptation efficace à la nouvelle tâche.
# Définir le modèle et attribuer le taux d'apprentissage et la décroissance du poidsmodel = Yolos(lr=2.5e-5, weight_decay=1e-4)
À des fins d’illustration, j’ai entraîné le modèle pendant un maximum de 3 étapes d’entraînement.
Après avoir entraîné le modèle, vous pouvez maintenant le sauvegarder et l’utiliser pour l’inférence.
# Sauvegarder le modèletrainer.save_checkpoint('./model/fashion_model.ckpt')
REGROUPER LES CATÉGORIES
Une fois que le modèle est affiné, c’est l’heure du spectacle ! Étant donné une image d’une personne modélisant des articles de mode, le modèle détectera et classera les articles en 46 classes différentes.
Cependant, la sortie des libellés de classe bruts peut ne pas être la manière la plus conviviale de présenter les résultats. C’est pourquoi j’ai décidé de regrouper ces classes en catégories plus larges telles que “Hauts et vêtements d’extérieur”, “Bas” et “Chaussures”. Par exemple, les classes ‘chemise, blouse’ et ‘haut, t-shirt, sweatshirt’ appartiennent toutes deux à la catégorie ‘Hauts et vêtements d’extérieur’.
Voici le code Python pour créer les correspondances de groupe :
# Regrouper les catégories selon les typesgroup_tops_outerwear = ['chemise, blouse', 'haut, t-shirt, sweatshirt', 'pull', 'cardigan', 'veste', 'gilet', 'manteau', 'cape', 'robe', 'combi-pantalon']group_bottoms = ['pantalon', 'shorts', 'jupe']group_footwear = ['chaussure', 'chaussette']group_accessories = ['lunettes', 'chapeau', 'bandeau, couvre-chef, accessoire pour cheveux', 'cravate', 'gant', 'montre', 'ceinture', 'chauffe-jambes', 'collants, bas', 'sac, portefeuille', 'écharpe', 'parapluie']group_clothing_details = ['capuche', 'col', 'liseré', 'épaulette', 'manche', 'poche', 'encolure', 'boucle', 'fermeture éclair']group_embellishments = ['applique', 'perle', 'nœud', 'fleur', 'frange', 'ruban', 'rivet', 'volant', 'paillette', 'pompon']group_mapping = {}for category in group_tops_outerwear: group_mapping[category] = 'Hauts et vêtements d\'extérieur'for category in group_bottoms: group_mapping[category] = 'Bas'for category in group_footwear: group_mapping[category] = 'Chaussures'for category in group_accessories: group_mapping[category] = 'Accessoires'for category in group_clothing_details: group_mapping[category] = 'Détails des vêtements'for category in group_embellishments: group_mapping[category] = 'Ornements'
Avec ces correspondances, nous pouvons traduire la sortie brute du modèle en catégories plus compréhensibles. Un utilisateur peut entrer une image d’une personne modélisant des articles de mode, et le modèle affichera les articles détectés, regroupés en catégories telles que ‘Hauts et vêtements d’extérieur’, ‘Bas’, ‘Chaussures’, ‘Accessoires’, ‘Détails des vêtements’ et ‘Ornements’.
Voici un aperçu de ce à quoi pourrait ressembler la sortie :
Hauts et vêtements d'extérieur : haut/t-shirt/sweatshirtDétails des vêtements : poche, encolureBas : pantalonOrnements : rivetChaussures : chaussure
J’ai également ajouté une fonctionnalité de codage couleur pour ces catégories, ce qui rend les résultats plus attrayants visuellement et plus faciles à comprendre.
color_mapping = { 'Hauts et vêtements d\'extérieur': '#FFC1E0', # Rose clair 'Bas': '#A7F7C0', # Vert clair 'Chaussures': '#E1BEE7', # Violet clair 'Accessoires': '#FFD8B1', # Orange clair 'Détails des vêtements': '#B3E5FC', # Bleu clair 'Ornements': '#FFF9C4' # Jaune clair}
DÉDUCTION
Pour utiliser le modèle pour la déduction, spécifiquement pour la détection d’articles de mode ainsi que pour l’étiquetage automatique des produits, il suffit d’effectuer les étapes suivantes :
# Charger l'extracteur de caractéristiques pré-entraîné à partir du modèle YOLO-smallfeature_extractor = YolosFeatureExtractor.from_pretrained('hustvl/yolos-small')# Charger le modèle à partir d'un point de contrôle, en définissant le taux d'apprentissage et la décroissance du poidsmodel_tags = Yolos.load_from_checkpoint( checkpoint_path='./model/fashion_model.ckpt', # Chemin vers le point de contrôle lr=2.5e-5, # Taux d'apprentissage pour l'affinage weight_decay=1e-4 # Décroissance du poids pour la régularisation)
Il suffit d’exécuter les fonctions d’aide suivantes pour la déduction. Il s’agit simplement d’un résumé des fonctions et tâches que j’ai mentionnées précédemment dans ce blog :
# pour le post-traitement des boîtes englobantes de sortiedef 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.float
C'EST L'HEURE DE MONTRER !
Travaillons sur une image. Pour cela, utilisez la fonction process_images().
image_path : accepte une liste de chemins d'image, vous pouvez mettre une chaîne de caractères représentant un chemin d'image à l'intérieur d'une liste. Par exemple : ["images/0.jpg"].
threshold : par défaut à 70% ou 0,7. Il est utilisé pour ne conserver que les prédictions dont le score de confiance maximal est supérieur au seuil.
show_image : par défaut à True. Cela permet de contrôler si vous souhaitez afficher l'image avec les articles de mode détectés à l'intérieur des boîtes englobantes (True) ou non (False).
Sortie 1 : Image unique avec les articles de mode détectés et imprimés. Photo originale de Napat Saeng sur Unsplash.
Si vous souhaitez l'utiliser pour l'étiquetage automatisé d'articles de mode et obtenir uniquement les résultats imprimés, vous pouvez entrershow_image=Falseà la place :
Enfin, si vous souhaitez l'utiliser pour plusieurs images, vous pouvez soit spécifier plusieurs chemins d'image à l'intérieur du paramètreimage_pathsou utiliser la fonctionprocess_images_in_directory()suivante et lui donner le chemin de votre répertoire d'images.
Option 2 : en utilisant le chemin de votre répertoire d'images
def process_images_in_directory(directory='./images', threshold=0.70, show_image=True): # Définissez les extensions des fichiers image qui vous intéressent image_extensions = ['jpg', 'png', 'jpeg', 'JPG', 'PNG'] # Utilisez une compréhension de liste pour créer une liste de fichiers pour chaque extension, puis combinez ces listes image_files = [glob.glob(f'{directory}/*.{ext}') for ext in image_extensions] image_paths = [item for sublist in image_files for item in sublist] # aplatissez la liste return process_images(image_paths, threshold=threshold, show_image=show_image)process_images_in_directory(directory='./images', threshold=0.8, show_image=True)
Les deux options produiront les résultats suivants :
Sortie #3-1 : Première image avec les articles de mode détectés et imprimés. Photo originale de Javier Contreras sur UnsplashSortie #3–2 : Deuxième image avec les articles de mode détectés et imprimés. Photo originale de Khaled Ghareeb sur UnsplashSortie n° 3-3 : Troisième image avec détection et impression des articles de mode. Photo originale de Tamara Bellis sur UnsplashSortie n° 3-4 : Dernière image avec détection et impression des articles de mode. Photo originale de Napat Saeng sur Unsplash.
CONCLUSION
L'impact potentiel de ce projet dans le domaine du e-commerce est considérable. En décryptant le code vestimentaire avec la détection automatisée des articles de mode, nous pouvons accélérer le processus de téléchargement de nouveaux produits, améliorant ainsi l'efficacité opérationnelle. Il ne s'agit pas seulement d'identifier les articles de mode ; il s'agit d'améliorer l'expérience client en fournissant des descriptions de produits précises et en facilitant la recherche de produits efficace.
De plus, cette technologie peut être étendue à d'autres applications telles que la gestion des stocks, l'analyse des tendances et les expériences d'achat personnalisées. Il s'agit de comprendre le langage de la mode et de l'utiliser à notre avantage.
CONCLUSION
Dans cette exploration, nous avons décrypté le code vestimentaire de l'industrie de la mode. Nous avons utilisé la précision de DL, un modèle pré-entraîné, et PyTorch Lightning pour automatiser le processus de détection des articles de mode et démontrer comment nous pouvons exploiter l'apprentissage profond pour effectuer un marquage automatique des produits. Cela peut transformer une tâche chronophage en un processus rapide et efficace.
En décryptant le code vestimentaire, nous avons ouvert un monde de possibilités dans le domaine du e-commerce. Ce n'est que le début. À mesure que nous affinons ces technologies, nous pouvons nous attendre à des solutions encore plus innovantes et efficaces à l'avenir.
NOTE
Cet article de blog est destiné à des fins éducatives et vise à fournir une vue d'ensemble du processus d'utilisation de modèles pré-entraînés pour la détection d'objets dans l'industrie de la mode. La mise en œuvre réelle peut nécessiter des étapes et des considérations supplémentaires, en fonction des exigences spécifiques de votre projet. Mais compte tenu des avantages de l'automatisation des tâches, il s'agit d'un voyage passionnant que je poursuivrai certainement après avoir obtenu mon diplôme.
Vous pouvez accéder à mes fichiers via mon référentiel GitHub à l'adresse suivante : https://github.com/erikaglacson/Multiple_Object_Detection.git .
Références
[1] PyTorch Lightning. (s.d.). Récupéré sur https://www.pytorchlightning.ai/
[2] Blin, J. (s.d.). Fashionpedia. Hugging Face. Récupéré le 27 juin 2023, sur 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. Dans Actes de la Conférence Européenne sur la Vision par Ordinateur (ECCV).
[4] Feruere Vega, V. (s.d.). YOLOS-fashionpedia. Hugging Face. Récupéré le 27 juin 2023, sur https://huggingface.co/valentinafeve/yolos-fashionpedia
[5] Wang, X. (s.d.). YOLOS-small. Hugging Face. Récupéré le 27 juin 2023, sur https://huggingface.co/hustvl/yolos-small
[6] Feruere Vega, V. (2023, 13 juin). Fine tunning YOLOs for fashion [Code source]. GitHub. https://github.com/valentinafeve/fine_tunning_YOLOS_for_fashion
We will continue to update IPGirl; if you have any questions or suggestions, please contact us!
