AI Telephone – Une Bataille de Modèles Multimodaux

AI Telephone - A Battle of Multimodal Models

DALL-E2, Stable Diffusion, BLIP et plus encore !

L’IA générative est en train de conquérir le monde en ce moment. Les derniers mois en particulier ont vu une explosion dans l’apprentissage machine multimodal – l’IA qui relie des concepts à travers différentes “modalités” telles que le texte, les images et l’audio. Par exemple, Midjourney est un modèle texte-image multimodal, car il prend en entrée du langage naturel et produit des images. Le magnum opus de cette renaissance récente de la synergie multimodale était ImageBind de Meta AI, qui peut prendre des entrées de 6(!) variétés et les représenter dans le même “espace”.

Avec toute cette excitation, je voulais mettre les modèles multimodaux à l’épreuve et voir à quel point ils étaient réellement bons. En particulier, je voulais répondre à trois questions :

1. Quel est le meilleur modèle texte-image ?
2. Quel est le meilleur modèle image-texte ?
3. Qu’est-ce qui est plus important – l’image-texte ou le texte-image ?

Bien sûr, chaque modèle apporte ses propres biais à la table, des données d’entraînement à l’architecture du modèle, il n’y a donc jamais vraiment un MEILLEUR modèle. Mais nous pouvons quand même mettre les modèles à l’épreuve dans un contexte général !

Pour répondre à ces questions, j’ai décidé de jouer à un jeu de téléphone AI, inspiré du jeu de société Telestrations, que ma famille et moi aimons jouer ensemble.

• Des pipelines CI/CD transparents avec GitHub Actions sur GCP vos outils pour un MLOps efficace.
• Détection de la croissance du cancer à l’aide de l’IA et de la vision par ordinateur
• Problème du Gradient Disparu Causes, Conséquences et Solutions

Telestrations ressemble beaucoup au jeu de téléphone : les joueurs se passent le mot en cercle, prenant en compte la communication de la personne à leur gauche, et en retour, communiquant leur interprétation à la personne à leur droite. Au fur et à mesure que le jeu se poursuit, le message d’origine est inévitablement altéré, voire perdu entièrement. Telestrations diffère cependant en ajoutant une communication bimodale : les joueurs alternent entre le dessin (ou l’illustration) d’une description et la description (en texte) d’une description.

Étant donné que j’étais plus intéressé par la comparaison des modèles, j’ai adapté le jeu pour qu’il convienne à cette fin.

Voici comment fonctionne le jeu de téléphone AI :

1. Chaque “jeu” associe un modèle image-texte (I2T) à un modèle texte-image (T2I).
2. Étant donné une indication initiale, nous utilisons le modèle T2I pour générer une image.
3. Nous passons ensuite cette image dans le modèle I2T pour générer une description.
4. Nous répétons les étapes 2 et 3 un nombre fixe de fois n (dans notre cas n=10 ).
5. Enfin, nous quantifions la différence entre l’indication d’origine et la description finale.

Dans ce post, je vais vous guider à travers tout ce processus, afin que vous puissiez jouer à téléphone AI aussi ! À la fin, je répondrai aux trois questions motivantes.

Remarque : Ce jeu de téléphone AI est intimement lié à la notion de consistance de cycle. En incorporant un terme de consistance de cycle dans la fonction de perte pendant l’entraînement, les modèles peuvent être incités à minimiser efficacement la dégradation sur un jeu de téléphone. À ma connaissance, aucun des modèles considérés dans cette expérience n’a été entraîné avec la consistance de cycle comme considération.

Le post est structuré comme suit :

1. Choisir les modèles multimodaux
2. Générer les indications
3. Créer des lignes de téléphone
4. Mener les conversations
5. Visualiser et analyser les résultats

Vous pouvez trouver tout le code pour exécuter cette expérience et jouer à téléphone AI ici.

Pour exécuter ce code, vous devrez installer la bibliothèque open source FiftyOne pour la curatelle de données, la bibliothèque Python OpenAI et le client Python Replicate.

pip install fiftyone openai replicate

Progression des images dans un jeu de téléphone AI entre DALL-E2 et BLIP.

Choisir les concurrents

L’espace des modèles multimodaux est immense : au moment de la rédaction, Hugging Face seul compte 4 425 modèles T2I et 155 modèles I2T. Jouer à téléphone AI avec tous ces modèles – ou même une fraction non négligeable d’entre eux – serait complètement irréalisable. Ma première tâche a été de réduire cet espace de candidats potentiels à un ensemble de concurrents plus gérable.

