Comment utiliser GPT-4 pour la génération et l'analyse d'images

Name

Lynn Mikami

Published on 30/04/2024

L'avènement de GPT-4 marque une évolution significative dans le domaine de l'intelligence artificielle, étendant ses capacités au-delà du texte pour inclure la génération et l'analyse d'images. Cet article explore les fonctionnalités multifacettes de GPT-4, en mettant l'accent sur sa capacité à traiter et à générer des images, et propose un guide complet sur l'exploitation de ces fonctionnalités de manière efficace.

Qu'est-ce que GPT-4 ?

GPT-4, ou Generative Pre-trained Transformer 4, est une version avancée des modèles d'IA développés par OpenAI. Il se distingue par sa compréhension améliorée et sa génération de texte semblable à celui produit par des humains, mais ce qui distingue GPT-4, c'est sa capacité à interagir avec des images. Cela inclut la génération d'images à partir de descriptions (GPT-4 Vision ou GPT-4V), l'analyse de contenu dans les images et même la lecture de texte capturé dans des photos, ce qui en fait un outil polyvalent pour différentes applications.

Compréhension des capacités d'image de GPT-4

Les capacités visuelles de GPT-4, souvent appelées GPT-4 Vision ou GPT-4V, lui permettent de traiter et de générer des images en fonction de descriptions textuelles. Cela signifie que vous pouvez télécharger une photo pour l'analyse ou demander au modèle de créer de nouvelles images à partir de zéro. Que ce soit pour créer des œuvres d'art, générer des images pour du contenu ou extraire des informations à partir d'images, GPT-4V est équipé pour gérer une gamme de tâches, ce qui en fait un ajout puissant à la suite GPT-4.

Comment générer des images avec GPT-4

La génération d'images avec GPT-4 est simple. Les utilisateurs peuvent saisir une description détaillée de l'image qu'ils imaginent et le modèle générera une image correspondante. Cette fonctionnalité est particulièrement utile pour les artistes, les designers et les créateurs de contenu qui souhaitent donner vie à leurs idées sans avoir besoin de compétences en dessin ou en design manuel. C'est également précieux pour la création de visuels qui complètent le contenu textuel, améliorant ainsi l'expérience utilisateur globale.

Comment utiliser GPT-4 pour l'analyse d'images

En plus de générer des images, GPT-4 peut analyser et interpréter le contenu des photos. Cela inclut la lecture de texte dans les images, la reconnaissance d'objets et la compréhension des scènes. Pour utiliser cette fonctionnalité, les utilisateurs peuvent télécharger une image sur la plateforme et GPT-4 fournira des informations basées sur son analyse. Cette fonctionnalité est particulièrement utile pour les tâches impliquant la recherche basée sur des images, l'extraction de données et les améliorations de l'accessibilité, telles que la lecture de texte pour les personnes malvoyantes.

Applications pratiques de GPT-4 Vision

Les applications potentielles des capacités d'image de GPT-4 sont vastes. Dans le secteur de l'éducation, il peut faciliter l'apprentissage interactif en générant des supports visuels ou en analysant des photographies historiques. Les marketeurs peuvent utiliser GPT-4 pour créer des visuels convaincants pour des campagnes ou analyser des photos de consommateurs pour obtenir des informations. De plus, dans l'industrie créative, GPT-4 peut aider dans le processus de conception en générant des concepts initiaux ou en modifiant des visuels existants en fonction des commentaires.

Comment combiner GPT-4V avec RAG - Créer une application de recherche de correspondances vestimentaires

Bienvenue dans le cahier Jupyter de l'application Clothing Matchmaker ! Ce projet illustre la puissance du modèle GPT-4V dans l'analyse des images d'articles vestimentaires et l'extraction de caractéristiques clés telles que la couleur, le style et le type. Le cœur de notre application repose sur ce modèle d'analyse d'images avancé développé par OpenAI, qui nous permet d'identifier avec précision les caractéristiques de l'article vestimentaire d'entrée.

