TnVvdm8gc2lzdGVtYSBNZWdhYnl0ZSBkaSBNZXRhOiB1bmEgc3ZvbHRhIG5lbCBzdXBlcmFyZSBnbGkgb3N0YWNvbGkgcGVyIGkgR1BU

2023-06-07, 00:51

<p><img src="https://gimg2.gateimg.com/image/article/1686098682RDZZ.jpeg" alt=""></p>
<p>GPT può tradurre testi, riassumere dati e creare contenuti adatti a scopi diversi come il marketing.</p>
<p>Meta’s Megabyte mira a superare gli ostacoli che altri sistemi GPT come GPT-4 di OpenAi e ChatGPT affrontano.</p>
<p>Megabyte è diverso dagli altri modelli GPT perché non utilizza la tokenizzazione.</p>
<p>Il modello Megabyte comprende un trasformatore locale, un incorporatore di patch e un trasformatore globale.</p>
<h2 id="h2-Introduzione388427"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’innovazione tecnologica ha rivoluzionato il modo in cui gli esseri umani interagiscono e svolgono varie attività, sia personali che aziendali. L’intelligenza artificiale, anche chiamata apprendimento automatico, è in grado di svolgere diverse attività come scrivere saggi o fare piani finanziari. In questo articolo discutiamo dell’importanza del Generative Pre-trained Transformer (GPT) nel trattamento del linguaggio naturale e delle sue applicazioni. Ci concentreremo anche sul sistema megabyte di Meta che supera diversi ostacoli per i GPT.</p>
<h2 id="h2-Significato20dei20GPT20nella20elaborazione20del20linguaggio20naturale334398"><a name="Significato dei GPT nella elaborazione del linguaggio naturale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Significato dei GPT nella elaborazione del linguaggio naturale</h2><p>I generatori di trasformatori preaddestrati (GPT) hanno molti vantaggi in vari settori dell’economia in quanto migliorano la produttività e aumentano la consapevolezza sociale. In primo luogo, è importante sapere che i GPT creano testi simili a quelli umani su vari argomenti.</p>
<p>Gli GPT utilizzano vari parametri per elaborare i dati e presentarli in modi facili da capire. Ci sono diverse applicazioni che utilizzano gli GPT per creare valore per gli esseri umani e la società in generale.</p>
<p>Fondamentalmente, i GPT sono componenti importanti delle applicazioni guidate dall’intelligenza artificiale che traducono informazioni da una lingua all’altra. Generano e riassumono anche grandi volumi di dati in informazioni facili da comprendere. In alcuni casi, i GPT consentono la generazione di contenuti adatti a scopi diversi come poesie, post di blog, saggi accademici, materiali di marketing e meme, tra gli altri.</p>
<p>Le imprese possono anche utilizzare i GPT per alimentare chatbot e assistenti virtuali che possono interagire con persone reali in modo conversazionale, aiutandole a comprendere diversi aspetti aziendali o sociali. A fini aziendali, possono generare un’analisi dei sentimenti su qualsiasi argomento o campo di interesse. Ad esempio, ci sono protocolli guidati da Ai che generano sentimenti di mercato crittografico che consentono ai trader e ad altri investitori di prendere decisioni di investimento informate.</p>
<p>Altri casi d’uso dei GPT nell’elaborazione del linguaggio naturale e nelle applicazioni Ai includono la creazione di contenuti per la commercializzazione di prodotti, il servizio clienti, l’analisi delle informazioni finanziarie nonché l’estrazione e la segnalazione dei dati, tra gli altri.</p>
<h2 id="h2-Limitazioni20dei20modelli20GPT20tradizionali378814"><a name="Limitazioni dei modelli GPT tradizionali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Limitazioni dei modelli GPT tradizionali</h2><p>Anche se ci sono vari <a href="https://www.gate.io/live/video/90b1e91dd5e7fb207b1509a809e5b444" target="_blank">tipi di GPT</a> creati da piattaforme diverse come ChatGPT e Openai, la maggior parte di loro ha gravi limitazioni.</p>
<p>I modelli di IA generativi attualmente migliori <a href="https://www.gate.io/blog_detail/2064/chatgpt-ai-impacts-healthcare-rising-prices-hit-americans-chinas-redistributive-policies-affect-property-developers" target="_blank">compreso il GPT-4 di OpenAI e il ChatGPT</a> utilizzare l’architettura del Transformer che è stata introdotta dai ricercatori di Google. L’aumento delle scale di autoattenzione e della lunghezza degli input e degli output crea una sfida poiché ogni parola ha bisogno di attenzione. Fondamentalmente, questo sistema funziona bene quando vengono utilizzate poche parole in input.</p>
<p>Tuttavia, il metodo Megabyte utilizza un’architettura diversa che divide le sequenze di input e output in patch anziché token. Pertanto, può gestire molte più parole rispetto ai modelli attuali.</p>
<p>Inoltre, l’approccio di Meta risolve il problema di scalabilità comune alla maggior parte dei modelli attualmente presenti sul mercato. Fondamentalmente, il modello Megabyte consente a una singola rete di feedforward di agire su una patch composta da più token. Pertanto, il sistema Megabyte di Meta funziona in parallelo anziché in serie. Ciò aumenta l’efficienza anche se il modello di base ha molti parametri.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/729/the-meta-metaverse-what-is-the-company-working-on" target="_blank">Il Meta Metaverse: su cosa sta lavorando l’azienda?</a></p>
<p>Alcuni modelli come le reti neurali profonde sono complessi da capire e spiegare, il che potrebbe ridurre la fiducia, la responsabilità e sollevare preoccupazioni etiche. Pertanto, c’è bisogno di modelli più semplici come Meta Ai che sono facili da spiegare. Questo perché la maggior parte degli utenti vorrebbe sapere come funziona un sistema per riporre fiducia in esso.</p>
<p>Un’altra problematica è che alcuni di questi modelli richiedono molti dati da convalidare e addestrare. Tuttavia, tali dati potrebbero non essere disponibili, il che ne riduce l’efficienza. Inoltre, problemi legati alla privacy, al bias, al rumore, alla sicurezza e alla incompletezza dei dati influiscono negativamente sulla robustezza e sulle prestazioni della maggior parte dei modelli GPT.</p>
<p>La maggior parte dei modelli di intelligenza artificiale tradizionali è costosa e consuma molta energia durante i calcoli. Questo perché la maggior parte dei sistemi è intensiva dal punto di vista computazionale. Di conseguenza, consumano molte risorse e aumentano i costi ambientali.</p>
<p>Inoltre, la maggior parte di questi modelli ha una bassa interoperabilità a causa delle differenze nella loro standardizzazione. Pertanto, è molto difficile per loro integrarsi poiché utilizzano lingue, framework e formati diversi. Tuttavia, formati aperti come ONNX o compilatori universali possono migliorare la loro comunicazione.</p>
<p>È importante rendersi conto che l’architettura di Meta AI è creata in modo da superare la maggior parte di questi problemi.</p>
<h2 id="h2-Sistema20Megabyte20di20Meta334602"><a name="Sistema Megabyte di Meta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sistema Megabyte di Meta</h2><p>Meta AI ha sviluppato una nuova <a href="https://encord.com/blog/meta-ai-megabyte-model-architecture-explained/" rel="nofollow noopener noreferrer" target="_blank">Sistema GPT chiamato Megabyte</a> con lo scopo di aggirare la tokenizzazione utilizzata dalla maggior parte dei modelli GPT. Il sistema di trasformatori pre-addestrati generativi (GPT) elabora grandi quantità di dati come video e testi come romanzi senza utilizzare la tokenizzazione.</p>
<p>Come punto, la tokenizzazione funziona in modo simile alla compressione dei file attraverso la conversione di grandi quantità di dati in token. Il trasformatore elabora i token per creare token di output che il sistema decodifica.</p>
<p>Normalmente, la tokenizzazione consente ai modelli di intelligenza artificiale di convertire grandi sequenze di dati in numeri. Ad esempio, un sistema può convertire una frase come “Il mio colore preferito è il rosso” in una stringa di token come “3666, 4004, 3124, 318, 2266, 13” che viene poi elaborata.</p>
<p>Tuttavia, con questo metodo c’è un limite sulla quantità di dati che elabora. Ad esempio, il limite di GPT-3.5 è compreso tra 3.000 e 4.000 parole mentre quello di GPT-4 è compreso tra 24.000 e 32.000.</p>
<p>In contrast, <a href="https://www.gate.io/ja/blog_detail/308/why-is-meta-previously-facebook-betting-big-on-metaverse" target="_blank">Meta</a> ha scartato la tokenizzazione a favore della nuova architettura di previsione a più livelli che dipende dalla modellazione end-to-end di oltre un milione di byte di dati. Questo è un grande risultato considerando che può elaborare un documento composto da fino a 750.000 parole. Ciò significa che il sistema Megabyte può elaborare i dati contenuti in tre romanzi di dimensioni medie.</p>
<p>Come indicato, Megabyte supera gli ostacoli della tokenizzazione derivanti dai suoi limiti rigidi sui dati, dal tempo necessario per addestrare i sistemi e dal consumo energetico elevato. Inoltre, senza la tokenizzazione, è possibile addestrare modelli di intelligenza artificiale per supportare lingue non inglesi che possono essere codificate nei caratteri standard a 8 bit, ad esempio.</p>
<p>L’intelligenza artificiale cripto AI di Meta espanderà le opportunità esistenti mentre democratizza ulteriormente varie tecnologie blockchain. Ad esempio, gli sviluppatori possono introdurre bot di trading di criptovalute nella propria lingua madre come il russo o il francese. Ancora più importante, le organizzazioni autonome decentralizzate (DAO) possono codificare i loro protocolli anche in lingue locali.</p>
<h2 id="h2-Come20funziona20il20sistema20Meta20Megabyte229394"><a name="Come funziona il sistema Meta Megabyte" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funziona il sistema Meta Megabyte</h2><p>Megabyte, l’architettura di decodifica multiscale, modella sequenze di più di 1 milione di byte mantenendo la differenziabilità end-to-end. Utilizza trasformatori multiscale che incorporano diversi livelli all’interno della loro architettura, modellando così modelli globali e locali nei dati.</p>
<p>In sostanza, il modello Megabyte è composto da tre componenti, ovvero un modulo locale, un inseritore di patch e un modulo globale (trasformatore globale). Il modulo locale, anche chiamato trasformatore locale, prevede i byte all’interno di ogni patch mentre l’inseritore è responsabile della codifica delle patch mediante la combinazione di embedding di byte. Infine, il modulo globale, anche noto come trasformatore globale, inserisce e produce le diverse rappresentazioni di patch.</p>
<p>Il diagramma seguente mostra la panoramica del Megabyte.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1686098917Meta 1.png" alt=""></p>
<p>Il diagramma sopra mostra alcuni dei componenti chiave di Megabyte. Un recente esperimento ha mostrato che Megabyte può essere più veloce del 40% rispetto al modello Transformer. È però essenziale notare che il Megabyte utilizzato durante l’esperimento aveva 1,5 miliardi di parametri mentre il Transformer ne aveva 350 milioni.</p>
<p>In generale, il Megabyte ha diversi vantaggi rispetto ai trasformatori tradizionali. Ad esempio, riduce i costi computazionali dell’autocertificazione, il che rende possibile gestire sequenze lunghe.</p>
<p>In secondo luogo, utilizza strati feedforward per percorso anziché per posizione, risultando nell’utilizzo efficiente delle risorse computazionali.</p>
<p>Inoltre, migliora un maggiore parallelismo durante l’elaborazione, il che porta a una generazione di sequenze più rapida mantenendo prestazioni elevate.</p>
<p>L’architettura Megabyte migliora la scalabilità, riduce il consumo di risorse e consente una comunicazione fluida con varie applicazioni basate su GPT. Raggiunge alcuni di questi vantaggi dividendo lunghe sequenze in due sequenze più brevi che minimizzano i costi di autoattenzione. Inoltre, la condivisione dei parametri e gli algoritmi di compressione riducono al minimo i requisiti di risorse dei GPT.</p>
<h2 id="h2-Conclusione476050"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Meta’s Megabyte utilizza il sistema generativo di trasformatori pre-addestrati per elaborare grandi volumi di dati senza utilizzare la tokenizzazione. Invece, utilizza un’architettura di previsione a più strati che riduce i costi, migliora la velocità, aumenta l’efficienza e aumenta la scalabilità e l’interoperabilità.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>