Opter pour les APIs

Pour commencer ce projet, je savais que j’allais travailler avec de nombreux modèles. Certains des modèles potentiels étaient assez grands, et beaucoup nécessitaient leurs propres environnements, avec un ensemble unique de besoins. Étant donné que j’avais l’intention d’associer chaque modèle T2I à chaque modèle I2T, installer ces modèles localement pour jouer à des jeux de téléphone AI présentait un purgatoire de dépendance potentiel – surtout parce que je travaille sur un MacBook Pro M1!

Pour contourner ce problème, j’ai décidé de me limiter aux modèles accessibles via des APIs. En particulier, j’ai choisi d’utiliser principalement Replicate , dont l’interface simple m’a permis de travailler avec des modèles T2I et I2T de manière plug-and-play. Presque tous les modèles que j’ai utilisés sont open source, donc si vous êtes plus courageux que moi, vous pouvez exécuter ces modèles localement et éviter les frais. Cela étant dit, au total, cette expérience a coûté moins de 15 $ US.

Modèles de Texte vers Image

Lors de la sélection des modèles T2I, j’ai choisi parmi les modèles de la collection Text to image de Replicate. Mes critères de sélection étaient que le modèle devait être bon marché, rapide et relativement populaire (jugé par le nombre de “runs” du modèle sur Replicate). De plus, le modèle devait être à usage général, ce qui signifie que je n’allais pas considérer les modèles de génération de logos, de dessins ou de style anime. Vous êtes plus que bienvenu à essayer de jouer au téléphone AI avec ces types de modèles si vous le souhaitez!

Compte tenu de ces exigences, j’ai choisi Stable Diffusion et Feed forward VQGAN CLIP . Initialement, j’ai également travaillé avec DALL-E Mini , mais lors des premiers tests, j’ai été déçu par les performances du modèle, j’ai donc échangé le modèle contre DALL-E2 d’OpenAI, auquel j’ai accédé via le point de terminaison de génération d’images d’OpenAI.

En passant, le fait de restreindre mon attention aux modèles accessibles via des APIs signifiait que je n’ai pas envisagé Midjourney . Il n’y a pas d’API officielle, et je ne voulais pas utiliser une API non officielle, ni entrer des instructions dans Discord une par une et télécharger les images générées une par une.

Pour rendre ce processus aussi plug-and-play que possible, j’ai adopté une approche orientée objet. J’ai défini une classe de base Text2Image, qui expose une méthode generate_image(text):

import replicateclass Text2Image(object):    """Wrapper for a Text2Image model."""    def __init__(self):        self.name = None        self.model_name = None    def generate_image(self, text):        response = replicate.run(self.model_name, input={"prompt": text})        if type(response) == list:            response = response[0]        return response

Pour les modèles Replicate, il suffit ensuite de définir l’attribut model_name, identifiant le modèle dans Replicate. Pour Stable Diffusion, par exemple, la définition de classe ressemble à ceci:

class StableDiffusion(Text2Image):    """Wrapper for a StableDiffusion model."""    def __init__(self):        self.name = "stable-diffusion"        self.model_name = "stability-ai/stable-diffusion:27b93a2413e7f36cd83da926f3656280b2931564ff050bf9575f1fdf9bcd7478"

Pour d’autres modèles, comme DALL-E2, la méthode generate_image(text) peut être surchargée:

import openaiclass DALLE2(Text2Image):    """Wrapper for a DALL-E 2 model."""    def __init__(self):        self.name = "dalle-2"        def generate_image(self, text):        response = openai.Image.create(            prompt=text,            n=1,            size="512x512"        )        return response['data'][0]['url']

Chacun de ces modèles T2I renvoie l’URL de l’image générée, que nous pouvons ensuite passer directement à nos modèles I2T.

Modèles d’Image vers Texte

J’ai suivi un processus similaire pour déterminer les concurrents I2T, en évaluant les candidats dans la collection Image to text de Replicate. Après avoir examiné les exemples de tous les modèles de la collection, six modèles se sont démarqués: BLIP , BLIP-2 , Légende préfixée CLIP , Légende d’image à grains fins avec récompense CLIP , mPLUG-Owl et MiniGPT-4 . D’autres modèles étaient tentants, comme CLIP Interrogator, qui essaie de rétro-ingénierie une instruction que vous pouvez ensuite utiliser pour générer une image similaire. Mais cela ressemblait un peu à de la triche en ce qui concerne le téléphone AI!

