U2V0dG9yZSBBSSBjb2xsYXNzYXRvIGRhIE52aWRpYSwgYyfDqCBhbmNvcmEgdW5hIHBvc3NpYmlsaXTDoCBkaSByaXByZXNhIHF1ZXN0J2Fubm8/

2024-09-03, 16:42

<p><img src="https://gimg2.gateimg.com/image/article/17253813611690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR131032"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Il fatturato e il profitto del secondo trimestre di Nvidia hanno entrambi superato le aspettative di mercato, mentre il fatturato del terzo trimestre è stato leggermente inferiore rispetto alle aspettative più ottimistiche, causando un aumento e successivamente una diminuzione del prezzo delle sue azioni. Tutti e tre gli indici azionari principali degli Stati Uniti hanno chiuso al ribasso e il settore dell’IA nella <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> è salito prima e poi è caduto.</p>
<p>Quando il mercato nutre aspettative ottimistiche sulla redditività di Nvidia, i prezzi dei token di intelligenza artificiale correlati spesso aumentano, formando una relazione sincrona.</p>
<p>La scoperta del valore dei token AI dipende dalla pratica efficace delle loro prospettive di applicazione, nonché dall’influenza delle azioni tecnologiche AI, come NVIDIA e TSMC.</p>
<h2 id="h2-Introduzione948799"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Recentemente, i token del settore dell’IA sono aumentati a causa delle speculazioni che circondano il rapporto finanziario di Nvidia (NVDA. US), ma si sono fermati e sono diminuiti dopo la pubblicazione del rapporto.</p>
<p>Nel contesto di una debolezza generale del mercato delle criptovalute, il settore dell’IA sembra non essere più così fiorente come l’anno scorso. Questo articolo esplorerà in dettaglio se ci sarà una nuova logica narrativa in questo settore in futuro e se potrà vivere una forte ripresa.</p>
<h2 id="h2-Il20rapporto20finanziario20supera20le20aspettative20ma20Nvidia20continua20a20minare20la20fiducia20nellIA944954"><a name="Il rapporto finanziario supera le aspettative, ma Nvidia continua a minare la fiducia nell’IA?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il rapporto finanziario supera le aspettative, ma Nvidia continua a minare la fiducia nell’IA?</h2><p>Come un’azienda leader nel campo della potenza di calcolo AI, Nvidia (NVDA. US) influenza la volatilità del mercato azionario statunitense e ha un impatto diretto sul settore criptato AI. Attualmente, il mercato è concentrato sulla sua relazione finanziaria rilasciata alla fine di agosto.</p>
<p>Secondo il suo rapporto finanziario del secondo trimestre pubblicato, Nvidia ha registrato una significativa crescita delle prestazioni, con un fatturato del secondo trimestre che ha raggiunto i 30 miliardi di dollari, un aumento del 122% rispetto allo stesso periodo dell’anno scorso, superando di gran lunga la previsione originale degli analisti di mercato di 28,86 miliardi di dollari. Nel settore chiave del data center, il fatturato ha raggiunto i 26,3 miliardi di dollari, un aumento anno su anno del 154%, superando anche le aspettative degli analisti (25,08 miliardi di dollari). Le prospettive dell’azienda per il prossimo trimestre fiscale sono ottimistiche, con un fatturato previsto del terzo trimestre di circa 32,5 miliardi di dollari, oscillante tra più e meno il 2%. Questa previsione è anche superiore alle aspettative generali degli analisti (31,9 miliardi di dollari) e inferiore alla più ottimistica previsione di mercato di 37,9 miliardi di dollari.<br><img src="https://gimg2.gateimg.com/image/article/17253815421.jpg" alt=""><br>Origine: nvidia.com</p>
<p>In particolare, per quanto riguarda il fatturato dei giochi, le prestazioni di Nvidia nel secondo trimestre sono state altrettanto impressionanti, raggiungendo 2,9 miliardi di dollari di fatturato, un aumento anno su anno del 16%, superando le aspettative degli analisti (2,79 miliardi di dollari). Per quanto riguarda il margine lordo e l’utile per azione, Nvidia ha dimostrato anche una forte solidità finanziaria, con un margine lordo regolato che è aumentato al 75,7%, un aumento significativo rispetto allo stesso periodo dell’anno scorso (71,2%) e leggermente superiore alle aspettative degli analisti (75,5%). L’utile per azione regolato è stato di 0,68 dollari, un significativo aumento anno su anno, superiore di gran lunga ai 0,27 dollari dell’anno precedente e migliore delle previsioni degli analisti di 0,64 dollari. Il profitto netto ha raggiunto un incredibile 16,599 miliardi di dollari, un aumento anno su anno del 168%, superiore di gran lunga alle previsioni degli analisti di 14,64 miliardi di dollari.</p>
<p>Per proteggersi dalla delusione del mercato per quanto riguarda le previsioni di performance, Nvidia ha annunciato un piano di riacquisto di azioni da 50 miliardi di dollari e ha mantenuto invariato il dividendo trimestrale per azione.</p>
<p>Ma questo non ha alleviato le preoccupazioni del mercato riguardo alla sua crescita indebolita, poiché il prezzo delle azioni di Nvidia è prima salito e poi sceso. Dopo la pubblicazione del rapporto finanziario, il prezzo delle azioni di Nvidia è sceso di oltre l’8% nel trading dopo l’orario di chiusura.<img src="https://gimg2.gateimg.com/image/article/17253815722.jpg" alt=""><br>Fonte: Investing.com</p>
<p>Il fatturato e il profitto di Nvidia nel secondo trimestre hanno superato le aspettative di mercato, mentre il fatturato del terzo trimestre è stato leggermente inferiore alle aspettative più ottimistiche. A causa di fattori come le alte aspettative di mercato e le sfide dei costi di produzione, il prezzo delle sue azioni è prima salito e poi è sceso, addirittura scendendo bruscamente dell’8% dopo la chiusura del mercato. Tutti e tre gli indici azionari principali degli Stati Uniti sono stati chiusi in ribasso, e tali fluttuazioni violente hanno naturalmente innescato prima un aumento e poi una caduta del settore dell’IA nel mercato delle criptovalute.</p>
<h2 id="h2-La20narrazione20del20settore20AI2020debole20basandosi20esclusivamente20su20Nvidia483664"><a name="La narrazione del settore AI è debole, basandosi esclusivamente su Nvidia?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La narrazione del settore AI è debole, basandosi esclusivamente su Nvidia?</h2><p>Prima della pubblicazione del rapporto finanziario di Nvidia, <a href="/price/near-protocol-near" rel="nofollow noopener noreferrer" target="_blank">Near Protocol</a> (NEAR), Artificial Super Alliance (FET), Bittensor (TAO), e <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Rendere</a> (RENDER) ha mostrato una notevole performance di prezzo. Questi token si sono ripresi rapidamente dai minimi di mercato registrati all’inizio di agosto e il settore dell’IA, che è salito fino al 70%, è diventato l’unico settore forte in un mercato debole.</p>
<p>Di particolare rilievo sono FET e TAO, che hanno le performance di prezzo più impressionanti. Artificial Super Alliance (FET), come token dell’Artificial Super Intelligence Alliance, integra progetti crittografici di intelligenza artificiale come OCEAN e AGIX, con l’obiettivo di diventare l’organizzazione indipendente open-source di ricerca e sviluppo sull’IA più potente; Bittensor (TAO) è un protocollo blockchain open-source dedicato alla costruzione di reti efficienti di apprendimento automatico AI decentralizzate, promuovendo ulteriormente lo sviluppo e la distribuzione della potenza di calcolo AI.</p>
<p>Anche se questi due progetti non sono stati selezionati per il programma Nvidia Inception come Aethir (ATH), ChainGPT (CGPT), e <a href="/price/flux-flux" rel="nofollow noopener noreferrer" target="_blank">Flusso</a>(FLUX), sono i leader segmentati nel campo dell’AI e sono sempre stati importanti bersagli dell’hype.</p>
<p>Indubbiamente, dopo la pubblicazione del rapporto finanziario di Nvidia, il settore dell’IA è crollato in generale, dimostrando il modello speculativo di ‘comprare aspettative, vendere fatti’.<img src="https://gimg2.gateimg.com/image/article/17253815983.jpg" alt=""><br>Fonte: SoSo Value</p>
<p>Guardando indietro nella storia, Nvidia è sempre stata altamente considerata come un punto di riferimento nel campo dei token concettuali di cripto IA. Dalla fine del 2022 fino al terzo trimestre di quest’anno, c’è stata una forte correlazione tra Nvidia e il mercato cripto. Ogni volta che il mercato nutre aspettative ottimistiche sulla redditività di Nvidia, i prezzi dei token legati all’IA spesso aumentano, formando una relazione sincrona.</p>
<p>Questa relazione è stata particolarmente evidente dopo che il rapporto finanziario di Nvidia è stato pubblicato a febbraio di quest’anno, quando c’è stata una significativa frenesia di hype nel settore dell’IA dell’industria criptata, e i prezzi dei token nel settore sono generalmente aumentati. La recente forte performance dei token dell’IA prima del rapporto finanziario di Nvidia conferma ancora una volta questo modello.</p>
<p>Tuttavia, con la breve fine delle speculazioni di mercato, le azioni tecnologiche legate a Nvidia sono passate da rialziste a ribassiste, e il mercato cripto nel complesso ha continuato il suo trend debole. Ci si aspetta che il settore dell’IA subirà un calo di risonanza in questo contesto.</p>
<p>Vale la pena notare che la prossima conferenza sugli utili di NVIDIA si terrà il 20 novembre, il che potrebbe inaugurare un’altra ondata di hype sui token di intelligenza artificiale.</p>
<h2 id="h2-Con20prospettive20ampie20quando20finir20la20fase20di20stasi20dellIA208217"><a name="Con prospettive ampie, quando finirà la fase di stasi dell’IA?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Con prospettive ampie, quando finirà la fase di stasi dell’IA?</h2><p>Il settore dell’IA è uno dei percorsi più eccitanti di questo mercato rialzista. Finora ci sono stati diversi progetti crittografici di IA influenti, come il protocollo NEAR, <a href="/price/internet-computer-icp" rel="nofollow noopener noreferrer" target="_blank">Internet Computer</a> (ICP), <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.AI</a>(FET), <a href="/price/render-rndr" target="_blank" class="blog_inner_link">Render</a> (RNDR) e Bittensor (TAO). Questi progetti dimostrano l’ampio potenziale dell’intelligenza artificiale nel campo crittografico attraverso mezzi tecnologici unici, come la tecnologia di sharding, piattaforme di calcolo decentralizzate, agenti intelligenti, ecc.</p>
<p>Dal punto di vista degli scenari di applicazione, l’applicazione dell’IA nel campo delle criptovalute copre molti aspetti come l’integrazione della potenza di calcolo, i contratti intelligenti, l’analisi dei dati, la previsione di mercato, la gestione del rischio e la creazione di contenuti.<br>Ad esempio, Arkham è una piattaforma di analisi dell’intelligenza artificiale che copre l’analisi di varie entità, scambi, fondi, balene e token. Gli utenti possono acquistare e vendere in modo anonimo informazioni sugli indirizzi del portafoglio blockchain tramite contratti intelligenti.<br>I compratori richiedono informazioni alla comunità tramite una ricompensa, mentre i cacciatori di ricompense ricevono premi inviando le informazioni richieste.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17253816374.jpg" alt=""><br>Origine: ARKHAM</p>
<p>Una nuova traccia così immaginativa è suscettibile all’entusiasmo di mercato. Dall’esperienza passata, la scoperta del valore dei token AI dipende non solo dalla pratica efficace delle loro prospettive di applicazione, ma anche dall’influenza delle azioni tecnologiche AI come Nvidia e TSMC. In effetti, Nvidia è sempre stata un tipico rappresentante della narrazione AI nella finanza tradizionale, con intricate relazioni commerciali con numerosi protocolli AI ed è diventata un catalizzatore emotivo de facto per questo settore.</p>
<p>Da una prospettiva più ampia, non solo i token AI nel mercato crittografico sono rimasti indietro quest’anno, ma anche il settore dell’IA nel mercato azionario statunitense è caduto in una fase di stallo. Molte note società di software di livello applicativo per l’IA, come Adobe (ADBE), Snowflake (SNOW), Unity Software (U) e UiPath (PATH), mancano di un’innovazione efficace nel loro business legato all’IA e non riescono a creare nuovi punti di crescita dei ricavi. Di conseguenza, le loro performance sono state al di sotto delle aspettative, rendendole uno dei settori con le peggiori performance.<img src="https://gimg2.gateimg.com/image/article/17253816585.jpg" alt=""><br>Fonte: news.futunn.com</p>
<p>La storia ha dimostrato che le tecnologie rivoluzionarie spesso evolvono dall’hardware al software e hanno molti colpi di scena, e l’IA non fa eccezione. Le sfide a breve termine sono inevitabili, ma il progresso tecnologico e l’adozione pratica saranno inarrestabili. Pertanto, da questo punto di vista, ci sono ancora significativi spazi di sviluppo per aziende come NVIDIA e TSMC, mentre i protocolli di calcolo AI, come Render e io.net, ne trarranno vantaggio.</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 il punto di vista del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita 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></div>