AI Telephone – Una Battaglia di Modelli Multimodali

AI Telephone - Multimodal Model Battle.

DALL-E2, Stable Diffusion, BLIP, e altro ancora!

L’AI generativa è al centro dell’attenzione al momento. Negli ultimi mesi in particolare, si è assistito a un’esplosione nell’apprendimento automatico multimodale, ovvero l’AI che connette concetti attraverso diverse “modalità” come testo, immagini e audio. Ad esempio, Midjourney è un modello testo-immagine multimodale, perché accetta il linguaggio naturale e produce immagini. Il capolavoro di questa recente rinascita nella sinergia multimodale è stato ImageBind di Meta AI, che può prendere in input 6(!) varietà e rappresentarle nello stesso “spazio”.

Con tutta questa eccitazione, volevo mettere alla prova i modelli multimodali e vedere quanto sono realmente buoni. In particolare, volevo rispondere a tre domande:

1. Quale modello testo-immagine è il migliore?
2. Quale modello immagine-testo è il migliore?
3. Cosa è più importante, immagine-testo o testo-immagine?

Certo, ogni modello porta i propri pregiudizi sul tavolo, dai dati di addestramento all’architettura del modello, quindi non c’è mai un modello MIGLIORE. Ma possiamo comunque mettere i modelli alla prova in un contesto generale!

Per rispondere a queste domande, ho deciso di giocare a un gioco di AI Telephone, ispirato al gioco da tavolo Telestrations, che io e la mia famiglia amiamo giocare insieme.

• Gestione facile dei modelli di apprendimento approfondito tramite configurazioni TOML
• Ehi GPU, cosa succede con la mia matrice?
• Se l’arte è il modo in cui esprimiamo la nostra umanità, dove si colloca l’IA?

Telestrations è molto simile al gioco del telefono: i giocatori si passano attorno in cerchio, ricevendo comunicazioni dalla persona a fianco e, a loro volta, comunicando la loro interpretazione alla persona dall’altro lato. Man mano che il gioco procede, il messaggio originale viene inevitabilmente alterato, se non addirittura perso del tutto. Telestrations differisce, però, aggiungendo la comunicazione bimodale: i giocatori alternano tra disegnare (o illustrare) una descrizione e descrivere (in testo) una descrizione.

Dato che ero più interessato a confrontare i modelli, ho adattato il gioco allo scopo.

Ecco come funziona il gioco di AI Telephone:

1. Ogni “partita” accoppierà un modello immagine-testo (I2T) con un modello testo-immagine (T2I)
2. Dato un prompt iniziale, utilizziamo il modello T2I per generare un’immagine.
3. Passiamo quindi questa immagine al modello I2T per generare una descrizione.
4. Ripetiamo i passaggi 2 e 3 un numero fisso di volte n (nel nostro caso n=10).
5. Infine, quantifichiamo la differenza tra il prompt originale e la descrizione finale.

In questo post, ti guiderò attraverso l’intero processo, in modo che tu possa giocare anche tu a AI Telephone! Alla fine, risponderò alle tre domande motivanti.

Nota: questo gioco di AI Telephone è intimamente legato alla nozione di consistenza del ciclo. Incorporando un termine di consistenza del ciclo nella funzione di perdita durante l’addestramento, i modelli possono essere incentivati a minimizzare efficacemente la degradazione durante un gioco del telefono. A mia conoscenza, nessuno dei modelli considerati in questo esperimento è stato addestrato tenendo in considerazione la consistenza del ciclo.

Il post è strutturato come segue:

1. Scegliere i modelli multimodali
2. Generare i prompt
3. Creare le linee telefoniche
4. Effettuare le conversazioni
5. Visualizzare e analizzare i risultati

Tutto il codice per eseguire questo esperimento e giocare a AI Telephone può essere trovato qui.

Per eseguire questo codice, dovrai installare la libreria open source FiftyOne per la cura dei dati del dataset, la libreria Python OpenAI e il client Python Replicate.

pip install fiftyone openai replicate

Progressione delle immagini in una partita di AI Telephone tra DALL-E2 e BLIP.

Scegliere i concorrenti

