R2F0ZSBMaXZlIEFNQSBSZWNhcC1BbGV0aGVhLmFp

2023-02-28, 07:25

<h2 id="h2-Il20settore20cripto20AI20ha20attirato20molta20attenzione20dietro20di20s20da20quando20chatGPT20ha20suscitato20linteresse20del20mondo20Quali20sono20le20caratteristiche20che20distinguono20Alethea20dagli20altri20progetti20di20intelligenza20artificiale193918"><a name="Il settore cripto AI ha attirato molta attenzione dietro di sé da quando chatGPT ha suscitato l’interesse del mondo. Quali sono le caratteristiche che distinguono Alethea dagli altri progetti di intelligenza artificiale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il settore cripto AI ha attirato molta attenzione dietro di sé da quando chatGPT ha suscitato l’interesse del mondo. Quali sono le caratteristiche che distinguono Alethea dagli altri progetti di intelligenza artificiale?</h2><p><strong>Arif Khan (CEO &amp; Fondatore):</strong><br>Il settore AI crypto ha attirato molta attenzione dietro di sé dal momento che chatGPT ha conquistato l’interesse del mondo. Quali sono le caratteristiche che distinguono Alethea dagli altri progetti AI?<br>Ospite: Oggi, l’AI generativa è suddivisa in due categorie: Web2 e Web3.</p>
<p>I modelli di intelligenza artificiale Web2 sono sempre esistiti e continueranno a esistere dove aiutano gli utenti a svolgere determinati compiti come aiutare a scrivere email, ecc. In tali modelli, l’utente è solo in grado di partecipare e difficilmente viene incentivato per farlo.</p>
<p>D’altra parte, il nostro lavoro negli ultimi 3 anni è stato quello di sviluppare tecnologie di intelligenza artificiale nel campo di Web3. A quel tempo, era difficile spiegare il nostro lavoro alla comunità o ai sostenitori precoci perché, sul fronte della blockchain, l’unico progetto NFT esistente era ‘CryptoKitties’ di Dapper Labs. Sul fronte dell’intelligenza artificiale, l’utilità e le applicazioni non erano state scalate per l’adozione di massa e la distribuzione attuale. Eravamo ancora nella fase di ricerca e sviluppo.</p>
<p>La nostra filosofia era quella di sviluppare l’IA e far decidere agli esseri umani il suo percorso di evoluzione e la sua influenza sulla società. Il modo migliore per mantenere gli esseri umani nel processo è tramite la proprietà. Pertanto, Alethea AI ha iniziato a costruire l’AI Protocol che fornisce uno strato di proprietà per l’industria dell’IA generativa. Ciò significa che gli utenti possono anche partecipare all’economia che viene creata dall’industria attraverso la proprietà degli asset dell’IA.</p>
<p>La nostra tesi è sempre stata quella di costruire l’IA da una prospettiva dei diritti di proprietà. Ciò significa che l’accumulo di valore deve avvenire per gli utenti di <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> anziché solo per attori ricchi provenienti da aziende Web2.</p>
<p>A parte da questa distinzione filosofica, fondamentalmente abbiamo iniziato a costruire il Protocollo AI utilizzando il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain come layer one dell’ecosistema. Questo ha permesso una natura aperta e senza permessi per il nostro ecosistema.</p>
<h2 id="h2-Recentemente20Alethea20AI20ha20lanciato20il20primo20motore20di20testoapersonaggio20al20mondo20che20competeva20con20Open20AI20Potresti20per20favore20fornire20una20spiegazione20pi20specifica20di20CharacterGPT300340"><a name="Recentemente Alethea AI ha lanciato il primo motore di testo-a-personaggio al mondo che competeva con Open AI. Potresti per favore fornire una spiegazione più specifica di CharacterGPT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recentemente Alethea AI ha lanciato il primo motore di testo-a-personaggio al mondo che competeva con Open AI. Potresti per favore fornire una spiegazione più specifica di CharacterGPT?</h2><p><strong>Arif Khan(CEO &amp; Founder):</strong><br>Certo, pensa a CharacterGPT come a ChatGPT con un volto e una voce.</p>
<p>CharacterGPT è il primo sistema AI generativo multimodale al mondo che può creare personaggi interattivi AI da una descrizione in linguaggio naturale. In breve, consente la generazione di testo-personaggio o TTC. CharacterGPT è il primo di una serie di sistemi AI all’avanguardia, ‘Text-to-X’, costruiti da Alethea AI.</p>
<p>Se visiti mycharacter.ai, un dApp costruito sul Protocollo IA e utilizza l’intelligenza di CharacterGPT, vedrai un’interfaccia che può prendere qualsiasi input per creare un personaggio IA realistico, interattivo e intelligente. Questi personaggi IA possono essere tokenizzati come NFT all’interno dell’dApp. Ciò significa che ora la proprietà dell’IA è accessibile a chiunque possieda un personaggio IA tokenizzato nel proprio portafoglio. Questa proprietà permette loro anche di scambiarla su mercati NFT, migliorarne l’intelligenza tramite l’addestramento o utilizzarla come preferiscono.</p>
<h2 id="h2-Qual2020leconomia20dei20token20del20token20ALI20di20AletheAI241203"><a name="Qual è l’economia dei token del token ALI di Alethe.AI?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è l’economia dei token del token ALI di Alethe.AI?</h2><p><strong>Arif Khan (CEO &amp; Fondatore):</strong><br>Il token di utilità ALI sta per Intelligenza Artificiale della Liquidità. Il termine ‘Liquid’ è essenziale per comprendere l’utilità dei token ALI nell’ecosistema in quanto consente di potenziare l’intelligenza dei iNFT e dei personaggi AI, rendendoli più intelligenti col passare del tempo.</p>
<p>Pensa ad ogni asset generato dall’IA come a un bambino, a cui devi fornire cibo, rifugio, cure, istruzione, ecc., e ALI Tokens serve a far crescere questo metaforico bambino dell’IA. Una volta che questo bambino dell’IA è cresciuto, cioè l’iNFT/Personaggio dell’IA raggiunge un certo livello di intelligenza, può anche svolgere vari servizi come interagire, dibattere, fare un video di saluto, ecc. Offrendo questi servizi o svolgendo questi lavori, l’iNFT può guadagnare ricompense o crediti che possono essere convertiti in ALI Utility Tokens.</p>
<p>Questo modello train-to-earn è un modo per l’ecosistema di ringraziare il proprietario dell’iNFT per permettergli di partecipare all’economia attraverso i suoi servizi e i lavori eseguiti, nonché per creare set di dati che rendono gli AI engine più intelligenti. Ogni volta che un utente interagisce con un personaggio AI, il motore AI sottostante utilizza i set di dati creati per diventare più intelligente.<br>Quindi i token di utilità ALI vengono utilizzati nell’ecosistema per creare utilità e consentire anche la governance del protocollo AI mentre decentralizziamo progressivamente.</p>
<p>Quando chiunque può creare qualsiasi personaggio, è indiscutibile che qualcuno finirà per creare anche personaggi dannosi e dannosi. Insieme al consiglio di moderazione dei contenuti, i membri della comunità possono decidere quali personaggi devono essere rimossi, disabilitati o rimossi attraverso la governance decentralizzata abilitata da ALI Utility Tokens.</p>
<p>L’economia del token di utilità ALI è articolata e comprende tutto, dagli aggiornamenti dell’intelligenza alla governance che fluisce come ‘Liquidità’ in tutto l’ecosistema. Ciò consente a tutti di utilizzare i propri personaggi AI in modo creativo come preferiscono.</p>
<h2 id="h2-Cosa20pensi20che20Alethea20AI20significhi20per20il20mercato20degli20NFT20Esploder20il20mercato406939"><a name="Cosa pensi che Alethea AI significhi per il mercato degli NFT? Esploderà il mercato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa pensi che Alethea AI significhi per il mercato degli NFT? Esploderà il mercato?</h2><p><strong>Arif Khan(CEO &amp; Founder):</strong><br>Siamo stati i primi a creare e a introdurre il concetto di NFT intelligenti o iNFT. Il primo iNFT al mondo, Alice, è stato messo all’asta da Sotheby’s da Alethea AI. Gli iNFT sono gli NFT incorporati e imbevuti di intelligenza artificiale.</p>
<p>Oggi molte aziende stanno facendo o cercando di fare ciò che abbiamo fatto, creando un impatto positivo sull’intera industria poiché questa nuova categoria sta emergendo e crescendo. Consente a chiunque di esplorare come creare NFT interattivi ed intelligenti che non siano solo JPEG statici.</p>
<p>La nostra tesi è che questa categoria continuerà a crescere e inizieremo a vedere sempre più sperimentazioni creative in una luce più ampia. Potrebbe essere qualsiasi cosa come arte, musica, voce, video, ecc. dove gli asset NFT saranno alimentati dall’intelligenza. Il futuro è eccitante!</p>
<p>Noi di Alethea AI ci vediamo come i facilitatori del Protocollo AI in cui chiunque può venire e tokenizzare i propri asset AI per dare vita alle proprie immaginazioni.</p>
<h2 id="h2-A20quale20stadio2020arrivata20Alethea20ora20Sono20tutti20gli20obiettivi20in20accordo20con20la20roadmap20attuale20E20quali20saranno20i20prossimi20passi20che20verranno20presi20in20futuro940509"><a name="A quale stadio è arrivata Alethea ora? Sono tutti gli obiettivi in accordo con la roadmap attuale? E quali saranno i prossimi passi che verranno presi in futuro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>A quale stadio è arrivata Alethea ora? Sono tutti gli obiettivi in accordo con la roadmap attuale? E quali saranno i prossimi passi che verranno presi in futuro?</h2><p><strong>Arif Khan (CEO &amp; Founder):</strong><br>Con il lancio di CharacterGPT, un sistema AI Generative multimodale molto potente che consente a chiunque di creare personaggi interattivi e intelligenti, apriremo l’accesso a un numero maggiore di sviluppatori e creatori per creare applicazioni ed esplorare la loro creatività. Quest’anno, passeremo dagli attuali due dApp sul Protocollo AI a un numero significativamente maggiore mentre continuiamo a scalare e crescere.</p>
<p>Abbiamo già la convergenza di CharacterGPT e del Protocollo AI, che si traduce come l’unione degli elementi di AI e Blockchain per fornire valore agli utenti. Siamo entusiasti di vedere gli utenti creare e portare in vita i loro asset di AI e caratteri. Ciò aiuterà l’ecosistema a evolversi e a colmare il divario tra Web2 e Web3.</p>
<p>Una delle sfide di Web3 è quella di far entrare le persone a bordo e aiutarle a capire la blockchain, il portafoglio, ecc., e diventa ancora più complicato quando si aggiunge l’AI. Quindi portare le persone in questo viaggio educativo aiuta a garantire che non siano intimiditi ma piuttosto curiosi. Queste sessioni AMA con comunità o ricompensare i nuovi utenti con alcuni token di utilità ALI quando creano un nuovo personaggio AI li aiutano a coltivare la loro curiosità e iniziare a fare domande.</p>
<p>Clicca qui per rivedere la LIve AMA&gt;&gt; <a href="https://www.gate.io/live/video/51b20625e9b206c8493fbadf6efdc7ee" target="_blank">AMA-Alethea.ai (AI, NFT)</a></p>
<div class="blog-details-info"><br><div>Autore:<strong> GateLive</strong>, Squadra 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, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>