En jouant avec les six candidats I2T, j’ai rapidement éliminé deux modèles de la compétition : BLIP-2 générait des réponses systématiquement trop courtes pour être utiles, et le modèle CLIP Caption Reward générait des réponses souvent incohérentes.

En analogie directe avec les modèles T2I, j’ai défini une classe de base Image2Text exposant une méthode generate_text(image_url):

class Image2Text(object):    """Wrapper pour un modèle Image2Text."""    def __init__(self):        self.name = None        self.model_name = None        self.task_description = "Écrire une description détaillée de cette image."    def generate_text(self, image_url):        response = replicate.run(            self.model_name,             input={                "image": image_url,                "prompt": self.task_description,                }            )        return response 

J’ai ensuite créé des sous-classes pour chaque modèle. Voici à quoi ressemble la sous-classe BLIP :

class BLIP(Image2Text):    """Wrapper pour un modèle BLIP."""    def __init__(self):        super().__init__()        self.name = "blip"        self.model_name = "salesforce/blip:2e1dddc8621f72155f24cf2e0adbde548458d3cab9f00c0139eea840d0ac4746"

Tous les modèles sont instanciés avec la même description de tâche – “écrire une description détaillée de cette image”.

Progression des images dans une partie de Téléphone AI entre DALL-E2 et mPLUG-Owl.

Prompts

Pour être aussi “scientifique” que possible, j’ai pensé qu’il était préférable de ne pas générer moi-même les prompts initiaux. À la place, (et juste pour le plaisir) j’ai externalisé la tâche à ChatGPT. J’ai demandé :

Je joue à un jeu de téléphone en utilisant des modèles AI de texte vers image et d'image vers texte. Je veux évaluer ces modèles en fonction de leur capacité à conserver des informations sémantiques complexes au cours de longues conversations. Votre travail est de me donner 10 textes prompts que je peux utiliser pour jouer à ces jeux de téléphone. Vous devez me donner un prompt facile, trois prompts IPGirl, trois prompts difficiles et un prompt ultra-difficile.

Je joue à un jeu de téléphone en utilisant des modèles AI de texte vers image et d’image vers texte. Je veux évaluer ces modèles en fonction de leur capacité à conserver des informations sémantiques complexes au cours de longues conversations. Votre travail est de me donner 10 textes prompts que je peux utiliser pour jouer à ces jeux de téléphone. Vous devez me donner un prompt facile, trois prompts IPGirl, trois prompts difficiles et un prompt ultra-difficile (“impossible”).

Voici quelques-uns des prompts générés par ChatGPT :

Facile : "Une pomme rouge posée sur une table en bois avec la lumière du soleil qui entre par une fenêtre."IPGirl : "Un astronaute flottant dans la Station spatiale internationale, regardant la Terre à travers la fenêtre, avec une capsule spatiale amarrée en arrière-plan."Difficile : "Un marché animé dans une ville ancienne du Moyen-Orient. Des commerçants marchandent pour des épices et des soies, des chameaux transportent des marchandises, le soleil se couche derrière une mosquée avec un croissant de lune visible."Impossible : "Une scène panoramique d'une civilisation extraterrestre avancée sur une exoplanète lointaine. Des véhicules interstellaires volent dans un ciel indigo au-dessus de structures cristallines imposantes. Des extraterrestres aux caractéristiques physiques variées interagissent, échangent des sphères d'énergie, communiquent par des motifs lumineux et s'occupent de flore exotique bioluminescente. Les deux lunes de la planète sont visibles à l'horizon au-dessus d'un océan alien étincelant."

Une approche scientifique plus rigoureuse serait beaucoup plus intentionnelle avec les prompts utilisés, ainsi qu’avec leur catégorisation.

J’ai ensuite pris les textes prompts générés par ChatGPT et construit des objets Prompt, qui contenaient le texte du prompt et le niveau de difficulté attribué par ChatGPT :

class Prompt(object):    def __init__(self, text, level):        self.text = text        self.level = levellevels = ["facile", "IPGirl", "difficile", "impossible"]level_prompts = [easy_texts, IPGirl_texts, hard_texts, impossible_texts]def get_prompts():    prompts = []    for level, texts in zip(levels, level_prompts):        for text in texts:            prompts.append(Prompt(text, level))    return prompts

Progression des images dans une partie de Téléphone AI entre VQGAN-CLIP et MiniGPT-4.