GPT-4V est un modèle qui combine le traitement du langage naturel avec la reconnaissance d'images, lui permettant de comprendre et de générer des réponses en fonction à la fois du texte et des entrées visuelles.

En utilisant les capacités du modèle GPT-4V, nous utilisons un algorithme de correspondance personnalisé et la technique RAG pour rechercher dans notre base de connaissances des articles qui complètent les caractéristiques identifiées. Cet algorithme prend en compte des facteurs tels que la compatibilité des couleurs et la cohérence du style pour fournir aux utilisateurs des recommandations appropriées. Grâce à ce cahier, nous visons à démontrer l'application pratique de ces technologies dans la création d'un système de recommandation vestimentaire.

L'utilisation de la combinaison GPT-4 Vision + RAG (Retrieval-Augmented Generation) offre plusieurs avantages :

• Compréhension contextuelle : GPT-4 Vision peut analyser les images d'entrée et comprendre le contexte, notamment les objets, les scènes et les activités représentées. Cela permet de suggérer ou d'apporter des informations plus précises et pertinentes dans divers domaines, qu'il s'agisse de design d'intérieur, de cuisine ou d'éducation.
• Base de connaissances riche : RAG combine les capacités de génération de GPT-4 avec un composant de recherche qui accède à un vaste corpus d'informations dans différents domaines. Cela signifie que le système peut fournir des suggestions ou des informations basées sur une large gamme de connaissances, des faits historiques aux concepts scientifiques.
• Personnalisation : L'approche permet une personnalisation facile pour répondre aux besoins ou préférences spécifiques des utilisateurs dans différentes applications. Que ce soit pour adapter les suggestions aux goûts artistiques d'un utilisateur ou pour fournir du contenu éducatif basé sur le niveau d'apprentissage d'un étudiant, le système peut être adapté pour offrir des expériences personnalisées.

Dans l'ensemble, l'approche GPT-4 Vision + RAG offre une solution puissante et flexible pour diverses applications liées à la mode, en exploitant les forces des techniques d'IA génératives et basées sur la recherche.

Configuration de l'environnement

Tout d'abord, nous installerons les dépendances nécessaires, puis importerons les bibliothèques et écrirons quelques fonctions utilitaires que nous utiliserons ultérieurement.

## Création des embeddings
 