Lo spazio dei modelli multimodali è enorme: al momento della scrittura, solo Hugging Face ha 4.425 modelli T2I e 155 modelli I2T. Giocare a AI Telephone con tutti questi modelli – o anche con una frazione non trascurabile di essi – sarebbe completamente impraticabile. Il mio primo compito è stato ridurre questo spazio di candidati potenziali a un insieme di concorrenti più gestibile.

Optare per le API

Per iniziare questo progetto, sapevo che avrei lavorato con molti modelli. Alcuni dei modelli prospettici erano abbastanza grandi e molti richiedevano i propri ambienti, con un insieme unico di requisiti. Dato che avevo pianificato di abbinare ogni modello T2I con ogni modello I2T, l’installazione di questi modelli localmente per giocare ai giochi del telefono dell’AI presentava un potenziale purgatorio delle dipendenze – specialmente perché lavoro su un MacBook Pro M1!

Per aggirare questo problema, ho deciso di attenermi ai modelli accessibili tramite API. In particolare, ho scelto di utilizzare principalmente Replicate, la cui semplice interfaccia mi ha permesso di lavorare con modelli T2I e I2T in modo plug-and-play. Quasi tutti i modelli che ho utilizzato sono open source, quindi se sei più coraggioso di me, puoi eseguire questi modelli in locale e evitare le spese. Detto questo, in totale questo esperimento è costato meno di $15 USD.

Modelli di testo-immagine

Nella selezione dei modelli T2I, ho scelto tra i modelli nella collezione Text to image di Replicate. I miei criteri di selezione erano che il modello doveva essere economico, veloce e relativamente popolare (giudicato dal numero di “runs” del modello su Replicate). Inoltre, il modello doveva essere a uso generale, il che significa che non avrei considerato modelli di outpainting, generazione di loghi o stile anime. Se vuoi, sei più che benvenuto a provare a giocare al telefono dell’AI con questi tipi di modelli!

Data questa requisito, ho scelto Stable Diffusion e Feed forward VQGAN CLIP . Inizialmente, ho anche lavorato con DALL-E Mini, ma nei primi test sono rimasto deluso dalle prestazioni del modello, quindi ho sostituito il modello con DALL-E2 di OpenAI, a cui ho acceduto tramite l’endpoint di generazione di immagini di OpenAI.

Come nota a margine, limitando la mia attenzione ai modelli accessibili tramite API, non ho considerato Midjourney. Non c’è un’API ufficiale e non volevo utilizzare un’API non ufficiale, né volevo inserire i suggerimenti in Discord uno per uno e scaricare le immagini generate una alla volta.

Per rendere questo processo il più plug-and-play possibile, ho adottato un approccio orientato agli oggetti. Ho definito una classe di base Text2Image, che espone un metodo 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

Per i modelli di Replicate, tutto ciò che serve è impostare l’attributo model_name, identificando il modello su Replicate. Per Stable Diffusion, ad esempio, la definizione della classe è la seguente:

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

Per altri modelli, come DALL-E2, il metodo generate_image(text) può essere sovrascritto:

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']

Ciascuno di questi modelli T2I restituisce l’URL dell’immagine generata, che possiamo quindi passare direttamente ai nostri modelli I2T.

Modelli di immagine-testo

Ho seguito un processo simile per determinare i concorrenti I2T, valutando i candidati nella collezione Image to text di Replicate. Dopo aver guardato gli esempi per tutti i modelli nella collezione, sei modelli si sono distinti: BLIP, BLIP-2, CLIP prefix captioning, Fine-grained Image Captioning with CLIP Reward, mPLUG-Owl e MiniGPT-4. Altri modelli erano allettanti, come CLIP Interrogator, che cerca di invertire l’ingegnerizzazione di un prompt che puoi quindi usare per generare un’immagine simile. Ma questo sentiva un po’ come barare per quanto riguarda il telefono dell’AI!

Giocando con i sei candidati I2T, sono stato in grado di eliminare rapidamente due modelli dalla competizione: le risposte generate da BLIP-2 erano costantemente troppo brevi per essere utili, e il modello di ricompensa didascalia CLIP generava risposte spesso incoerenti.

In diretta analogia con i modelli T2I, ho definito una classe di base Image2Text esponendo un metodo generate_text(image_url):

class Image2Text(object):    """Wrapper for an Image2Text model."""    def __init__(self):        self.name = None        self.model_name = None        self.task_description = "Scrivere una descrizione dettagliata di questa immagine."    def generate_text(self, image_url):        response = replicate.run(            self.model_name,             input={                "image": image_url,                "prompt": self.task_description,                }            )        return response 