La Ligne Téléphonique

Le dernier composant pour jouer à AI Telephone était la “ligne téléphonique” elle-même. J’ai créé une classe TelephoneLine pour encapsuler la connexion entre un modèle T2I et un modèle I2T. Avec une seule ligne téléphonique, une “partie” de téléphone est jouée en appelant play(prompt, nturns=10), où la conversation évolue à partir de prompt, et s’exécute pour nturns tours aller-retour.

import osimport hashlibimport fiftyone as fofrom fiftyone import ViewField as Fclass TelephoneLine(object):    """Classe pour jouer au téléphone avec AI."""    def __init__(self, t2i, i2t):        self.t2i = t2i        self.i2t = i2t        self.name = f"{t2i.name}_{i2t.name}"        self.conversations = {}    def get_conversation_name(self, text):        full_name = f"{self.name}{text}"        hashed_name = hashlib.md5(full_name.encode())        return hashed_name.hexdigest()[:6]        def play(self, prompt, nturns = 10):        """Jouer une partie de téléphone."""        print(f"Connexion {self.t2i.name} <-> {self.i2t.name} avec le prompt: {prompt.text[:20]}...")        texts = [prompt.text]        image_urls = []        for _ in range(nturns):            image_url = self.t2i.generate_image(texts[-1])            text = self.i2t.generate_text(image_url)            texts.append(text)            image_urls.append(image_url)                conversation_name = self.get_conversation_name(prompt.text)        self.conversations[conversation_name] = {            "texts": texts,            "image_urls": image_urls,            "level": prompt.level        }

Pour chaque jeu joué, la conversation est enregistrée avec un nom unique, généré en hachant le nom du modèle T2I, le nom du modèle I2T et le texte du prompt (méthode get_conversation_name()).

J’ai également équipé la classe avec une méthode save_conversations_to_dataset(), qui enregistre les images et les descriptions de tous les jeux joués sur la ligne téléphonique dans un Dataset FiftyOne :

 def save_conversations_to_dataset(self, dataset):        """Enregistrer les conversations dans un dataset."""        for conversation_name in self.conversations.keys():            conversation = self.conversations[conversation_name]            prompt = conversation["texts"][0]            level = conversation["level"]            image_urls = conversation["image_urls"]            texts = conversation["texts"]            for i in range(len(image_urls)):                filename = f"{conversation_name}_{i}.jpg"                filepath = os.path.join(IMAGES_DIR, filename)                download_image(image_urls[i], filepath)                sample = fo.Sample(                    filepath = filepath,                    conversation_name = conversation_name,                    prompt = prompt,                    level = level,                    t2i_model = self.t2i.name,                    i2t_model = self.i2t.name,                    step_number = i,                    text_before = texts[i],                    text_after = texts[i+1]                )                                dataset.add_sample(sample)

Progression des images dans un jeu de AI Telephone entre Stable Diffusion et CLIP Prefix Captioning.

Effectuer les Conversations

Avec tous les blocs de construction en place, jouer à AI Telephone est un jeu d’enfant !

Nous pouvons instancier les modèles T2I et I2T :

## Modèles Image2Textsmplug_owl = MPLUGOwl()blip = BLIP()clip_prefix = CLIPPrefix()mini_gpt4 = MiniGPT4()image2text_models = [mplug_owl, blip, clip_prefix, mini_gpt4]## Modèles Text2Imagevqgan_clip = VQGANCLIP()sd = StableDiffusion()dalle2 = DALLE2()text2image_models = [sd, dalle2, vqgan_clip]

Et ensuite créer une ligne téléphonique pour chaque paire :

combos = [(t2i, i2t) for t2i in text2image_models for i2t in image2text_models]lines = [TelephoneLine(*combo) for combo in combos]

Nous chargeons ensuite nos prompts :

prompts = get_prompts()

Et créez un Dataset FiftyOne que nous utiliserons pour stocker les images générées et toutes les informations pertinentes des conversations :

import fiftyone as fodataset = fo.Dataset(name = 'telephone', persistent=True)dataset.add_sample_field("conversation_name", fo.StringField)dataset.add_sample_field("prompt", fo.StringField)dataset.add_sample_field("level", fo.StringField)dataset.add_sample_field("t2i_model", fo.StringField)dataset.add_sample_field("i2t_model", fo.StringField)dataset.add_sample_field("step_number", fo.IntField)dataset.add_sample_field("text_before", fo.StringField)dataset.add_sample_field("text_after", fo.StringField)