Nous allons maintenant configurer la base de connaissances en choisissant une base de données et en générant des embeddings pour celle-ci. J'utilise le fichier `sample_styles.csv` dans le dossier des données. Il s'agit d'un échantillon d'un ensemble de données plus important qui contient environ `44 000` articles. Cette étape peut également être remplacée en utilisant une base de données vectorielle prête à l'emploi. Par exemple, vous pouvez suivre l'un de [ces guides](https://github.com/openai/openai-cookbook/tree/main/examples/vector_databases) pour configurer votre base de données vectorielle.
 
```python
styles_filepath = "data/sample_clothes/sample_styles.csv"
styles_df = pd.read_csv(styles_filepath, on_bad_lines='skip')
print(styles_df.head())
print("Dataset ouvert avec succès. Le jeu de données contient {} articles de vêtements.".format(len(styles_df)))

Maintenant, nous allons générer des embeddings pour l'ensemble du jeu de données. Nous pouvons paralléliser l'exécution de ces embeddings pour garantir que le script s'échelle pour les ensembles de données plus importants. Avec cette logique, le temps nécessaire pour créer des embeddings pour l'ensemble du jeu de données de 44 000 entrées passe d'environ 4 heures à 2-3 minutes.

## Logique d'embedding en lot
 
# Fonction simple pour prendre une liste d'objets texte et les renvoyer sous forme de liste d'embeddings
@retry(wait=wait_random_exponential(min=1, max=40), stop=stop_after_attempt(10))
def get_embeddings(input: List):
    response = client.embeddings.create(
        input=input,
        model=EMBEDDING_MODEL
    ).data
    return [data.embedding for data in response]
 
 
# Divise un itérable en lots de taille n.
def batchify(iterable, n=1):
    l = len(iterable)
    for ndx in range(0, l, n):
        yield iterable[ndx : min(ndx + n, l)]
     
 
# Fonction pour le batching et le traitement en parallèle des embeddings
def embed_corpus(
    corpus: List[str],
    batch_size=64,
    num_workers=8,
    max_context_len=8191,
):
    # Encode le corpus, en le tronquant à max_context_len
    encoding = tiktoken.get_encoding("cl100k_base")
    encoded_corpus = [
        encoded_article[:max_context_len] for encoded_article in encoding.encode_batch(corpus)
    ]
 
    # Calcule les statistiques du corpus : le nombre d'inputs, le nombre total de tokens et le coût estimé pour l'embedding
    num_tokens = sum(len(article) for article in encoded_corpus)
    cost_to_embed_tokens = num_tokens / 1000 * EMBEDDING_COST_PER_1K_TOKENS
    print(
        f"num_articles={len(encoded_corpus)}, num_tokens={num_tokens}, est_embedding_cost={cost_to_embed_tokens:.2f} USD"
    )
 
    # Embed le corpus
    with concurrent.futures.ThreadPoolExecutor(max_workers=num_workers) as executor:
        
        futures = [
            executor.submit(get_embeddings, text_batch)
            for text_batch in batchify(encoded_corpus, batch_size)
        ]
 
        with tqdm(total=len(encoded_corpus)) as pbar:
            for _ in concurrent.futures.as_completed(futures):
                pbar.update(batch_size)
 
        embeddings = []
        for future in futures:
            data = future.result()
            embeddings.extend(data)
 
        return embeddings
    
# Fonction pour générer les embeddings pour une colonne donnée dans un DataFrame
def generate_embeddings(df, column_name):
    # Initialise une liste vide pour stocker les embeddings
    descriptions = df[column_name].astype(str).tolist()
    embeddings = embed_corpus(descriptions)
 
    # Ajoute les embeddings en tant que nouvelle colonne du DataFrame
    df['embeddings'] = embeddings
    print("Embeddings créés avec succès.")

Deux options pour créer les embeddings :

La ligne suivante va créer les embeddings pour l'ensemble de données d'échantillons de vêtements. Cela prendra environ 0,02 s pour le traitement et environ 30 s supplémentaires pour écrire les résultats dans un fichier .csv local. Le processus utilise notre modèle text_embedding_3_large qui est tarifé à $0,00013/1K tokens. Étant donné que l'ensemble de données contient environ 1K entrées, l'opération suivante coûtera environ $0,001. Si vous décidez de travailler avec l'ensemble de données complet de 44K entrées, cette opération prendra 2-3 minutes pour le traitement et coûtera environ $0,07.

Si vous ne souhaitez pas continuer avec la création de vos propres embeddings, nous utiliserons un ensemble de données d'embeddings précalculés. Vous pouvez ignorer cette cellule et décommenter le code dans la cellule suivante pour continuer avec le chargement des vecteurs précalculés. Cette opération prend environ 1 minute pour charger toutes les données en mémoire.

generate_embeddings(styles_df, 'productDisplayName')
print("Écriture des embeddings dans le fichier ...")
styles_df.to_csv('data/sample_clothes/sample_styles_with_embeddings.csv', index=False)
print("Embeddings stockés avec succès dans sample_styles_with_embeddings.csv")

# styles_df = pd.read_csv('data/sample_clothes/sample_styles_with_embeddings.csv', on_bad_lines='skip')
 
# # Convertit la colonne 'embeddings' des représentations textuelles de listes en listes réelles de nombres flottants
# styles_df['embeddings'] = styles_df['embeddings'].apply(lambda x: ast.literal_eval(x))
 
print(styles_df.head())
print("Dataset ouvert avec succès. Le jeu de données contient {} articles de vêtements avec leurs embeddings.".format(len(styles_df)))

Construction de l'algorithme de correspondance

Dans cette section, nous développerons un algorithme de recherche de similarité cosinus pour trouver des éléments similaires dans notre dataframe. Nous utiliserons notre fonction de similarité cosinus personnalisée à cette fin. Bien que la bibliothèque sklearn propose une fonction de similarité cosinus intégrée, des mises à jour récentes de son SDK ont entraîné des problèmes de compatibilité, nous incitant ainsi à implémenter notre propre calcul de similarité cosinus standard.

Si vous avez déjà configuré une base de données de vecteurs, vous pouvez ignorer cette étape. La plupart des bases de données standard sont livrées avec leurs propres fonctions de recherche, ce qui simplifie les étapes ultérieures décrites dans ce guide. Cependant, nous souhaitons démontrer que l'algorithme de correspondance peut être adapté pour répondre à des exigences spécifiques, telles qu'un seuil particulier ou un nombre spécifié de correspondances renvoyées.

La fonction find_similar_items accepte quatre paramètres:

• embedding : L'embedding pour lequel nous voulons trouver une correspondance.
• embeddings : Une liste d'embeddings à parcourir pour trouver les meilleures correspondances.
• threshold (optionnel) : Ce paramètre spécifie le score de similarité minimum pour qu'une correspondance soit considérée comme valide. Un seuil plus élevé donne des correspondances plus proches (meilleures), tandis qu'un seuil plus bas permet de renvoyer plus d'éléments, même s'ils ne sont pas aussi étroitement assortis à l'embedding initial.
• top_k (optionnel) : Ce paramètre détermine le nombre d'éléments à renvoyer qui dépassent le seuil donné. Ce seront les correspondances les mieux notées pour l'embedding fourni.

def cosine_similarity_manual(vec1, vec2):
    """Calculer la similarité cosinus entre deux vecteurs."""
    vec1 = np.array(vec1, dtype=float)
    vec2 = np.array(vec2, dtype=float)
 
 
    dot_product = np.dot(vec1, vec2)
    norm_vec1 = np.linalg.norm(vec1)
    norm_vec2 = np.linalg.norm(vec2)
    return dot_product / (norm_vec1 * norm_vec2)
 
 
def find_similar_items(input_embedding, embeddings, threshold=0.5, top_k=2):
    """Trouver les éléments les plus similaires basés sur la similarité cosinus."""
    
    # Calculer la similarité cosinus entre l'embedding d'entrée et tous les autres embeddings
    similarities = [(index, cosine_similarity_manual(input_embedding, vec)) for index, vec in enumerate(embeddings)]
    
    # Filtrer les similarités inférieures au seuil
    filtered_similarities = [(index, sim) for index, sim in similarities if sim >= threshold]
    
    # Trier les similarités filtrées par score de similarité
    sorted_indices = sorted(filtered_similarities, key=lambda x: x[1], reverse=True)[:top_k]
 
    # Renvoyer les éléments les plus similaires top-k
    return sorted_indices

def find_matching_items_with_rag(df_items, item_descs):
   """Prendre les descriptions d'articles d'entrée et trouver les articles les plus similaires basés sur la similarité cosinus pour chaque description."""
   
   # Sélectionner les embeddings du DataFrame.
   embeddings = df_items['embeddings'].tolist()
 
   
   similar_items = []
   for desc in item_descs:
      
      # Générer l'embedding pour l'article d'entrée
      input_embedding = get_embeddings([desc])
    
      # Trouver les articles les plus similaires basés sur la similarité cosinus
      similar_indices = find_similar_items(input_embedding, embeddings, threshold=0.6)
      similar_items += [df_items.iloc[i] for i in similar_indices]
    
   return similar_items

Module d'analyse

Dans ce module, nous exploitons gpt-4-vision-preview pour analyser les images d'entrée et extraire des caractéristiques importantes telles que des descriptions détaillées, des styles et des types. L'analyse est effectuée via un appel d'API simple, dans lequel nous fournissons l'URL de l'image à analyser et demandons au modèle d'identifier les caractéristiques pertinentes.

Pour garantir que le modèle renvoie des résultats précis, nous utilisons des techniques spécifiques dans notre consigne:

1. Spécification du format de sortie: Nous demandons au modèle de renvoyer un bloc JSON avec une structure prédéfinie, composée de :

   • items (str[]) : Une liste de chaînes, chacune représentant un titre concis pour un article vestimentaire, incluant le style, la couleur et le genre. Ces titres ressemblent étroitement à la propriété productDisplayName dans notre base de données d'origine.
   • category (str) : La catégorie qui représente le mieux l'article donné. Le modèle sélectionne parmi une liste de tous les articleTypes uniques présents dans le dataframe des styles d'origine.
   • gender (str) : Une étiquette indiquant le genre auquel l'article est destiné. Le modèle choisit parmi les options [Men, Women, Boys, Girls, Unisex].

2. Instructions claires et concises :

   • Nous fournissons des instructions claires sur ce que les titres des articles doivent inclure et sur le format de sortie souhaité. La sortie doit être au format JSON, mais sans la balise json que la réponse du modèle contient normalement.

3. Exemple en une fois :

   • Pour clarifier davantage la sortie attendue, nous fournissons au modèle une description d'entrée d'exemple et une sortie d'exemple correspondante. Bien que cela puisse augmenter le nombre de tokens utilisés (et donc le coût de l'appel), cela aide à guider le modèle et aboutit à de meilleures performances globales.

En suivant cette approche structurée, nous visons à obtenir des informations précises et utiles à partir du modèle gpt-4-vision-preview pour une analyse et une intégration ultérieures dans notre base de données.

def analyze_image(image_base64, subcategories):
    response = client.chat.completions.create(
        model=GPT_MODEL,
        messages=[
            {
            "role": "user",
            "content": [
                {
                "type": "text",
                "text": """Étant donné une image d'un article vestimentaire, analysez l'article et gérez une sortie JSON avec les champs suivants : "items", "category" et "gender". 
                           Utilisez votre compréhension des tendances de la mode, des styles et des préférences de genre pour fournir des suggestions précises et pertinentes. 
                           Le champ items doit être une liste d'articles qui iraient bien avec l'article sur l'image. Chaque article doit représenter un titre d'article vestimentaire contenant le style, la couleur et le genre de l'article."""
Le modèle de langage GPT-4V est capable de fournir des traductions en français.
Dans notre cas, nous utilisons GPT-4V pour analyser des images de mode et suggérer des articles qui compléteraient une tenue originale. Pour mettre en œuvre des garde-fous, nous pouvons **affiner les résultats** : après avoir obtenu des suggestions initiales de GPT-4V, nous pouvons renvoyer l'image originale et les articles suggérés au modèle. Nous pouvons alors demander à GPT-4V d'évaluer si chaque article suggéré conviendrait effectivement à la tenue originale.
 
Cela donne à modèle la capacité de s'autocorriger et d'ajuster sa propre sortie en fonction des commentaires ou des informations supplémentaires. En mettant en place ces garde-fous et en permettant l'autocorrection, nous pouvons améliorer la fiabilité et l'utilité de la sortie du modèle dans le contexte de l'analyse et de la recommandation de mode.
 
Pour faciliter cela, nous écrivons une invite qui demande au LLM une réponse simple "oui" ou "non" à la question de savoir si les articles suggérés correspondent à la tenue originale ou non. Cette réponse binaire aide à rationaliser le processus d'affinement et garantit des commentaires clairs et exploitables du modèle.
 
```python
def check_match(reference_image_base64, suggested_image_base64):
    response = client.chat.completions.create(
        model=GPT_MODEL,
        messages=[
            {
            "role": "user",
            "content": [
                {
                "type": "text",
                "text": """ Vous allez recevoir deux images de deux articles vestimentaires différents.
                            Votre objectif est de décider si les articles sur les images fonctionneraient bien ensemble dans une tenue.
                            La première image est l'article de référence (l'article avec lequel l'utilisateur essaie de l'associer à un autre article).
                            Vous devez décider si le deuxième article fonctionnerait bien avec l'article de référence.
                            Votre réponse doit être une sortie JSON avec les champs suivants : "answer", "reason".
                            Le champ "answer" doit être soit "yes" (oui) ou "no" (non), en fonction de votre opinion sur le fait que les articles fonctionneraient bien ensemble.
                            Le champ "reason" doit être une brève explication de votre raisonnement pour votre décision. Ne pas inclure les descriptions des 2 images.
                            Ne pas inclure la balise ```json``` dans la sortie.
                           """,
                },
                {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{reference_image_base64}",
                },
                },
                {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{suggested_image_base64}",
                },
                }
            ],
            }
        ],
        max_tokens=300,
    )
    # Extraire les fonctionnalités pertinentes de la réponse
    features = response.choices[0].message.content
    return features