Ho quindi creato sottoclassi per ogni modello. Ecco come appare la sottoclasse BLIP:

class BLIP(Image2Text):    """Wrapper for a BLIP model."""    def __init__(self):        super().__init__()        self.name = "blip"        self.model_name = "salesforce/blip:2e1dddc8621f72155f24cf2e0adbde548458d3cab9f00c0139eea840d0ac4746"

Tutti i modelli sono istanziati con la stessa descrizione del compito – “Scrivi una descrizione dettagliata di questa immagine”.

Progressione delle immagini in un gioco di AI Telephone tra DALL-E2 e mPLUG-Owl.

Prompts

Per essere il più “scientifico” possibile, ho pensato fosse meglio non generare io stesso i prompt iniziali. Invece, (e solo per divertimento) ho appaltato il compito a ChatGPT. Ho chiesto:

Sto giocando a un gioco del telefono usando modelli AI di testo-immagine e immagine-testo. Voglio valutare questi modelli in base alla loro capacità di conservare informazioni semantiche complesse nel corso di lunghe conversazioni. Il tuo lavoro è quello di darmi 10 prompt di testo che posso usare per giocare a questi giochi del telefono. Devi darmi un prompt facile, 3 Nisoo, 3 difficile e 1 ultra-difficile

Sto giocando a un gioco del telefono usando modelli AI di testo-immagine e immagine-testo. Voglio valutare questi modelli in base alla loro capacità di conservare informazioni semantiche complesse nel corso di lunghe conversazioni. Il tuo lavoro è quello di darmi 10 prompt di testo che posso usare per giocare a questi giochi del telefono. Devi darmi un prompt facile, 3 Nisoo, 3 difficile e 1 ultra-difficile (“impossibile”)

Ecco alcuni dei prompt generati da ChatGPT:

Facile: "Una mela rossa seduta su un tavolo di legno con la luce del sole che entra da una finestra."Nisoo: "Un astronauta che fluttua nella Stazione Spaziale Internazionale, guardando fuori dalla finestra verso la Terra, con una capsula spaziale attraccata sullo sfondo."Difficile: "Un affollato mercato in una antica città del Medio Oriente. I commercianti si barattano spezie e sete, i cammelli trasportano merci, il sole tramonta dietro una moschea con una luna crescente visibile."Impossibile: "Una scena panoramica di una civiltà aliena avanzata su un lontano pianeta extrasolare. Veicoli interstellari volano in un cielo indaco sopra imponenti strutture cristalline. Alieni con diverse caratteristiche fisiche interagiscono, impegnati in attività come lo scambio di sfere energetiche, la comunicazione attraverso schemi luminosi, e la cura di una flora esotica e bioluminescente. Le due lune del pianeta sono visibili all'orizzonte su un'ocean alieno lucente."

Un approccio scientifico più rigoroso sarebbe molto più intenzionale con i prompt utilizzati, così come la loro categorizzazione.

Ho quindi preso i prompt di testo generati da ChatGPT e ho costruito gli oggetti Prompt, che contenevano il testo per il prompt e il “livello” di difficoltà assegnato da ChatGPT:

class Prompt(object):    def __init__(self, text, level):        self.text = text        self.level = levellevels = ["facile", "Nisoo", "difficile", "impossibile"]level_prompts = [easy_texts, Nisoo_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

Progressione delle immagini in un gioco di AI Telephone tra VQGAN-CLIP e MiniGPT-4.

La Linea Telefonica

Il componente finale per giocare a AI Telephone è la “linea telefonica” stessa. Ho creato una classe TelephoneLine per incapsulare la connessione tra un modello T2I e un modello I2T. Dato una singola linea telefonica, un “gioco” del telefono viene giocato chiamando il metodo play(prompt, nturns=10), dove la conversazione evolve da prompt, e si svolge per nturns turni di andata e ritorno.

import osimport hashlibimport fiftyone as fofrom fiftyone import ViewField as Fclass TelephoneLine(object):    """Classe per giocare a telefono con 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):        """Gioca a un gioco del telefono."""        print(f"Collegando {self.t2i.name} <-> {self.i2t.name} con 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        }

Per ogni gioco giocato, la conversazione viene registrata con un nome univoco, generato dall’hashing del nome del modello T2I, il nome del modello I2T e il testo prompt (get_conversation_name() metodo).

Ho anche dotato la classe di un metodo save_conversations_to_dataset(), che salva le immagini e le descrizioni di tutti i giochi giocati sulla linea telefonica in un Dataset FiftyOne:

 def save_conversations_to_dataset(self, dataset):        """Salva le conversazioni in 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)

