V0xEIGNoZSBzYWxlIGRlbCAyODAlIGluIGR1ZSBzZXR0aW1hbmUsIGFuYWxpenphIGxlIG9wcG9ydHVuaXTDoCBkaSBpbnZlc3RpbWVudG8gbmVsIHNldHRvcmUgZGVsbCdJQQ==

2024-02-23, 10:00

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR985367"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>La traccia AI ha recentemente portato il mercato in alto a causa dell’ultimo testo di OpenAI per video Sora, che ha suscitato una serie di token concetto come Sora e Wld.</p>
<p>Sora ha rapidamente guadagnato popolarità grazie al suo simbolismo di creatività infinita rappresentato dalla parola giapponese “そら”, oltre che per i suoi eccellenti effetti e gli effetti testuali semplici al video.</p>
<p>La traccia AI è emersa già nel 2023 a causa del lancio di ChatGPT da OpenAI ed è nuovamente diventata popolare quest’anno grazie a Sora. Ciò indica che il settore dell’AI potrebbe diventare un componente importante di questo mercato toro, il che provocherà un cambiamento di paradigma.</p>
<h2 id="h2-Introduzione444280"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Dall’anno nuovo cinese, il mercato dell’AI nel mercato delle criptovalute ha mostrato una scena prospera, con una popolarità continua al primo posto. Con l’ultimo testo di OpenAI in video Sora come scintilla, una serie di token di concetto AI come Sora e Wld hanno guidato il mercato con forti guadagni. Pertanto, sarà analizzato uno per uno se questa nuova febbre dell’AI è sostenibile e come valutare le opportunità di investimento in questo settore nel testo seguente.</p>
<h2 id="h2-Sora20svelata20aprendo20una20nuova20era20dellintelligenza20artificiale863619"><a name="Sora svelata, aprendo una nuova era dell’intelligenza artificiale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sora svelata, aprendo una nuova era dell’intelligenza artificiale?</h2><p>Durante il Festival di primavera, OpenAI ha attivamente guidato la tendenza degli investimenti nei chip di intelligenza artificiale e ha lanciato un nuovo prodotto non open source, Sora, per video generati da testo, che ha suscitato una serie di token di intelligenza artificiale come Sora, una moneta meme con lo stesso nome, e il progetto Wld dell’OpenAI fondatore Ultraman.</p>
<p>Alcune persone hanno commentato che l’emergere di Sora è caratterizzato da una ‘lunghezza ultra lunga degli anni ‘60’, riprese video a multi angolo singolo’ e ‘modelli mondiali’, anticipando l’arrivo di una nuova era della narrazione visiva. Può trasformare l’immaginazione delle persone in immagini dinamiche vivide e trasformare la magia del testo in un banchetto visivo.<br><img src="https://gimg2.gateimg.com/image/article/1708682213img_v3_028b_3c970e8b-9797-4d3d-a9f9-9852846f71ix.jpg" alt=""><br>Fonte: @OpenAI</p>
<p>Sora è un modello avanzato di intelligenza artificiale sviluppato dall’istituto di ricerca sull’intelligenza artificiale americano OpenAI, che può generare video corrispondenti basati su descrizioni testuali fornite dagli utenti. La base tecnologica di Sora è costruita sul modello di generazione di testo a immagine DALL-E di OpenAI e, attraverso ulteriori ricerche e ottimizzazioni, ha raggiunto la capacità di convertire il testo in video.</p>
<p>Tuttavia, per quanto riguarda i dati di addestramento del modello, OpenAI non ha divulgato la quantità specifica e la fonte esatta, rivelando solo che questi dati includono video disponibili pubblicamente e video protetti da copyright autorizzati specificamente per fini di addestramento.</p>
<p>Anche se Sora utilizza ancora l’architettura del Transformer e il modello di diffusione, la sua più grande innovazione risiede nella sua capacità di presentare in modo accurato leggi naturali come la riflessione delle fiamme e l’inerzia del movimento degli oggetti nei video generati. Rispetto ad altri modelli di diffusione, l’output video di Sora mostra un’estrema stabilità e coerenza. Pertanto, i video AI che presenta offrono agli utenti un’esperienza coerente, logica e altamente piacevole. Vale la pena menzionare che Sora segue ancora la legge di scalabilità dell’AI. OpenAI sottolinea chiaramente nella documentazione tecnica che con l’aumento del calcolo di addestramento, la qualità del campione è significativamente migliorata, confermando ulteriormente l’arrivo dell’era multimodale.</p>
<p>Oltre a Sora, Nvidia ha anche rilasciato l’attesissimo strumento di distribuzione locale AI Chat with RTX come previsto. Nel frattempo, Google ha aggiornato Gemini e rilasciato la versione 1.5. Di conseguenza, i progressi positivi del settore globale dell’intelligenza artificiale hanno notevolmente stimolato la popolarità del settore dell’intelligenza artificiale del mercato delle criptovalute, in particolare Sora, che è diventato rapidamente popolare grazie alla sua infinita creatività rappresentata dalla parola giapponese “vuoto”, agli effetti eccellenti e alla semplice praticità, una volta lanciato, ha rapidamente guidato il successo complessivo del settore dell’intelligenza artificiale nel mercato delle criptovalute.</p>
<h2 id="h2-I20Token20del20settore20dellAI20hanno20guidato20la20crescita20con20la20massima20popolarit20al20mondo62581"><a name="I Token del settore dell’AI hanno guidato la crescita, con la massima popolarità al mondo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I Token del settore dell’AI hanno guidato la crescita, con la massima popolarità al mondo</h2><p>Alla data di scrittura, il settore dell’intelligenza artificiale ha raggiunto nuovi massimi con il rapporto finanziario NVIDIA di mercoledì che ha superato di gran lunga le aspettative, ma la sua popolarità è ancora in alto tra i vari settori. Secondo il mercato Gate.io, in termini di valore di mercato, i primi tre sono Bittensor (TAO), <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Renderizzare</a> (RNDR) e <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a>(FET), con valori di mercato di $3.9 miliardi, $2.8 miliardi e $1.1 miliardi, rispettivamente.<br><img src="https://gimg2.gateimg.com/image/article/1708682263img_v3_028b_285c3da9-da1d-4e90-9aa9-453c01cc7aix.jpg" alt=""><br>Origine: Gate.io</p>
<p>Quando si tratta della criptovaluta più popolare Worldcoin (WLD), è necessario spiegare il contesto di base. Il progetto è stato avviato dal fondatore di OpenAI, Ultraman, e il team del progetto ha creato un dispositivo chiamato Orb, che può catturare un’immagine dell’occhio di una persona e convertirla in un breve codice numerico. Recentemente ha attirato l’attenzione di Vitalik.</p>
<p>Non è difficile vedere dal grafico dei prezzi che da quando è stato rilasciato Sora, WLD è schizzato dal suo punto più basso di $2,1 al suo punto più alto di $8,4, con un valore di mercato paragonabile a <a href="/price/fetch-ai-fet" target="_blank" class="blog_inner_link">Fetch.ai</a> (FET).<br><img src="https://gimg2.gateimg.com/image/article/1708682295img_v3_028b_f432fd28-48ec-440b-a8e9-63c6a33aecix.jpg" alt=""><br>Sorgente: Gate.io</p>
<p>In realtà, WLD stesso non è il token del settore dell’IA ma il principale beneficiario, e l’aumento significativo dei prezzi delle monete è in gran parte dovuto all’eccitazione causata dalla sua associazione con il fondatore di OpenAI.</p>
<p>Il token AI più ortodosso è <a href="/price/livepeer-lpt" rel="nofollow noopener noreferrer" target="_blank">Livepeer</a>(LPT), e dopo il rilascio di Sora, il prezzo della moneta è rapidamente schizzato in alto, aumentando di oltre il 60%.</p>
<p>Livepeer è una rete decentralizzata di streaming video basata sulla <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain. A causa dell’ampia quantità di potenza di calcolo GPU (unità di elaborazione grafica) necessaria per generare contenuti video di alta qualità e dei costi elevati, l’aumento dei prezzi dei token LPT riflette la crescente domanda di generazione di video di alta qualità sul mercato. Nel frattempo, la comunità <a href="/price/livepeer-lpt" target="_blank" class="blog_inner_link">Livepeer</a> sta pianificando di integrare la propria rete con la tecnologia video generata da testo nei prossimi mesi. Sebbene la data e i dettagli specifici non siano ancora stati annunciati, si prevede che questo piano aumenterà ulteriormente il valore dei token LPT.</p>
<p>Inoltre, SingularityNET (AGIX), come piattaforma che consente la creazione, la condivisione e la monetizzazione su larga scala dei servizi di intelligenza artificiale, ha registrato una crescita significativa nel suo token nativo AGIX, con un aumento superiore al 30%.</p>
<p>Secondo le ultime statistiche di CoinMarketCap, il valore di mercato totale del segmento AI&amp;Big Data ha raggiunto $23 miliardi, con un totale di 237 token, di cui 197 sono stati quotati e scambiati online, rappresentando l’1,19% del valore di mercato criptato totale.</p>
<h2 id="h2-Pu20continuare20la20popolarit20del20settore20dellAI20e20qual2020il20suo20valore20di20investimento308952"><a name="Può continuare la popolarità del settore dell’AI e qual è il suo valore di investimento?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Può continuare la popolarità del settore dell’AI e qual è il suo valore di investimento?</h2><p>Naturalmente, basandosi sull’esperienza passata, la popolarità di nessun settore nel mercato delle criptovalute può rimanere invariata. Con la diminuzione dell’effetto di prelievo di profitto e l’aumento dei rischi nell’intelligenza artificiale, la popolarità del settore dell’IA potrebbe regolarsi.</p>
<p>L’innovazione della tecnologia AI ha portato sia enormi opportunità che potenziali rischi. Per garantirne la sicurezza prima dell’utilizzo della tecnologia Sora, OpenAI ha adottato una serie di misure di sicurezza. Stanno collaborando con membri del team rosso per valutare i rischi nelle aree chiave utilizzando Sora e invitando artisti visivi, designer e registi a fornire feedback per ottimizzare la praticità del modello per i professionisti creativi.</p>
<p>Tuttavia, OpenAI avverte anche che nonostante ricerche e test approfonditi, è ancora difficile prevedere come gli utenti trarranno beneficio o abuseranno della tecnologia. In effetti, alcuni sostengono che questa tecnologia potrebbe essere sfruttata da criptofraudsters. Gli imbroglioni potrebbero utilizzare Sora per creare video di falsi endorsement di celebrità, video con informazioni di parte o errate e diffonderli ampiamente attraverso piattaforme di social media.<img src="https://gimg2.gateimg.com/image/article/1708682354img_v3_028b_2234f8cd-3965-4705-9c82-5830ece93dix.jpg" alt=""><br>Sorgente: @OpenAI</p>
<p>Inoltre, ci sono anche alcuni progetti che impersonano nomi di AI che possono sfruttare i vantaggi del traffico per lanciarsi, e i rischi e i pericoli nascosti in questi aspetti sono degni di attenzione da parte degli investitori.</p>
<p>Quando esaminiamo la popolarità dell’intero percorso dell’IA, non è difficile trovare che lo sfondo macro più ampio è che, man mano che il mercato delle criptovalute diventa sempre più maturo, le aspettative delle persone continuano a crescere. Specialmente con l’imminente dimezzamento di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ad aprile e il lancio di Sora, l’attenzione del mercato ha raggiunto un nuovo apice.</p>
<p>L’ascesa dell’intelligenza artificiale nel campo delle criptovalute non è casuale. Già nel primo trimestre del 2023, la diffusione di nuove tecnologie come ChatGPT e MidJourney ha portato il primo decollo per le criptovalute basate sull’intelligenza artificiale. Queste tecnologie non solo guidano una nuova ondata tecnologica, ma spingono anche tecnologie come Fetch verso un’impennata nei token legati all’IA come AI (FET), SingularityNet (AGIX) e persino settori come DePIN come Akash (AKT).</p>
<p>Nel complesso, l’emergere di Sora, una tecnologia innovativa iniziata nel 2024, ha riacceso l’entusiasmo del mercato per la tecnologia AI, attirando l’attenzione di investitori e appassionati di tecnologia, insieme all’attenzione di numerose Altcoin e Meme coin strettamente legate alla tecnologia AI. Gli investitori dovrebbero anche prestare attenzione alle fluttuazioni a breve termine per ridurre i rischi speculativi, seguendo da vicino questa opportunità di investimento “pendio spesso e neve lunga”.</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à consentita la ripubblicazione dell'articolo a condizione che sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>