Enfin, déterminons quels sont les articles identifiés ci-dessus qui complètent réellement la tenue.

# Sélectionner les chemins uniques pour les images générées
paths = list(set(paths))
 
for path in paths:
    # Encoder l'image de test en base64
    suggested_image = encode_image_to_base64(path)
    
    # Vérifier si les articles correspondent
    match = json.loads(check_match(encoded_image, suggested_image))
    
    # Afficher l'image et les résultats de l'analyse
    if match["answer"] == 'yes':
        display(Image(filename=path))
        print("Les articles correspondent !")
        print(match["reason"])

Nous pouvons observer que la liste initiale des articles potentiels a été affinée davantage, ce qui donne une sélection plus soignée qui s'harmonise bien avec la tenue. De plus, le modèle fournit des explications sur la raison pour laquelle chaque article est considéré comme une bonne correspondance, offrant ainsi des informations précieuses sur le processus de prise de décision.

Revue

Dans ce tutoriel, nous avons exploré l'application de GPT-4 avec Vision et d'autres techniques d'apprentissage automatique dans le domaine de la mode. Nous avons démontré comment analyser des images d'articles vestimentaires, extraire les fonctionnalités pertinentes et utiliser ces informations pour trouver des articles correspondants qui complètent une tenue originale. Grâce à la mise en place de garde-fous et de mécanismes d'autocorrection, nous avons affiné les suggestions du modèle pour garantir leur précision et leur pertinence contextuelle.