Progressione delle immagini in un gioco di AI Telephone tra Stable Diffusion e CLIP Prefix Captioning.

Svolgere le conversazioni

Con tutti i mattoncini a disposizione, giocare ad AI Telephone è un gioco da ragazzi!

Possiamo istanziare i modelli T2I e I2T:

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

E quindi creare una linea telefonica per ogni coppia:

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

Carichiamo quindi i nostri prompt:

prompts = get_prompts()

E creiamo un Dataset FiftyOne che useremo per memorizzare le immagini generate e tutte le informazioni rilevanti dalle conversazioni:

import fiftyone as fo
dataset = 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)

Poi possiamo eseguire tutte le 120 partite di telefono:

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

Nell’app FiftyOne, fare clic sull’icona di divisione nella barra dei menu per raggruppare le immagini per conversazione, selezionare conversation_name dal menu a discesa, quindi attivare il selettore su ordered e selezionare step_number.

Risultati e Conclusioni

Per valutare la qualità di una conversazione – puramente in termini di quanto approssimava il significato della descrizione finale al significato del prompt iniziale, ho deciso di generare embedding per i prompt e le descrizioni e calcolare la distanza coseno (in [0, 2]) tra i due.

from scipy.spatial.distance import cosine as cosine_distance

Per un modello di embedding, volevo un modello che potesse incorporare sia testo che immagini, data la natura multimodale dell’esercizio. Alla fine ho scelto di usare ImageBind per tre motivi:

1. Altri modelli di embedding immagine-testo come CLIP e BLIP sono correlati ad alcuni dei modelli utilizzati nell’esperimento (prefissi di captioning BLIP e CLIP), e ho voluto evitare qualsiasi possibile pregiudizio dall’uso degli stessi tipi di modelli per la valutazione.
2. Molti modelli di embedding di testo hanno un piccolo max_token_count – il numero massimo di token consentiti in un testo da incorporare. CLIP, ad esempio, ha max_token_count=77. Alcune delle nostre descrizioni sono significativamente più lunghe di questo. Fortunatamente, ImageBind ha un conteggio massimo di token molto più lungo.
3. Volevo provare ImageBind, e questa era un’ottima opportunità!

Ho avvolto l’API di ImageBind di Replicate in una funzione 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)

Per evitare calcoli ridondanti, ho hashato i prompt e memorizzato gli embedding dei prompt in un dizionario. In questo modo, anziché incorporare ogni prompt per ciascuna delle 12 linee di telefono, dobbiamo incorporare solo una volta per ciascuna:

import hashlib
def hash_prompt(prompt):
    return hashlib.md5(prompt.encode()).hexdigest()[:6]
### Embed initial prompts
prompt_embeddings = {}
dataset.add_sample_field("prompt_hash", fo.StringField)
## Group samples by initial prompt
## Add hash to all samples in group
prompt_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")

Poi possiamo raggruppare i campioni per nome della conversazione, iterare attraverso questi gruppi, calcolare l’embedding del testo per ogni passaggio e registrare la distanza coseno (più piccola è meglio!) tra l’embedding del testo e l’embedding del prompt iniziale:

dataset.add_sample_field("text_after_dist", fo.FloatField)
conversation_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
        )

Ho quindi calcolato i punteggi medi per ogni coppia T2I-I2T per tutte le indicazioni a un certo livello di difficoltà e ho tracciato i risultati. In ciascuno dei video, i modelli I2T e T2I sono stampati sulle immagini generate, così come il testo utilizzato per generare quella immagine (rosso), e la descrizione generata da quella immagine (verde).

Facile

Per le indicazioni facili, le prestazioni tendono a dipendere maggiormente dal modello di testo-immagine. DALL-E2 e Stable Diffusion superano nettamente VQGAN-CLIP. MiniGPT-4 è membro di entrambe le coppie più performanti.

Ecco alcuni esempi per l’indicazione facile introdotta sopra:

