UHXDsiBsJ0FJIGNoZSBmYSBsJ2F1dG9zdG9wIHBvcnRhcmUgdW5hIG51b3ZhIHRlbmRlbnphIG5lbGxlIG5hcnJhemlvbmkgZGkgbWVyY2F0byBhbCByaWFsem8/

2024-03-19, 08:46

<p><img src="https://gimg2.gateimg.com/image/article/1710838001sdfx.jpeg" alt=""></p>
<h2 id="h2-TLDR763493"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>La traccia AI+Web3 può essere grossolanamente divisa in tre livelli: livello di infrastruttura, livello intermedio e livello di applicazione. Il livello di infrastruttura si concentra sulla fornitura di potenza di calcolo e archiviazione, che attualmente è il campo più popolare e richiesto.</p>
<p>Oltre ai casi di utilizzo del livello dell’applicazione nel gaming, nei social network e nel trading, l’IA può essere utilizzata anche in campi come l’analisi dei dati, il monitoraggio e il tracciamento delle informazioni e le scommesse d’asta.</p>
<p>I progetti strettamente legati al concetto di intelligenza artificiale spesso guadagnano rapidamente il favore del mercato, ma è necessario prestare attenzione a filtrare i progetti che non sono all’altezza del loro nome e sono puramente concentrati sui temi caldi.</p>
<h2 id="h2-Introduzione538036"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Di recente, una serie di progetti AI+Web3 hanno suscitato entusiasmo nel mercato. Al fine di esplorare questa potenziale opportunità di mercato in modo approfondito, Gate.io Research combinerà vari progetti interessanti per condurre analisi approfondite dei vari collegamenti nella catena industriale AI+Web3, al fine di fornire ai lettori una comprensione completa e approfondita.</p>
<h2 id="h2-AIWeb320Nuova20tecnologia20nuova20direzione20nuova20speculazione764885"><a name="AI+Web3: Nuova tecnologia, nuova direzione, nuova speculazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+Web3: Nuova tecnologia, nuova direzione, nuova speculazione</h2><p>L’anno scorso, con l’emergere di modelli AI generativi su larga scala come ChatGPT, l’AI è diventata un argomento di investimento caldo ricercato dal mercato capitalistico mondiale. Allo stesso tempo, il mercato <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> ha anche inaugurato un nuovo round di prosperità.</p>
<p>La combinazione organica di intelligenza artificiale e Web3 diventa indubbiamente l’intersezione dei due argomenti caldi nel campo della tecnologia attuale. Di recente, abbiamo osservato un gran numero di progetti nuovi e vecchi su questo tema che stanno ricevendo attenzione dal mercato, mettendo in evidenza l’interesse forte e le alte aspettative degli investitori per questa combinazione.</p>
<p>Secondo la definizione della blockchain Wanxiang, la combinazione di intelligenza artificiale e Web3 è principalmente riflessa in due aspetti: come Web3 promuove lo sviluppo dell’IA e come le applicazioni Web3 combinano la tecnologia dell’IA. Attualmente, la maggior parte dei progetti tende a utilizzare la tecnologia e i concetti Web3 per guidare l’avanzamento dell’IA. Per analizzare questa combinazione, possiamo iniziare con l’intero processo di IA, dall’addestramento del modello all’applicazione.</p>
<p>Il processo di produzione dell’AI include approssimativamente: l’acquisizione dei dati, che fornisce una base per l’addestramento del modello; Preelaborazione dei dati e ingegneria delle caratteristiche/suggerimenti, che coinvolge la pulizia dei dati, l’annotazione e le interrogazioni strutturate; Addestramento e ottimizzazione del modello, migliorando le prestazioni del modello attraverso l’iterazione; Revisione e governance del modello per garantire la qualità e la trasparenza del modello; Inferenza del modello, predizione di nuovi dati; Distribuzione e monitoraggio del modello per garantire prestazioni ottimali del modello nelle applicazioni pratiche.</p>
<p>In questo processo, Web3 ha molti punti di integrazione. Ad esempio, la rete distribuita e il meccanismo di incentivi di Web3 possono costruire reti e comunità AI più aperte e open-source, soddisfacendo le esigenze delle applicazioni AI per infrastrutture e reti dati a basso costo e aperte. Nel frattempo, combinare Web3 con tecnologie crittografiche come ZK può migliorare le problematiche di fiducia dell’AI, affrontare sfide come la trasparenza del modello, il bias e le applicazioni etiche.<br><img src="https://gimg2.gateimg.com/image/article/17108378111.jpeg" alt=""><br>Origine: blockchain Wanxiang</p>
<p>Come mostrato nella figura sopra, il percorso AI+Web3 può essere approssimativamente diviso in tre livelli: livello di infrastruttura, livello intermedio e livello di applicazione.</p>
<p>Il livello infrastrutturale si concentra sulla fornitura di potenza di calcolo e archiviazione, e l’aggiunta di Web3 può ridurre i suoi costi e servire più applicazioni di intelligenza artificiale.</p>
<p>Il livello intermedio utilizza la tecnologia Web3 per ottimizzare i processi di produzione dell’AI, come l’acquisizione dei dati, la pre-elaborazione e la convalida del modello, dando luogo a numerosi progetti innovativi.</p>
<p>Il livello dell’applicazione dimostra l’ampia applicazione dell’AI in Web3, come la generazione di contenuti, l’analisi e la previsione. Sulla base dell’osservazione dell’autore, la descrizione del livello dell’applicazione nella figura sopra è ancora piuttosto conservativa. Lo discuteremo in dettaglio nel pomeriggio. Anche se non ci sono ancora progetti leader, il potenziale è enorme e la futura competizione si concentrerà sulle capacità produttive e tecnologiche.</p>
<p>Forniremo studi di caso specifici per questi tre progetti di livello nelle sezioni seguenti.</p>
<h2 id="h2-Emergono20uno20dopo20laltro20i20progetti20di20tendenza20AIWeb3427215"><a name="Emergono uno dopo l’altro i progetti di tendenza AI+Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Emergono uno dopo l’altro i progetti di tendenza AI+Web3</h2><h3 id="h3-AIDePIN799199"><a name="AI+DePIN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+DePIN</h3><p>L’intero flusso di lavoro dell’IA si basa sul supporto dell’infrastruttura di calcolo e archiviazione. Queste strutture sono responsabili non solo di fornire potenza di calcolo potente per l’addestramento e la previsione del modello, ma anche per memorizzare, gestire e analizzare i dati durante l’intero modello e ciclo di vita dei dati.</p>
<p>Attualmente, la rapida crescita delle applicazioni di intelligenza artificiale ha portato a una enorme domanda di infrastrutture, in particolare di potenza di calcolo ad alte prestazioni. Pertanto, lo sviluppo di infrastrutture informatiche e di archiviazione più efficienti, economiche e ricche di risorse è diventato un trend chiave nelle prime fasi dello sviluppo dell’IA, attualmente il campo più popolare.<img src="https://gimg2.gateimg.com/image/article/17108378632.jpeg" alt=""><br>Source: <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Render</a> Rete</p>
<p>In questo settore sono emersi diversi progetti rappresentativi, come la rete di rendering nata nel precedente mercato rialzista e che fornisce principalmente servizi di rendering, Akash che si concentra sul cloud computing, <a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a> e <a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">Arweave</a> che si concentrano sullo storage cloud, IO.NET e Aethir che sono stati appena lanciati in questo mercato rialzista e forniscono principalmente supporto di potenza di calcolo per l’AI. Nel nostro recente articolo “ <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 crea un record per i prezzi alle stelle, analizza i progetti in tendenza nell’ecosistema SOL</a>“ha introdotto progetti all’avanguardia come IO.NET, che qui non verranno ulteriormente elaborati.”</p>
<h3 id="h3-AIData240336"><a name="AI+Data" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+Data</h3><p>Il livello intermedio è fondamentale <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> nel processo di produzione di intelligenza artificiale, che utilizza la tecnologia Web3 per ottimizzare e migliorare flussi di lavoro specifici.</p>
<p>In primo luogo, nella fase di acquisizione dei dati, il livello intermedio introduce la gestione decentralizzata dell’identità dei dati, che non solo protegge la sicurezza dei dati degli utenti, ma garantisce anche la chiara proprietà dei dati. Allo stesso tempo, attraverso meccanismi di incentivazione, gli utenti possono essere incoraggiati a condividere dati di alta qualità per ottenere monetizzazione, espandendo così le fonti di dati.</p>
<p>A causa delle limitazioni della fase di sviluppo del settore, non c’erano quasi progetti relativamente noti in questo campo nella precedente fase di mercato rialzista e ribassista. In questo mercato rialzista, ci sono stati progetti di identità AI come Worldcoin (di cui abbiamo scritto più volte), Aspecta investito da Gate.io, Ocean Protocol, una piattaforma di scambio di dati, e Grass, una rete dati per il mining a banda larga.<img src="https://gimg2.gateimg.com/image/article/17108378893.jpeg" alt=""><br>Origine: Aspecta</p>
<p>In secondo luogo, nella fase di pre-elaborazione dei dati, il livello intermedio si impegna a costruire una piattaforma di annotazione e di elaborazione dati AI distribuita, fornendo un forte supporto per la successiva formazione del modello. A tal proposito, progetti come Public AI hanno ottenuto risultati significativi.</p>
<p>Infine, nella fase di convalida del modello e di inferenza, lo strato intermedio utilizza appieno la combinazione della tecnologia Web3 e delle tecniche crittografiche, come ZK e crittografia omomorfica, per verificare se il processo di inferenza del modello utilizza i dati e i parametri corretti. Ciò non solo garantisce l’accuratezza del modello ma protegge anche la privacy dei dati di input. Gli scenari di applicazione tipici sono ZKML, come Bittensor, Privasea, Modulus e Privasea investiti da Gate Labs.</p>
<h3 id="h3-AIcentrico20sullintenzione248724"><a name="AI+centrico sull’intenzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+centrico sull’intenzione</h3><p>Intent centrico, tradotto come “centrato sull’intenzione,” si riferisce direttamente a “cosa si vuole fare,” concentrandosi sull’obiettivo piuttosto che sul processo. Intent centrico mira a ottimizzare protocolli e infrastrutture per consentire che le noiose operazioni on-chain vengano eseguite in un’unica fase. Più precisamente, nascondendo i complessi processi operativi del passato, gli utenti possono raggiungere i loro obiettivi senza sentirsi o riflettere direttamente, riflettendo l’essenza dell’astrazione della catena.</p>
<p>Gli scenari di intenzione comune per l’uso dell’IA includono attualmente cross chain, airdrop, governance, transazioni ad alto valore e operazioni batch. Il Bot Telegram di cui abbiamo discusso in precedenza nel nostro articolo può anche essere classificato in questa categoria.</p>
<p>Ad esempio, Delysium (AGI) si impegna a utilizzare l’IA per creare una rete di agenti AI incentrata sull’intento dell’utente per Web3, che ha ottenuto un’alta attenzione in mercati come la Corea del Sud.</p>
<p>Come mostrato nella figura, a causa della speculazione di mercato e della scoperta del valore, il token di questo progetto ha registrato un aumento sorprendente di recente.<img src="https://gimg2.gateimg.com/image/article/17108379194.jpeg" alt=""><br>Sorgente: Gate.io</p>
<p>Delysium ha lanciato un Agente IA chiamato Lucy. Come sistema operativo Web3 basato su intelligenza artificiale, Lucy è in grado di pianificare intelligentemente ed eseguire automaticamente flussi di lavoro che possono risolvere le esigenze degli utenti basandosi sulla comprensione delle intenzioni e degli obiettivi contenuti nel linguaggio naturale, semplificando i complessi processi operativi delle attuali applicazioni e protocolli Web3.</p>
<h3 id="h3-AIGioco39062"><a name="AI+Gioco" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+Gioco</h3><p>AI+Games hanno anche uno spazio di immaginazione estremamente elevato. La tecnologia dell’IA non solo accelera il processo di produzione del gioco, ma si estende anche in ogni aspetto della produzione del gioco, dall’esplorazione delle abitudini degli utenti alla personalizzazione delle scene di interazione personalizzate, dimostrando un enorme potenziale. Oggi, i principali produttori di giochi stanno abbracciando attivamente l’IA e ristrutturando l’ecosistema della catena dell’industria del gioco.</p>
<p>Per quanto riguarda la produzione di giochi, l’IA fornisce un forte supporto per l’arte, la pianificazione e le operazioni. Che si tratti di ispirazione creativa, generazione di livelli, copywriting e analisi operativa, l’IA sta fornendo un’accelerazione per la produzione di contenuti di gioco. In termini di esperienza di gioco, le capacità di generazione di linguaggio naturale e di generazione di immagini portate dall’IA rendono il gameplay più innovativo e vario e l’interazione tra NPC più intelligente e vivida.</p>
<p>Ad esempio, Jue Wu AI di “Honor of Kings” è stata ampiamente applicata nella valutazione e nei test di livello; In “Mount &amp; Blade II: Bannerlord” ChatGPT consente agli NPC di rispondere dinamicamente ai giocatori, migliorando l’interattività del gioco; In “Naraka: Bladepoint” i giocatori possono persino utilizzare l’intelligenza artificiale per generare modelli di moda e votare per i lavori più popolari, mostrando l’enorme potenziale dell’IA nell’innovazione dei giochi.<img src="https://gimg2.gateimg.com/image/article/17108379395.jpeg" alt=""><br>Sorgente: sleeplessAI</p>
<p>Oltre ai tradizionali giochi Web2 che abbracciano l’IA, i giochi Web3 non fanno eccezione. Ad esempio, Ultriverse offre agli utenti un’analisi approfondita delle caratteristiche dell’IA e un’esperienza personalizzata su social, giochi, metaverso e altre esperienze multiple attraverso il suo potente motore di intelligenza artificiale, nonché il gioco di compagni virtuali senza sonno di AI che si concentra sull’IA.</p>
<h3 id="h3-AIAnalisi178158"><a name="AI+Analisi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI+Analisi</h3><p>Oltre ai casi di livello applicativo nel gaming, social networking e trading, l’IA può essere utilizzata anche in campi come l’analisi dei dati, il monitoraggio e il tracciamento delle informazioni e le scommesse d’asta. Sono emersi progetti rappresentativi come Kaito e Dune, che stabiliscono un punto di riferimento per l’industria.</p>
<p>Spesso citiamo i grafici dei dati di Dune nei nostri post del blog, quindi non è necessario dilungarsi su di essi qui.</p>
<h2 id="h2-Per20concludere114425"><a name="Per concludere" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Per concludere</h2><p>Nell’ultimo anno, l’integrazione di Web3 e AI non solo ha portato una nuova tendenza nella tecnologia, ma ha anche generato un nuovo consenso nell’industria: la blockchain ha cambiato le relazioni di produzione e l’AI ha cambiato la produttività. Questo concetto ora è profondamente radicato nei cuori delle persone ed è diventato una potente forza trainante per lo sviluppo dell’industria.</p>
<p>Con gli sviluppatori di giochi, i protocolli DeFi e altri progetti di infrastrutture Web3 che aumentano i loro investimenti in AI, la combinazione di AI e Web3 sta diventando una direzione importante per l’innovazione industriale. Infatti, i progetti strettamente correlati al concetto di AI spesso guadagnano rapidamente il favore del mercato, e abbiamo già notato questa incredibile crescita in precedenza.</p>
<p>Tuttavia, al di sotto della prosperità e dell’entusiasmo apparenti, non possiamo ignorare gli ostacoli pratici nell’industria AI+Web3. Soprattutto per i professionisti, è necessario esplorare a fondo i loro scenari di applicazione pratici e fattibili, valutare la loro capacità di creare valore e costruire narrazioni settoriali. A lungo termine, come si formerà il modello ecologico dell’industria AI+Web3, quali settori mostreranno un enorme potenziale di sviluppo e se dovranno affrontare dilemmi etici e morali, è necessario esplorare e rispondere continuamente nella pratica.</p>
<p>Pertanto, di fronte all’onda di AI+Web3, non dovremmo solo vedere le opportunità che porta, ma anche mantenere una mente lucida e guardare razionalmente le sfide e i difetti. Solo in questo modo possiamo meglio comprendere la traiettoria di sviluppo dell’industria AI+Web3, promuovere il suo sviluppo sano e sostenibile e cogliere le opportunità di profitto portate dalla tendenza.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<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 per violazione del copyright.<br></div><p></p><br></div></div></div></div>