VHV0dG8gY2nDsiBjaGUgZGV2aSBzYXBlcmUgc3VsIHByb3NzaW1vIHByb2dldHRvIEFJK0RJRCBWYW5hIGluIHR1dHRhIGxhIHJldGU=

2024-12-16, 09:06

<p><img src="https://gimg2.gateimg.com/image/article/1734339712hotspot.png" alt=""></p>
<h2 id="h2-TLDR890784"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Il progetto Vana si impegna a consentire agli utenti di riottenere la proprietà e il controllo dei dati creando personaggi digitali e supportando i controlli sulla privacy, garantendo che solo gli utenti e i loro account autorizzati possano accedervi.</p>
<p>La rete Vana ha costruito due livelli principali: il livello di mobilità dei dati e il livello di portabilità dei dati, garantendo la proprietà, la sicurezza e la disponibilità dei dati.</p>
<p>L’offerta totale di VANA è di 120 milioni di token come token nativi, che hanno le funzioni di staking per mantenere la sicurezza della rete, partecipare alle decisioni di governance, pagare le commissioni di rete e accedere ai dati delle transazioni.</p>
<h2 id="h2-Introduzione485009"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Con l’aggiornamento rapido delle applicazioni AI+Crypto rappresentate dagli agenti AI di recente, il valore dei dati come risorsa importante nell’era digitale viene gradualmente riconosciuto. Tuttavia, nell’attuale Web2 e <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> negli ecosistemi, i dati degli utenti vengono raccolti gratuitamente dalle grandi piattaforme e utilizzati per fini commerciali, con conseguente incapacità di proteggere gli interessi dei creatori di dati.</p>
<p>In questo contesto è emerso il progetto Vana, impegnato a rompere il modello esistente dell’economia dei dati, consentendo agli utenti di riacquistare la proprietà e il controllo dei propri dati e di addestrare modelli di intelligenza artificiale attraverso i dati per ottenere benefici diretti, creando un nuovo punto di narrazione e uno spazio di innovazione per l’integrazione dell’intelligenza artificiale.</p>
<p>Abbiamo precedentemente scritto diversi articoli per esplorare i vari protocolli e tecnologie innovative nel campo dell’AI durante questo mercato toro. Il token Vana (VANA) sarà lanciato su <a href="http://Gate.io" rel="nofollow noopener noreferrer" target="_blank">grandi scambi, inclusi Gate.io</a> Oggi. Questo articolo mira a diffondere la situazione di base e le prospettive di sviluppo del protocollo AI+DD.</p>
<h2 id="h2-Panoramica20di20base20del20protocollo444542"><a name="Panoramica di base del protocollo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica di base del protocollo</h2><p>Vana ha avuto origine da un progetto di ricerca al MIT nel 2018 che aveva lo scopo di consentire agli utenti di avere i propri dati e utilizzare i modelli di intelligenza artificiale che avevano creato.</p>
<p>Secondo il sito ufficiale, Vana è un’applicazione di generazione di identità AI che consente agli utenti di creare un personaggio digitale e supporta il suo utilizzo in diverse applicazioni. Allo stesso tempo, il personaggio digitale ha privacy e può essere controllato solo dall’utente creato e dal loro account autorizzato. Gli sviluppatori possono utilizzare questi dati per addestrare modelli AI personalizzati e promuovere la democratizzazione dei dati nel <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> era.<br><img src="https://gimg2.gateimg.com/image/article/17343397811.jpeg" alt=""><br>Sorgente: vana.org</p>
<p>Vale la pena sottolineare che la rete Vana è completamente open source e opera in modo decentralizzato senza la necessità di licenze. La Open Data Foundation e altre organizzazioni contribuenti stanno lavorando insieme per promuovere l’adozione su larga scala del protocollo Vana.</p>
<h2 id="h2-Team20e20finanziamento82314"><a name="Team e finanziamento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Team e finanziamento</h2><p>Vana è stata co-fondata da due imprenditori filippini, Anna Kazlauskas e Art Abal. Anna ha una formazione in informatica ed economia, è stata coinvolta in <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> mining nei primi giorni e ha condotto ricerche di dati presso istituzioni finanziarie internazionali. Ha lavorato come consulente politico per il Primo Ministro di Timor Est e ha progettato un sistema legale che garantisce l’uguaglianza per tutti.</p>
<p>Art è un Master in Politiche Pubbliche presso l’Università di Harvard e ha guidato metodi innovativi di raccolta dati presso il fornitore di dati di addestramento AI Appen. I due hanno collaborato al progetto TOCA, offrendo alle persone a basso reddito nelle Filippine l’opportunità di guadagnare ricompense contribuendo dati, gettando le basi per lo sviluppo di Vana.</p>
<p>Secondo i dati di Rootdata, Vana ha raccolto 25 milioni di dollari in due round di finanziamento. Il round iniziale è stato guidato da Polychain con un investimento di 2 milioni di dollari, il round strategico è stato guidato da Coinbase Ventures con un investimento di 5 milioni di dollari e il round A è stato guidato da Paradigm con un investimento di 18 milioni di dollari. Il portafoglio di investimenti include Coinbase Ventures, Casey Caruso, Packy McCormick e ex partner di Paradigm che hanno partecipato anche all’investimento.<img src="https://gimg2.gateimg.com/image/article/17343398052.jpeg" alt=""><br>Origine: Rootdata</p>
<h2 id="h2-Architettura20tecnica20e20principi408605"><a name="Architettura tecnica e principi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Architettura tecnica e principi</h2><p>La rete Vana è composta da due livelli principali per garantire la proprietà, la sicurezza e la disponibilità dei dati: il livello di liquidità dei dati e il livello di portabilità dei dati.<br><img src="https://gimg2.gateimg.com/image/article/17343398223.jpeg" alt=""><br>Sorgente: docs.vana.org</p>
<p><strong>Livello di liquidità dei dati</strong><br>Il livello di liquidità dei dati è il livello fondamentale della rete Vana, che consente ai dati di essere considerati come un asset liquido. Questo livello permette ai dati di essere verificati, tokenizzati e scambiati in modo sicuro attraverso meccanismi decentralizzati.</p>
<p>Il livello di liquidità dei dati introduce organizzazioni autonome decentralizzate (DataDAO) che aggregano tipi di dati simili da vari contributori per creare un mercato dei dati decentralizzato e affidabile.</p>
<p><strong>Livello di portabilità dei dati</strong><br>Il livello di portabilità dei dati è il livello di applicazione di Vana, che consente l’accesso, la condivisione e l’uso di set di dati decentralizzati su vari piattaforme e applicazioni. Questo livello garantisce l’interoperabilità dei dati di proprietà dell’utente su diversi servizi e sistemi mantenendo la privacy e la sicurezza dei dati.</p>
<p>Attraverso questi due strati principali, la rete Vana ha costruito un ecosistema completo dalla validazione dei dati, alla tokenizzazione, al trading fino alle applicazioni cross-platform, al fine di garantire agli utenti il completo controllo dei loro dati e massimizzarne il valore.</p>
<h2 id="h2-Innovazioni20Salienti718593"><a name="Innovazioni Salienti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Innovazioni Salienti</h2><p>I punti salienti innovativi di Vana sono principalmente riflessi nei seguenti aspetti:</p>
<p><strong>Sovranità dei dati e dividendi dei dati personali</strong><br>Vana ha democratizzato i dati consentendo agli utenti di possedere e controllare i propri dati. Gli utenti non solo possono ottenere rendimenti economici contribuendo ai dati, ma possono anche partecipare al processo di addestramento dei modelli di intelligenza artificiale e godere dei benefici diretti dei dati.</p>
<p><strong>Protezione della privacy e diritti di accesso programmabili</strong><br>Vana ha risolto il problema della duplicazione dei dati combinando l’hosting dei dati privati con i registri di proprietà pubblica. I dati stessi vengono archiviati in server personali crittografati o in aree sicure affidabili, mentre la blockchain mantiene gli stati globali come i registri di proprietà dei dati, le autorizzazioni di accesso e le prove di verifica. Questo design non solo protegge la privacy dei dati dell’utente, ma consente anche l’accesso programmabile ai dati.</p>
<p><strong>Pool di liquidità dei dati DLP</strong><br>DLP è una delle principali innovazioni tecnologiche di Vana, che consente agli utenti di mettere in gioco i propri diritti di utilizzo dei dati per specifici pool di dati di dominio e ottenere token come certificati patrimoniali. Quando il lato della domanda di formazione AI applica il pool di dati, il costo sarà automaticamente allocato proporzionalmente ai titolari del voucher. Questo meccanismo non solo promuove la liquidità e il valore dei dati, ma fornisce anche agli utenti rendimenti economici sostenuti.</p>
<p><strong>Ambiente di esecuzione affidabile TEE</strong><br>La tecnologia TEE fornisce a Vana potenti capacità di protezione della privacy. Nell’ambiente TEE, i dati possono eseguire operazioni complesse senza essere esposti, garantendo la privacy dei dati e realizzando il diritto di utilizzare i dati. Questa caratteristica ‘utilizzabile ma invisibile’ risolve perfettamente il problema della protezione della privacy.</p>
<h2 id="h2-Dati20commerciali1970"><a name="Dati commerciali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dati commerciali</h2><p>Dal lancio della Rete di Test per Sviluppatori nel giugno 2023, la rete Vana ha attirato un gran numero di utenti e sviluppatori a partecipare. Attualmente, Vana ha oltre 1,3 milioni di utenti, più di 300 DAO di dati e un volume di transazioni giornaliere di 1,7 milioni.</p>
<p>Questi data DAO coprono molteplici settori, dai social media ai dati di previsione finanziaria, offrendo agli utenti diverse opportunità di contribuzione e guadagno di dati.</p>
<h2 id="h2-Economia20dei20token365324"><a name="Economia dei token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Economia dei token</h2><p>VANA è il token nativo della rete Vana, con un’offerta totale di 120 milioni di token e una circolazione iniziale del 28,5%. Ha le funzioni di staking per mantenere la sicurezza della rete, partecipare alle decisioni di governance, pagare le commissioni di rete e accedere ai dati delle transazioni.<br><img src="https://gimg2.gateimg.com/image/article/17343399334.jpeg" alt=""><br>Origine: docs.vana.org</p>
<p>Vale la pena menzionare che VANA funge da token fondamentale, mentre ogni DLP può emettere anche il proprio token per incentivare il contributo e la governance dei dati.</p>
<p>In sintesi, VANA e vari token DLP vengono utilizzati in molteplici scenari, come il trading di dati, il voto per la governance e la sicurezza della rete, per garantire la stabilità e liquidità del valore del token, incentivando contemporaneamente gli utenti a partecipare alle contribuzioni di dati e alla governance della rete.</p>
<h2 id="h2-Prospettive20future996187"><a name="Prospettive future" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future</h2><p>Con lo sviluppo continuo della tecnologia dell’IA, la domanda di dati di alta qualità diventerà sempre più urgente. Si può vedere che Vana fornirà fonti di dati ricche per l’addestramento dell’IA fornendo una rete dati di proprietà e controllata dagli utenti. La sua innovativa architettura tecnologica e modello di business offrono agli utenti opportunità di sovranità dei dati e protezione della privacy e forniscono agli sviluppatori fonti di dati ricche e piattaforme di addestramento.</p>
<p>Con il lancio della mainnet e l’introduzione dei token, Vana senza dubbio sperimenterà un po’ di hype. Infine, desidero ricordare ai lettori di monitorare attentamente i rischi di volatilità e di partecipare agli investimenti o al trading con cautela.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Charle 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. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni prudenti.<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 della violazione del copyright.<br></div><p></p><br></div></div></div></div>