Nous pouvons ensuite exécuter les 120 jeux de téléphone :

from tqdm import tqdmfor line in tqdm(lines):    for prompt in prompts:        line.play(prompt, nturns = 10)    line.save_conversations_to_dataset(dataset)session = fo.launch_app(dataset)

Dans l’application FiftyOne, cliquez sur l’icône de division dans la barre de menu pour regrouper les images par conversation, sélectionnez conversation_name dans le menu déroulant, puis basculez le sélecteur sur ordered et sélectionnez step_number.

Résultats et Conclusions

Pour évaluer la qualité d’une conversation – uniquement en termes de la proximité de la signification de la description finale par rapport à la signification de la question initiale, j’ai décidé de générer des embeddings pour les questions et les descriptions, et de calculer la distance cosine (dans [0, 2]) entre les deux.

from scipy.spatial.distance import cosine as cosine_distance

Pour un modèle d’embedding, je voulais un modèle capable d’embedder à la fois du texte et des images, compte tenu de la nature multimodale de l’exercice. J’ai fini par choisir d’utiliser ImageBind pour trois raisons :

1. D’autres modèles d’embedding d’image-texte conjoints populaires comme CLIP et BLIP sont liés à certains des modèles que j’ai utilisés dans l’expérience (préfixe de légende BLIP et CLIP), et je voulais éviter tout biais possible en utilisant les mêmes types de modèles pour l’évaluation.
2. De nombreux modèles d’embedding de texte ont un petit max_token_count – le nombre maximal de tokens autorisés dans un texte à être embeddé. CLIP, par exemple, a max_token_count=77. Certaines de nos descriptions sont significativement plus longues que cela. Heureusement, ImageBind a un nombre maximum de tokens beaucoup plus long.
3. Je voulais essayer ImageBind, et c’était une excellente occasion !

J’ai enveloppé l’API ImageBind de Replicate dans une fonction embed_text(text) :

MODEL_NAME = "daanelson/imagebind:0383f62e173dc821ec52663ed22a076d9c970549c209666ac3db181618b7a304"def embed_text(text):    response = replicate.run(        MODEL_NAME,        input={            "text_input": text,             "modality": "text"            }    )    return np.array(response)

Pour éviter les calculs redondants, j’ai haché les questions et stocké les embeddings de questions dans un dictionnaire. Ainsi, au lieu d’embedder chaque question pour chacune des 12 lignes de téléphone, nous n’avons besoin d’embedder chaque question qu’une seule fois :

import hashlibdef hash_prompt(prompt):    return hashlib.md5(prompt.encode()).hexdigest()[:6]### Embed initial promptsprompt_embeddings = {}dataset.add_sample_field("prompt_hash", fo.StringField)## Group samples by initial prompt## Add hash to all samples in groupprompt_groups = dataset.group_by("prompt")for pg in prompt_groups.iter_dynamic_groups():    prompt = pg.first().prompt    hash = hash_prompt(prompt)    prompt_embeddings[hash] = embed_text(prompt)    view = pg.set_field("prompt_hash", hash)    view.save("prompt_hash")

Nous pouvons ensuite regrouper les échantillons par nom de conversation, itérer à travers ces groupes, calculer l’embedding de texte pour chaque étape, et enregistrer la distance cosine (plus petite est meilleure !) entre l’embedding de texte et l’embedding de la question initiale :

dataset.add_sample_field("text_after_dist", fo.FloatField)prompt_groups = dataset.group_by("conversation_name")for cg in conversation_groups.iter_dynamic_groups(progress=True):    hash = cg.first().prompt_hash    prompt_embedding = prompt_embeddings[hash]    ordered_samples = cg.sort_by("step_number")    for sample in ordered_samples.iter_samples(autosave=True):        text_embedding = embed_text(sample.text_after)        sample["text_embedding"] = text_embedding                sample.text_after_dist = cosine_distance(            prompt_embedding,            text_embedding        )

J’ai ensuite calculé les scores moyens pour chaque paire T2I-I2T pour toutes les invitations à un certain niveau de difficulté et j’ai tracé les résultats. Dans chacune des vidéos, les modèles I2T et T2I sont imprimés sur les images générées, ainsi que le texte utilisé pour générer cette image (rouge) et la description générée à partir de cette image (vert).

Facile