AI Telephone per una indicazione facile, con coppie di modelli di testo-immagine e immagine-testo.

Nelle partite con MiniGPT-4 (e in misura leggermente inferiore BLIP), la mela rimane al centro, mentre per i giochi che coinvolgono CLIP Prefix, la mela viene gradualmente sostituita.

Nisoo

Quando le indicazioni diventano un po’ più difficili, la situazione inizia a cambiare.

AI Telephone per un’indicazione di difficoltà Nisoo, con coppie di modelli di testo-immagine e immagine-testo.

Per quasi tutti i giochi, il soggetto cambia circa al quarto o quinto passo. All’inizio, MiniGPT-4 ha un vantaggio. Ma alla fine del gioco, sembra che quel vantaggio sia stato interamente perso.

Difficile

Quando le indicazioni diventano impegnative, vediamo qualcosa di interessante: per i primi passi, il modello immagine-testo è il più importante (MiniGPT-4 è il migliore, e CLIP Prefix è per lo più il peggiore). Tuttavia, in fasi successive, il modello di testo-immagine diventa il più importante. E per complicare ulteriormente la situazione, VQGAN-CLIP è il migliore qui!

Si potrebbe pensare che “migliore” potrebbe significare solo che viene mantenuta la coerenza, senza rappresentare accuratamente il concetto originale. Tuttavia, quando guardiamo gli esempi, possiamo vedere che questo non è il caso.

AI Telephone per un’indicazione difficile, con coppie di modelli di testo-immagine e immagine-testo.

Prendiamo ad esempio quello evidenziato nel video, in cui l’indicazione iniziale è l’indicazione “difficile” introdotta sopra riguardante un “mercato affollato”. Mentre le immagini generate da VQGAN-CLIP sono senza dubbio granulari, il soggetto può ancora essere identificato, e si avvicina abbastanza all’indicazione originale.

Impossibile

Non sorprende che nessuno dei nostri concorrenti abbia avuto un successo particolarmente positivo qui. Si potrebbe argomentare che VQGAN-CLIP sia il vincitore. Ma per la maggior parte, questo è solo rumore. Nel video, anche per i giochi che coinvolgono VQGAN-CLIP, il soggetto è effettivamente irriconoscibile.

AI Telephone per un’indicazione “impossibile”, con coppie di modelli di testo-immagine e immagine-testo.

Conclusioni

Questa esplorazione è stata ben lontana da essere scientifica; ho solo esaminato dieci indicazioni, senza una vera validazione del loro livello di difficoltà. Ho solo fatto conversazioni fino a dieci scambi di battute; e ho valutato le prestazioni su una sola metrica.

È chiaro che quali modelli T2I e I2T funzionano meglio dipende in gran parte dalla complessità dell’indicazione, e per quanto tempo si vuole far parlare i modelli. Tuttavia, vale la pena notare alcune osservazioni chiave:

1. VQGAN-CLIP potrebbe funzionare meglio per indicazioni più impegnative, ma questo non significa che sia un modello T2I migliore. Le immagini prodotte da VQGAN-CLIP sono spesso molto meno coerenti e globalmente coerenti rispetto a quelle prodotte da Stable Diffusion o DALL-E2.
2. L’analisi precedente riguarda solo la somiglianza semantica – non tiene conto dello stile. Lo stile di queste immagini può cambiare molto nel corso di un gioco di AI Telephone. Aneddoticamente, ho scoperto che lo stile è molto più consistente per i modelli I2T come mPLUG-Owl, che forniscono lunghe descrizioni, che per i modelli come BLIP, le cui descrizioni sono più incentrate sul soggetto.
3. Dopo circa cinque o sei iterazioni, i giochi si erano per lo più convergenti a equilibri stabili.
4. Anche se il modello di embedding, ImageBind, era multimodale, la distanza tra i singoli embedding di immagini e di testo era molto maggiore della distanza tra immagini o descrizioni consecutive. In generale, seguivano le stesse tendenze, ma in modo meno pronunciato, motivo per cui non le ho incluse nei grafici.

Spero che questo ti ispiri a condurre i tuoi esperimenti con l’AI generativo – che tu stia giocando a AI Telephone o facendo qualcos’altro del tutto!

Se provi una variazione di questo e ottieni risultati interessanti, commenta questo post!