Cette approche a plusieurs utilisations pratiques dans le monde réel, notamment :

1. Assistantes de shopping personnalisées : Les détaillants peuvent utiliser cette technologie pour offrir des recommandations de tenues personnalisées aux clients, améliorant ainsi l'expérience d'achat et augmentant la satisfaction des clients.
2. Applications de garde-robe virtuelle : Les utilisateurs peuvent télécharger des images de leurs propres articles vestimentaires pour créer une garde-robe virtuelle et recevoir des suggestions de nouveaux articles qui correspondent à leurs pièces existantes.
3. Design et stylisme de mode : Les designers de mode et les stylistes peuvent utiliser cet outil pour expérimenter différentes combinaisons et styles, rationalisant ainsi le processus créatif.

Cependant, l'un des aspects à prendre en compte est le coût. L'utilisation des LLM et des modèles d'analyse d'images peut entraîner des coûts, surtout s'ils sont utilisés de manière intensive. Il est important de considérer le rapport coût-efficacité de la mise en œuvre de ces technologies. gpt-4-vision-preview est facturé à $0.01 par tranche de 1000 jetons. Cela représente $0.00255 pour une image de 256px x 256px.

En conclusion, ce guide sert de base pour une exploration et un développement ultérieurs dans l'intersection de la mode et de l'IA, ouvrant la voie à des systèmes de recommandation de mode plus personnalisés et intelligents.

Conclusion

L'expansion de GPT-4 dans le traitement et la génération d'images marque une étape importante dans le développement de l'IA. En comprenant comment utiliser les capacités de vision de GPT-4, les utilisateurs peuvent exploiter la puissance de l'IA pour créer et analyser des images de manière précédemment considérée comme impossible. Que ce soit à des fins créatives, éducatives ou analytiques, GPT-4 ouvre de nouvelles possibilités pour intégrer des visuels dans le monde numérique, améliorant à la fois la création et la compréhension de contenu dans divers domaines.