S2FuIEFJIGRpZSBsaWZ0ZW4gbGVpZGVuIHRvdCBlZW4gbmlldXdlIHRyZW5kIGluIGJ1bGxtYXJrdHZlcmhhbGVuPw==

2024-03-19, 08:46

<p><img src="https://gimg2.gateimg.com/image/article/1710838001sdfx.jpeg" alt=""></p>
<h2 id="h2-TLDR857773"><a name="[TL；DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL；DR]</h2><p>De AI+Web3-track kan ruwweg worden verdeeld in drie lagen: de infrastructuurlaag, de tussenlaag en de toepassingslaag. De infrastructuurlaag richt zich op het leveren van rekenkracht en opslag, wat momenteel het meest populaire en populaire gebied is.</p>
<p>Naast toepassingen op het niveau van de applicatielaag in gaming, sociale netwerken en handel, kan AI ook worden gebruikt op gebieden zoals gegevensanalyse, informatiebewaking en -tracking, en bieden op weddenschappen.</p>
<p>Projecten die nauw verbonden zijn met het concept van AI winnen vaak snel marktgunst, maar er moet aandacht worden besteed aan het filteren van projecten die hun naam niet waarmaken en puur gericht zijn op populaire onderwerpen.</p>
<h2 id="h2-Introductie636764"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Onlangs heeft een reeks AI+Web3-projecten de markt enthousiast gemaakt. Om deze potentiële marktkans diepgaand te verkennen, zal Gate.io Research verschillende populaire projecten combineren om een diepgaande analyse uit te voeren van diverse schakels in de AI+Web3-industrieketen, om lezers een uitgebreid en diepgaand begrip te bieden.</p>
<h2 id="h2-AIWeb320Nieuwe20Technologie20Nieuwe20Richting20Nieuwe20Speculatie287269"><a name="AI+Web3: Nieuwe Technologie, Nieuwe Richting, Nieuwe Speculatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+Web3: Nieuwe Technologie, Nieuwe Richting, Nieuwe Speculatie</h2><p>Vorig jaar, met de opkomst van grootschalige generatieve AI-modellen zoals ChatGPT, is AI een veelbesproken investeringsthema geworden dat wordt nagestreefd door de wereldwijde kapitaalmarkt. Tegelijkertijd heeft de Web3-markt ook een nieuwe golf van welvaart ingeluid.</p>
<p>De organische combinatie van AI en <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> wordt ongetwijfeld het kruispunt van de twee hete onderwerpen in het huidige technologieveld. Onlangs hebben we een groot aantal nieuwe en oude projecten rond dit thema gezien die marktaandacht krijgen, wat de sterke interesse en hoge verwachtingen van investeerders voor deze combinatie benadrukt.</p>
<p>Volgens de definitie van de Wanxiang blockchain komt de combinatie van AI en Web3 vooral tot uiting in twee aspecten: hoe Web3 de ontwikkeling van AI bevordert en hoe Web3-toepassingen AI-technologie combineren. Momenteel neigen de meeste projecten ernaar om Web3-technologie en -concepten te gebruiken om de vooruitgang van AI te stimuleren. Om deze combinatie te analyseren, kunnen we beginnen met het hele proces van AI van modeltraining tot toepassing.</p>
<p>Het productieproces van AI omvat grofweg: gegevensverwerving, die een basis biedt voor modeltraining; Gegevenspreprocessing en functie-/hint-engineering, waarbij gegevensreiniging, annotatie en gestructureerde queries betrokken zijn; Modeltraining en optimalisatie, waarbij de prestaties van het model worden verbeterd via iteratie; Modelbeoordeling en governance om de kwaliteit en transparantie van het model te waarborgen; Modelinferentie, waarbij nieuwe gegevens worden voorspeld; Modelimplementatie en -monitoring om optimale prestaties van het model in praktische toepassingen te garanderen.</p>
<p>In dit proces heeft Web3 veel integratiepunten. Bijvoorbeeld, het gedistribueerde netwerk en stimuleringsmechanisme van Web3 kunnen meer open en open-source AI-netwerken en gemeenschappen opbouwen, aan de behoeften van AI-toepassingen voor goedkope, open infrastructuur en datanetwerken voldoen. Tegelijkertijd kan het combineren van Web3 met cryptotechnologieën zoals ZK de vertrouwenskwesties van AI verbeteren, uitdagingen zoals modeltransparantie, vooringenomenheid en ethische toepassingen aanpakken.<br><img src="https://gimg2.gateimg.com/image/article/17108378111.jpeg" alt=""><br>Bron: Wanxiang blockchain</p>
<p>Zoals te zien is in de bovenstaande afbeelding, kan de AI+Web3-track grofweg worden verdeeld in drie lagen: de infrastructuurlaag, de tussenlaag en de toepassingslaag.</p>
<p>De infrastructuurlaag richt zich op het leveren van rekenkracht en opslag, en de toevoeging van Web3 kan de kosten verlagen en meer AI-toepassingen ondersteunen.</p>
<p>De middelste laag maakt gebruik van Web3-technologie om AI-productieprocessen te optimaliseren, zoals gegevensverwerving, voorbewerking en modelvalidatie, resulterend in talrijke innovatieve projecten.</p>
<p>De toepassingslaag toont de brede toepassing van AI in Web3, zoals contentgeneratie, analyse en voorspelling. Op basis van de observatie van de auteur is de beschrijving van de toepassingslaag in de bovenstaande figuur nog steeds vrij conservatief. We zullen het vanmiddag gedetailleerd bespreken. Hoewel er nog geen toonaangevende projecten zijn geweest, is het potentieel enorm en zal toekomstige concurrentie zich richten op product- en technologische mogelijkheden.</p>
<p>We zullen specifieke casestudy’s geven voor deze drie projecten in de volgende secties.</p>
<h2 id="h2-AIWeb320Trending20Projects20Emerge20One20After20Another470663"><a name="AI+Web3 Trending Projects Emerge One After Another" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+Web3 Trending Projects Emerge One After Another</h2><h3 id="h3-AIDePIN396347"><a name="AI+DePIN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+DePIN</h3><p>De volledige workflow van AI steunt op de ondersteuning van reken- en opslaginfrastructuur. Deze voorzieningen zijn niet alleen verantwoordelijk voor het leveren van krachtige rekenkracht voor modeltraining en voorspelling, maar ook voor het opslaan, beheren en parsen van gegevens gedurende het gehele datamodel en de levenscyclus.</p>
<p>Op dit moment heeft de snelle groei van AI-toepassingen geleid tot een enorme vraag naar infrastructuur, met name krachtige rekenkracht. Daarom is het ontwikkelen van efficiëntere, kosteneffectieve en rijke reken- en opslaginfrastructuur een belangrijke trend in de beginfase van AI-ontwikkeling, wat momenteel het meest populaire gebied is.<img src="https://gimg2.gateimg.com/image/article/17108378632.jpeg" alt=""><br>Bron: <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Render</a> Netwerk</p>
<p>In dit veld zijn verschillende representatieve projecten ontstaan, zoals het renderingsnetwerk dat is ontstaan in de vorige bullmarkt en voornamelijk renderdiensten levert, Akash dat zich richt op cloud computing, <a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a> en <a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">Arweave</a> die zich richten op cloudopslag, IO.NET en Aethir die nieuw gelanceerd zijn in deze bullmarkt en voornamelijk rekenkracht bieden ter ondersteuning van AI. In ons recente artikel “ <a href="https://www.gate.io/zh/blog_detail/3923/bome%E5%88%9B%E9%80%A0%E6%9A%B4%E6%B6%A8%E8%AE%B0%E5%BD%95-%E7%9B%98%E7%82%B9sol%E9%82%A3%E4%BA%9B%E4%B8%8D%E5%BE%97%E4%B8%8D%E7%9C%8B%E7%9A%84%E7%83%AD%E9%97%A8%E9%A1%B9%E7%9B%AE" target="_blank">BOME creëert een record voor exploderende prijzen, analyseer de trending projecten in het SOL ecosysteem</a>“het introduceerde baanbrekende projecten zoals IO.NET, waar hier niet verder op zal worden ingegaan.”</p>
<h3 id="h3-AIData715967"><a name="AI+Data" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+Data</h3><p>De middelste laag is een sleutel <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> in het AI-productieproces, dat gebruik maakt van Web3-technologie om specifieke workflows te optimaliseren en verbeteren.</p>
<p>In de eerste fase, in de gegevensverwerving fase, introduceert de tussenlaag gedecentraliseerd gegevensidentiteitsbeheer, wat niet alleen de beveiliging van gebruikersgegevens beschermt, maar ook zorgt voor duidelijk eigendom van de gegevens. Tegelijkertijd kunnen gebruikers door middel van stimuleringsmechanismen worden aangemoedigd om hoogwaardige gegevens te delen om te monetariseren, waardoor de bronnen van gegevens worden uitgebreid.</p>
<p>Vanwege de beperkingen van de ontwikkelingsfase van de industrie waren er in de vorige rondes van stieren- en berenmarkten bijna geen relatief bekende projecten op dit gebied. In deze stierenmarkt zijn er AI-identiteitsprojecten geweest zoals Worldcoin (waarover we meerdere keren hebben geschreven), Aspecta geïnvesteerd door Gate.io, Ocean Protocol, een datatransactieplatform, en Grass, een datanetwerk voor breedbandmijnbouw.<img src="https://gimg2.gateimg.com/image/article/17108378893.jpeg" alt=""><br>Bron: Aspecta</p>
<p>Ten tweede is de middelste laag in de gegevensvoorverwerkingsfase toegewijd aan het bouwen van een gedistribueerd AI-gegevensannotatie- en verwerkingsplatform, wat sterke ondersteuning biedt voor daaropvolgende modeltraining. In dit opzicht hebben projecten zoals Public AI significante resultaten behaald.</p>
<p>Tenslotte maakt de middelste laag in de modelvalidatie- en inferentiefase volledig gebruik van de combinatie van Web3-technologie en cryptografietechnieken, zoals ZK en homomorfe encryptie, om te verifiëren of het inferentieproces van het model de juiste gegevens en parameters gebruikt. Dit zorgt niet alleen voor de nauwkeurigheid van het model, maar beschermt ook de privacy van invoergegevens. Typische toepassingsscenario’s zijn ZKML, zoals Bittensor, Privasea, Modulus en Privasea geïnvesteerd door Gate Labs.</p>
<h3 id="h3-AIintentgericht933869"><a name="AI+intent-gericht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+intent-gericht</h3><p>Intent centric, vertaald als ‘intentiegericht’, verwijst direct naar ‘wat je wilt doen’, met de nadruk op het resultaat in plaats van het proces. Intent centric heeft als doel protocollen en infrastructuur te optimaliseren om tijdrovende on-chain operaties in één stap uit te voeren. Meer precies, door de complexe operationele processen van het verleden te verbergen, kunnen gebruikers hun doelen bereiken zonder zich daarvan bewust te zijn of direct, wat de essentie van ketenabstractie weerspiegelt.</p>
<p>De gebruikelijke intentiescenario’s voor het gebruik van AI omvatten momenteel cross chain, airdrop, governance, transacties met hoge waarde en batchbewerkingen. De Telegram Bot die we eerder hebben besproken in ons artikel kan ook onder deze categorie worden ingedeeld.</p>
<p>Bijvoorbeeld, Delysium (AGI) is toegewijd aan het gebruik van AI om een AI Agent Network te creëren dat gericht is op gebruikersintentie voor Web3, wat veel aandacht heeft gekregen in markten zoals Zuid-Korea.</p>
<p>Zoals te zien is in de afbeelding, heeft de token van dit project de laatste tijd een verbazingwekkende stijging gezien als gevolg van marktspeculatie en waardeontdekking.<br><img src="https://gimg2.gateimg.com/image/article/17108379194.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Delysium heeft een AI-agent genaamd Lucy gelanceerd. Als een door AI aangedreven Web3-besturingssysteem is Lucy in staat om intelligent workflows te plannen en automatisch uit te voeren die gebruikersbehoeften kunnen oplossen op basis van het begrijpen van de intenties en doelen die vervat zijn in natuurlijke taal, waardoor de complexe operationele processen van huidige Web3-applicaties en protocollen worden vereenvoudigd.</p>
<h3 id="h3-AISpel493529"><a name="AI+Spel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+Spel</h3><p>AI+Games hebben ook een extreem hoge verbeeldingsruimte. AI-technologie versnelt niet alleen het productieproces van het spel, maar loopt ook door elk aspect van de productie van het spel, van het verkennen van gebruikersgewoonten tot het aanpassen van gepersonaliseerde interactiescènes, waarbij enorme potentie wordt gedemonstreerd. Tegenwoordig omarmen grote spelfabrikanten actief AI en herstructureren ze het ecosysteem van de spelindustrie.</p>
<p>Met betrekking tot gameproductie biedt AI sterke ondersteuning voor kunst, planning en operaties. Of het nu gaat om creatieve inspiratie, niveau generatie, copywriting en operationele analyse, AI versnelt de productie van gamecontent. Op het gebied van gamingervaring maken de natuurlijke taalgeneratie en beeldgeneratie mogelijkheden die door AI worden gebracht het gameplay meer innovatief en divers, en de interactie tussen NPC’s intelligenter en levendiger.</p>
<p>Bijvoorbeeld wordt de Jue Wu AI van ‘Honor of Kings’ veel toegepast bij het beoordelen en testen van niveaus; In ‘Mount &amp; Blade II: Bannerlord’ zorgt ChatGPT ervoor dat NPCs dynamisch reageren op spelers, waardoor de interactiviteit van het spel wordt verbeterd; In ‘Naraka: Bladepoint’ kunnen spelers zelfs AI-schilderijen gebruiken om modellen te genereren en te stemmen op de meest populaire werken, waarbij het enorme potentieel van AI in game-innovatie wordt getoond.<img src="https://gimg2.gateimg.com/image/article/17108379395.jpeg" alt=""><br>Bron: sleeplessAI</p>
<p>Naast traditionele Web2-games omarmt Web3-games AI net zo goed. Zo biedt Ultriverse gebruikers AI diepgaande functieanalyse en aangepaste sociale, gaming, metaverse en andere meerdere ervaringen via zijn krachtige AI-engine, evenals het virtuele metgezelschapsspel van sleepless AI dat zich richt op AI.</p>
<h3 id="h3-AIAnalyse819031"><a name="AI+Analyse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+Analyse</h3><p>Naast toepassingen op het niveau van de applicatielaag in gaming, sociale netwerken en handel kan AI ook worden gebruikt in gebieden zoals data-analyse, informatiebewaking en -tracking, en biedingen en weddenschappen. Representatieve projecten zoals Kaito en Dune zijn opgekomen en stellen een benchmark voor de industrie.</p>
<p>We citeren vaak de gegevensgrafieken van Dune in onze blogposts, dus er is geen noodzaak om ze hier verder toe te lichten.</p>
<h2 id="h2-Samenvattend333756"><a name="Samenvattend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvattend</h2><p>In het afgelopen jaar heeft de integratie van Web3 en AI niet alleen een nieuwe trend in technologie geleid, maar ook een nieuw consensus in de industrie voortgebracht: blockchain heeft productierelaties veranderd en AI heeft de productiviteit veranderd. Dit concept heeft zich nu diep geworteld in de harten van mensen en is een krachtige drijvende kracht geworden voor de ontwikkeling van de industrie.</p>
<p>Met spelontwikkelaars, DeFi-protocollen en andere Web3-infrastructuurprojecten die hun investeringen in AI verhogen, wordt de combinatie van AI en Web3 een belangrijke richting voor industrie-innovatie. Sterker nog, projecten die nauw verband houden met het concept van AI winnen vaak snel marktfavoriet, en we hebben deze verbazingwekkende groei al eerder opgemerkt.</p>
<p>Echter, onder de oppervlakkige welvaart en hype kunnen we de praktische obstakels in de AI+Web3-industrie niet negeren. Vooral voor beoefenaars is het noodzakelijk om diep in te gaan op hun praktische en haalbare toepassingsscenario’s, hun vermogen om waarde te creëren te ueren en sectorverhalen op te bouwen. Op de lange termijn, hoe zal het ecologische patroon van de AI+Web3-industrie worden gevormd, welke gebieden zullen enorme ontwikkelingspotentie hebben, en of het te maken zal krijgen met ethische en morele dilemma’s, moeten continu worden verkend en beantwoord in de praktijk.</p>
<p>Daarom zouden we in het licht van de AI+Web3-golf niet alleen de kansen moeten zien die het met zich meebrengt, maar ook een heldere geest moeten behouden en de uitdagingen en tekortkomingen ervan rationeel moeten bekijken. Alleen op deze manier kunnen we de ontwikkelingstraject van de AI+Web3-industrie beter begrijpen, de gezonde en duurzame ontwikkeling bevorderen en de winstkansen grijpen die door de trend worden geboden.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen, mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>