TWV0YSdzIG5pZXV3ZSBtZWdhYnl0ZS1zeXN0ZWVtOiBlZW4gZG9vcmJyYWFrIGJpaiBoZXQgb3Zlcndpbm5lbiB2YW4gb2JzdGFrZWxzIHZvb3IgR1BUJ3M=

2023-06-07, 00:51

<p><img src="https://gimg2.gateimg.com/image/article/1686098682RDZZ.jpeg" alt=""></p>
<p>GPT’s kunnen teksten vertalen, gegevens samenvatten en inhoud maken die geschikt is voor verschillende doeleinden zoals marketing.</p>
<p>Meta’s Megabyte heeft tot doel de hindernissen te overwinnen waarmee andere GPT-en zoals OpenAi’s GPT-4 en ChatGPT worden geconfronteerd.</p>
<p>Megabyte verschilt van andere GPT-modellen omdat het geen tokenisatie gebruikt.</p>
<p>Het Megabyte-model bestaat uit een lokale transformator, een patch-embedder en een wereldwijde transformator.</p>
<h2 id="h2-Introductie388965"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Technologische innovatie heeft de manier waarop mensen met elkaar omgaan en verschillende taken uitvoeren, waaronder persoonlijke of zakelijke taken, revolutionair veranderd. Kunstmatige intelligentie, ook wel machine learning genoemd, kan verschillende activiteiten uitvoeren zoals het schrijven van essays of het maken van financiële plannen. In dit artikel bespreken we het belang van Generative Pre-trained Transformer (GPT) in natuurlijke taalverwerking en de toepassingen ervan. We zullen ook focussen op Meta’s megabyte-systeem dat verschillende obstakels voor GPT’s overwint.</p>
<h2 id="h2-Belang20van20GPTs20in20natuurlijke20taalverwerking179905"><a name="Belang van GPT’s in natuurlijke taalverwerking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belang van GPT’s in natuurlijke taalverwerking</h2><p>Generative Pre-trained transformers (GPT’s) hebben veel voordelen in verschillende sectoren van de economie, omdat ze de productiviteit verhogen en het maatschappelijk bewustzijn vergroten. Ten eerste is het belangrijk om te weten dat GPT’s mensachtige teksten creëren over verschillende onderwerpen.</p>
<p>De GPT’s gebruiken verschillende parameters om gegevens te verwerken en deze op een begrijpelijke manier te presenteren. Er zijn verschillende toepassingen die GPT’s gebruiken om waarde te creëren voor mensen en de samenleving in het algemeen.</p>
<p>In feite zijn GPT’s belangrijke componenten van door kunstmatige intelligentie aangestuurde toepassingen die informatie van de ene taal naar de andere vertalen. Ze genereren ook grote hoeveelheden gegevens en vatten deze samen tot gemakkelijk te begrijpen informatie. In sommige glen maken GPT’s het genereren van inhoud mogelijk die geschikt is voor verschillende doeleinden, zoals gedichten, blogberichten, academische essays, marketingmateriaal en memes, onder andere.</p>
<p>Bedrijven kunnen ook GPT’s gebruiken om chatbots en virtuele assistenten aan te sturen die op een gesprekspartnerige manier met echte mensen kunnen communiceren, waardoor ze verschillende zakelijke of sociale aspecten kunnen begrijpen. Voor zakelijke doeleinden kunnen ze sentimentanalyse genereren over elk onderwerp of interessegebied. Als voorbeeld zijn er door Ai aangestuurde protocollen die cryptomarktsentiment genereren, waardoor handelaren en andere investeerders geïnformeerde investeringsbeslissingen kunnen nemen.</p>
<p>Andere toepassingen van GPT’s in natuurlijke taalverwerking en AI-toepassingen omvatten contentcreatie voor marketingproducten, klantenservice, analyse van financiële informatie, evenals gegevensextractie en rapportage, onder andere.</p>
<h2 id="h2-Beperkingen20van20traditionele20GPTmodellen138412"><a name="Beperkingen van traditionele GPT-modellen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Beperkingen van traditionele GPT-modellen</h2><p>Hoewel er verschillende zijn <a href="https://www.gate.io/live/video/90b1e91dd5e7fb207b1509a809e5b444" target="_blank">soorten GPT’s</a> gemaakt door verschillende platforms zoals ChatGPT en Openai, waarvan de meeste ernstige beperkingen hebben.</p>
<p>De huidige beste generatieve AI-modellen <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">inclusief OpenAI’s GPT-4 en ChatGPT</a> gebruik de Transformer-architectuur die werd geïntroduceerd door onderzoekers van Google. De toename van zelfaandacht schaalt en de lengte van invoer- en uitvoerwaarden creëert een uitdaging, aangezien elk woord aandacht nodig heeft. In feite werkt dit systeem goed wanneer er weinig woorden als invoer worden gebruikt.</p>
<p>De Megabyte-methode gebruikt echter een andere architectuur die sequenties van invoer en uitvoer verdeelt in patches in plaats van tokens. Hierdoor kan het veel meer woorden verwerken dan de huidige modellen.</p>
<p>Ook lost de aanpak van Meta het schaalbaarheidsprobleem op dat veel voorkomt bij de meeste modellen die momenteel op de markt zijn. Kort gezegd maakt het Megabyte-model het mogelijk dat een enkel voorwaarts netwerk actief is op een patch bestaande uit meerdere tokens. Daarom werkt het Megabyte-systeem van Meta parallel in plaats van serieel. Dit verhoogt de efficiëntie, zelfs als het basismodel veel parameters heeft.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/729/the-meta-metaverse-what-is-the-company-working-on" target="_blank">De Meta Metaverse: Waar werkt het bedrijf aan?</a></p>
<p>Sommige modellen zoals diepe neurale netwerken zijn complex om te begrijpen en uit te leggen, wat het vertrouwen, de verantwoordelijkheid en de ethische bezwaren kan verminderen. Daarom is er behoefte aan eenvoudigere modellen zoals Meta Ai, die gemakkelijk uit te leggen zijn. Dit komt omdat de meeste gebruikers willen weten hoe een systeem werkt om er vertrouwen in te hebben.</p>
<p>Een ander probleem is dat sommige van deze modellen veel gegevens nodig hebben om te worden gideerd en getraind. Desalniettemin zijn dergelijke gegevens mogelijk niet beschikbaar, wat hun efficiëntie vermindert. Bovendien hebben kwesties met betrekking tot privacy, bias, ruis, beveiliging en gegevensonvolledigheid een negatieve invloed op de robuustheid en prestaties van de meeste GPT-modellen.</p>
<p>De meeste traditionele AI-modellen zijn duur en verbruiken veel energie bij het maken van berekeningen. Dit komt doordat de meeste en rekenintensief zijn. Als zodanig verbruiken ze veel middelen en verhogen ze de milieukosten.</p>
<p>Bovendien hebben de meeste van deze modellen een lage interoperabiliteit als gevolg van verschillen in hun standaardisatie. Daarom is het erg moeilijk voor hen om te integreren, omdat ze verschillende talen, frameworks en formaten gebruiken. Open formaten zoals ONNX of universele compilers kunnen echter hun communicatie verbeteren.</p>
<p>Het is belangrijk om te beseffen dat de architectuur van Meta AI op zo’n manier is gemaakt dat het de meeste van deze problemen overwint.</p>
<h2 id="h2-Metas20Megabytesysteem828298"><a name="Meta’s Megabyte-systeem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Meta’s Megabyte-systeem</h2><p>Meta AI heeft een nieuwe ontwikkeld <a href="https://encord.com/blog/meta-ai-megabyte-model-architecture-explained/" rel="nofollow noopener noreferrer" target="_blank">GPT-systeem genaamd de Megabyte</a> met als doel het omzeilen van tokenisatie die de meeste GPT-modellen gebruiken. Het generatieve voorgeleerde transformer (GPT) systeem verwerkt grote hoeveelheden gegevens zoals video’s en teksten zoals romans zonder gebruik te maken van tokenisatie.</p>
<p>Als punt functioneert tokenisatie op een vergelijkbare manier als bestandscompressie door grote hoeveelheden gegevens om te zetten in tokens. De transformer verwerkt de tokens om uitvoertokens te maken die door het systeem worden gedecodeerd.</p>
<p>Normaal gesproken maakt tokenisatie het mogelijk voor AI-modellen om grote hoeveelheden gegevens om te zetten in cijfers. Zo kan een systeem een zin als ‘Mijn favoriete kleur is rood’ omzetten in een tokenreeks zoals ‘3666, 4004, 3124, 318, 2266, 13’, die vervolgens wordt verwerkt.</p>
<p>Bij deze methode is er echter een limiet aan de hoeveelheid gegevens die het verwerkt. Bijvoorbeeld, de limiet van GPT-3.5 is tussen de 3.000 en 4.000 woorden, terwijl die van GPT-4 tussen de 24.000 en 32.000 ligt.</p>
<p>In tegenstelling tot, <a href="https://www.gate.io/ja/blog_detail/308/why-is-meta-previously-facebook-betting-big-on-metaverse" target="_blank">Meta</a> heeft tokenisatie laten vallen ten gunste van de nieuwe voorspellingsarchitectuur met meerdere lagen die afhankelijk is van end-to-end modellering van meer dan één miljoen bytes aan gegevens. Dit is een geweldige prestatie als je bedenkt dat het een document van maximaal 750.000 woorden kan verwerken. Dit betekent dat het Megabyte-systeem gegevens kan verwerken die in drie gemiddelde romans zijn opgenomen.</p>
<p>Zoals opgemerkt, overwint Megabyte de struikelblokken van tokenisatie die voortkomen uit de strenge gegevenslimieten, de lange tijd die nodig is om en te trainen en het hoge energieverbruik. Ook is het zonder tokenisatie mogelijk om AI-modellen te trainen om niet-Engelse talen te ondersteunen die kunnen worden gecodeerd in de standaard 8-bits karakters, bijvoorbeeld.</p>
<p>Meta’s kunstmatige intelligentie crypto AI zal bestaande mogelijkheden uitbreiden terwijl het verschillende blockchaintechnologieën verder democratiseert. Bijvoorbeeld kunnen ontwikkelaars cryptocurrency-handelsbots in hun moedertaal introduceren, zoals Russisch of Frans. Belangrijker nog, gedecentraliseerde autonome organisaties (DAO’s) kunnen ook hun protocollen coderen in lokale talen.</p>
<h2 id="h2-Hoe20het20Meta20Megabyte20systeem20werkt166100"><a name="Hoe het Meta Megabyte systeem werkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe het Meta Megabyte systeem werkt</h2><p>Megabyte, de multiscale decoder-architectuur, modelleert sequenties van meer dan 1 miljoen bytes terwijl end-to-end differentieerbaarheid behouden blijft. Het maakt gebruik van multiscale transformers die verschillende niveaus in hun architectuur opnemen en daardoor zowel globale als lokale patronen in gegevens modelleren.</p>
<p>De Megabyte-model bestaat in principe uit drie componenten, namelijk een lokaal module, een patch-embedder en een globale module (globale transformer). De lokale module, ook wel de lokale transformer genoemd, voorspelt de bytes binnen elke patch terwijl de embedder verantwoordelijk is voor het coderen van patches door het combineren van byte-embeddings. Ten slotte voert de globale module, ook bekend als de globale transformer, de verschillende patch-representaties in en uit.</p>
<p>De volgende diagram toont het overzicht van Megabyte.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1686098917Meta 1.png" alt=""></p>
<p>Het bovenstaande diagram toont enkele van de belangrijkste componenten van Megabyte. Een recent experiment toonde aan dat de Megabyte 40% sneller kan zijn dan het Transformer-model. Het is echter essentieel op te merken dat de megabyte die tijdens het experiment werd gebruikt, 1,5 miljard parameters had, terwijl de transformator er 350 miljoen had.</p>
<p>Over het algemeen heeft de Megabyte verschillende voordelen ten opzichte van de traditionele transformatoren. Zo vermindert het de computationele kosten van zelfattestatie, waardoor het mogelijk is om lange sequenties te verwerken.</p>
<p>Ten tweede maakt het gebruik van feedforward-lagen per pad in plaats van per positie, wat resulteert in efficiënt gebruik van rekenbronnen.</p>
<p>Ook zorgt het voor een grotere paralleliteit tijdens de verwerking, wat leidt tot snellere sequentiegeneratie met behoud van hoge prestaties.</p>
<p>De Megabyte-architectuur verbetert de schaalbaarheid, vermindert het resourceverbruik en maakt soepele communicatie met verschillende op GPT gebaseerde toepassingen mogelijk. Het bereikt enkele van deze voordelen door lange sequenties op te delen in twee kortere sequenties, wat de kosten van zelfaandacht minimaliseert. Bovendien minimaliseren parameterdeling en compressiealgoritmen de resourcevereisten van GPT’s.</p>
<h2 id="h2-Conclusie854480"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Meta’s Megabyte maakt gebruik van het generatieve, voorgeleerde transformer-systeem om grote hoeveelheden gegevens te verwerken zonder tokenisatie te gebruiken. In plaats daarvan maakt het gebruik van een multi-laagse voorspellingsarchitectuur die kosten minimaliseert, de snelheid verbetert, de efficiëntie verbetert en de schaalbaarheid en interoperabiliteit vergroot.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Mashell C.</strong>, Gate.io Onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>