Pour les invitations faciles, les performances ont tendance à dépendre le plus fortement du modèle texte-image. DALL-E2 et Stable Diffusion surpassent largement VQGAN-CLIP. MiniGPT-4 est membre des paires les plus performantes.

Voici quelques exemples pour l’invitation facile introduite ci-dessus:

Téléphone IA pour une invitation facile, avec des paires de modèles texte-image et image-texte.

Dans les jeux avec MiniGPT-4 (et dans une moindre mesure BLIP), la pomme reste au centre, alors que dans les jeux impliquant CLIP Prefix, la pomme disparait progressivement.

IPGirl

Quand les invitations deviennent un peu plus difficiles, la situation commence à changer.

Téléphone IA pour une invitation IPGirl difficile, avec des paires de modèles texte-image et image-texte.

Pour presque tous les jeux, le sujet change quelque part autour de la quatrième ou cinquième étape. Au début, MiniGPT-4 a un avantage. Mais à la fin du jeu, cet avantage semble avoir été entièrement perdu.

Difficile

À mesure que les invitations deviennent difficiles, nous commençons à voir quelque chose d’intéressant : pour les premières étapes, le modèle image-texte est le plus important (MiniGPT-4 est le meilleur, et CLIP Prefix est pour la plupart le pire). À des stades ultérieurs, cependant, le modèle texte-image devient le plus important. Et pour compliquer encore la situation, VQGAN-CLIP est le meilleur ici !

On pourrait craindre que “meilleur” signifie simplement que la cohérence est maintenue, sans représenter précisément le concept original. Cependant, lorsque nous regardons des exemples, nous pouvons constater que ce n’est pas le cas.

Téléphone IA pour une invitation difficile, avec des paires de modèles texte-image et image-texte.

Prenons l’exemple mis en évidence dans la vidéo, où l’invitation initiale est l’invitation “difficile” présentée ci-dessus concernant un “marché animé”. Bien que les images générées par VQGAN-CLIP soient sans aucun doute granuleuses, le sujet peut encore être distingué et correspond assez bien à l’invitation d’origine.

Impossible

Sans surprise, aucun de nos concurrents ne se débrouille très bien ici. On pourrait argumenter que VQGAN-CLIP est le gagnant. Mais pour la plupart, tout cela n’est que du bruit. Dans la vidéo, même pour les jeux impliquant VQGAN-CLIP, le sujet est effectivement méconnaissable.

Téléphone IA pour une invitation “impossible”, avec des paires de modèles texte-image et image-texte.

Conclusions

Cette exploration était loin d’être scientifique ; je n’ai examiné que dix invitations, sans validation réelle de leur niveau de difficulté. J’ai seulement mené les conversations jusqu’à dix allers-retours ; et j’ai évalué les performances sur une seule mesure.

Il est clair que les modèles T2I et I2T qui se portent le mieux dépendent en grande partie de la complexité de l’invitation et de la durée pendant laquelle vous voulez faire parler les modèles. Néanmoins, il convient de noter quelques observations clés :

1. VQGAN-CLIP peut mieux s’en sortir pour les invitations plus difficiles, mais cela ne signifie pas que c’est un meilleur modèle T2I. Les images produites par VQGAN-CLIP sont souvent beaucoup moins cohérentes et globalement cohérentes que celles produites par Stable Diffusion ou DALL-E2.
2. L’analyse ci-dessus concerne uniquement la similarité sémantique – elle ne prend pas en compte le style. Le style de ces images peut beaucoup changer au cours d’un jeu de téléphone IA. De manière anecdotique, j’ai constaté que le style est beaucoup plus cohérent pour les modèles I2T comme mPLUG-Owl, qui donnent de longues descriptions, que pour les modèles comme BLIP, dont les descriptions sont davantage centrées sur le sujet.
3. À environ cinq ou six itérations, les jeux avaient pour la plupart convergé vers des équilibres stables.
4. Même si le modèle d’incorporation, ImageBind, était multimodal, la distance entre les plongements d’images et de texte consécutifs était beaucoup plus grande que la distance entre les images consécutives ou les descriptions consécutives. En général, ils ont suivi les mêmes tendances, mais de manière moins prononcée, c’est pourquoi je ne les ai pas inclus dans les graphiques.

J’espère que cela vous inspirera à mener vos propres expériences avec l’IA générative – que vous jouiez à l’AI Telephone ou que vous fassiez quelque chose d’entièrement différent !

Si vous essayez une variation de ceci et obtenez des résultats intéressants, commentez ce post !

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