QUktc2VjdG9yIGluZ2VzdG9ydCBkb29yIE52aWRpYSwgaXMgZXIgZGl0IGphYXIgbm9nIHN0ZWVkcyBlZW4ga2FucyBvcCBoZXJzdGVsPw==

2024-09-03, 16:42

<p><img src="https://gimg2.gateimg.com/image/article/17253813611690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR69645"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>De omzet en winst van Nvidia in Q2 overtroffen beide de verwachtingen van de markt, terwijl de omzet in Q3 iets lager was dan de meest optimistische verwachtingen, waardoor de aandelenkoers eerst steeg en vervolgens daalde. Alle drie de belangrijkste Amerikaanse aandelenindices sloten lager, en de AI-sector in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">Crypto-markt</a> steeg eerst en viel toen.</p>
<p>Wanneer de markt optimistische verwachtingen heeft over de winstgevendheid van Nvidia, stijgen de prijzen van gerelateerde AI-tokens vaak, waardoor er een synchrone relatie ontstaat.</p>
<p>De ontdekking van de waarde van AI-tokens hangt af van de effectieve praktijk van hun toepassingsvooruitzichten, evenals de invloed van AI-technologiestocks zoals NVIDIA en TSMC.</p>
<h2 id="h2-Introductie299288"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Onlangs zijn AI-sector tokens gestegen als gevolg van speculatie rondom het financiële rapport van Nvidia (NVDA. US), maar ze zijn gestagneerd en gedaald na de publicatie van het rapport.</p>
<p>Tegen de achtergrond van de algemene zwakte op de cryptomarkt lijkt de AI-sector niet langer zo bloeiend te zijn als vorig jaar. Dit artikel zal in detail onderzoeken of er in de toekomst nieuwe narratieve logica in deze sector zal zijn en of deze een sterke opleving kan teweegbrengen.</p>
<h2 id="h2-Financieel20rapport20overtreft20verwachtingen20maar20Nvidia20ondermijnt20nog20steeds20het20vertrouwen20in20AI679016"><a name="Financieel rapport overtreft verwachtingen, maar Nvidia ondermijnt nog steeds het vertrouwen in AI?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Financieel rapport overtreft verwachtingen, maar Nvidia ondermijnt nog steeds het vertrouwen in AI?</h2><p>Als toonaangevend bedrijf op het gebied van AI-rekenkracht heeft Nvidia (NVDA. US) invloed op de volatiliteit van de Amerikaanse aandelenmarkt en heeft het een directe impact op de crypto-AI-sector. Op dit moment ligt de focus van de markt op het financiële rapport dat eind augustus is uitgebracht.</p>
<p>Volgens het vrijgegeven financiële rapport voor het tweede kwartaal heeft Nvidia aanzienlijke groeiprestaties geboekt, waarbij de omzet voor het tweede kwartaal $30 miljard bedroeg, een stijging van 122% ten opzichte van dezelfde periode vorig jaar, ver boven de oorspronkelijke voorspelling van de marktanalisten van $28,86 miljard. In het belangrijke bedrijfsgebied van gegevenscentra bedroeg de omzet $26,3 miljard, een jaar-op-jaar stijging van 154%, ook boven de verwachtingen van analisten ($25,08 miljard). Het vooruitzicht van het bedrijf voor het volgende fiscale kwartaal is optimistisch, met een verwachte omzet voor het derde kwartaal van ongeveer $32,5 miljard, schommelend tussen plus en min 2%. Deze prognose is ook hoger dan de algemene verwachtingen van analisten ($31,9 miljard) en lager dan de meest optimistische verwachting van de markt van $37,9 miljard.<br><img src="https://gimg2.gateimg.com/image/article/17253815421.jpg" alt=""><br>Bron: nvidia.com</p>
<p>Specifiek wat betreft de game-inkomsten was de prestatie van Nvidia in het tweede kwartaal even indrukwekkend, met een omzet van $2,9 miljard, een jaar-op-jaar stijging van 16%, wat de verwachtingen van analisten overtrof ($2,79 miljard). Wat betreft de brutowinstmarge en de winst per aandeel toonde Nvidia ook een sterke financiële gezondheid, met een aangepaste brutowinstmarge die steeg naar 75,7%, een aanzienlijke stijging ten opzichte van dezelfde periode vorig jaar (71,2%) en iets hoger dan de verwachtingen van analisten (75,5%). Aangepaste winst per aandeel was $0,68, een aanzienlijke jaar-op-jaar stijging, ruim boven de $0,27 van het voorgaande jaar en beter dan de voorspelling van analisten van $0,64. De nettowinst bedroeg een verbazingwekkende $16,599 miljard, een jaar-op-jaar stijging van 168%, ruim boven de verwachting van analisten van $14,64 miljard.</p>
<p>Om zich in te dekken tegen marktteleurstelling over prestatierichtlijnen, kondigde Nvidia een plan aan om voor $50 miljard aan aandelen terug te kopen en handhaafde zijn driemaandelijkse dividend per aandeel ongewijzigd.</p>
<p>Maar dit verlichtte de marktzorgen niet over zijn verzwakte groei, omdat de aandelenkoers van Nvidia eerst steeg en vervolgens daalde. Na de publicatie van het financiële rapport daalde de aandelenkoers van Nvidia met meer dan 8% in de handel na sluitingstijd.<br><img src="https://gimg2.gateimg.com/image/article/17253815722.jpg" alt=""><br>Bron: Investing.com</p>
<p>Nvidia’s Q2-omzet en winst overtroffen de marktverwachtingen, terwijl de Q3-omzet iets lager was dan de meest optimistische verwachtingen. Door factoren als hoge marktverwachtingen en uitdagingen op het gebied van productiekosten steeg de aandelenkoers eerst en daalde toen, zelfs scherp met 8% na sluiting van de markt. Alle drie de belangrijkste Amerikaanse aandelenindices sloten lager en dergelijke hevige schommelingen zorgden natuurlijk voor een stijging en daling van de AI-sector in de cryptomarkt.</p>
<h2 id="h2-Is20het20verhaal20van20de20AIsector20zwak20uitsluitend20vertrouwend20op20Nvidia458978"><a name="Is het verhaal van de AI-sector zwak, uitsluitend vertrouwend op Nvidia?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is het verhaal van de AI-sector zwak, uitsluitend vertrouwend op Nvidia?</h2><p>Voor de publicatie van het financiële rapport van Nvidia, <a href="/price/near-protocol-near" rel="nofollow noopener noreferrer" target="_blank">Near Protocol</a>(NEAR), Artificial Super Alliance (FET), Bittensor (TAO), en <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Render</a> (RENDER) liet een indrukwekkende prijsprestatie zien. Deze tokens herstelden snel naar hun vorige hoogtepunten na de marktcrash begin augustus, en de AI-sector, die tot wel 70% steeg, werd de enige sterke sector in een zwakke markt.</p>
<p>Bijzondere vermelding verdienen de FET en TAO, die de meest indrukwekkende prijsprestaties hebben. Artificial Super Alliance (FET), als de token van de Artificial Super Intelligence Alliance, integreert kunstmatige intelligentie crypto-projecten zoals OCEAN en AGIX, met als doel de krachtigste onafhankelijke open-source AI-onderzoeks- en ontwikkelingsorganisatie te worden; Bittensor (TAO) is een open-source blockchain-protocol dat zich richt op het bouwen van efficiënte gedecentraliseerde AI-machine learningnetwerken, waardoor de ontwikkeling en distributie van AI-rekenkracht wordt bevorderd.</p>
<p>Hoewel deze twee projecten niet geselecteerd werden voor het Nvidia Inception programma zoals Aethir (ATH), ChainGPT (CGPT), en <a href="/price/flux-flux" rel="nofollow noopener noreferrer" target="_blank">Flux</a> (FLUX), ze zijn de gesegmenteerde leiders in het AI-veld en zijn altijd belangrijke doelen van hype geweest.</p>
<p>Ongetwijfeld daalde de AI-sector over de hele linie nadat het financiële rapport van Nvidia was vrijgegeven, wat het speculatieve patroon van ‘verwachtingen kopen, feiten verkopen’ aantoonde.<img src="https://gimg2.gateimg.com/image/article/17253815983.jpg" alt=""><br>Bron: SoSo Value</p>
<p>Terugkijkend op de geschiedenis, wordt Nvidia altijd hoog aangeschreven als een benchmark in het veld van crypto AI-concept tokens. Vanaf het einde van 2022 tot het derde kwartaal van dit jaar was er een sterke correlatie tussen Nvidia en de cryptomarkt. Telkens wanneer de markt optimistische verwachtingen heeft voor de winstgevendheid van Nvidia, stijgen vaak de prijzen van gerelateerde AI-tokens, wat resulteert in een synchrone relatie.</p>
<p>Deze relatie werd vooral duidelijk nadat het financiële rapport van Nvidia in februari van dit jaar werd vrijgegeven, toen er een aanzienlijke hype was in de AI-sector van de crypto-industrie en de prijzen van tokens in de sector over het algemeen stegen. De recente sterke prestaties van AI-tokens vóór het financiële rapport van Nvidia bevestigen opnieuw dit patroon.</p>
<p>Echter, met het korte einde van marktspeculatie zijn Nvidia-gerelateerde technologische aandelen omgeslagen van stijgen naar dalen, en de algehele cryptomarkt heeft zijn zwakke trend voortgezet. Verwacht wordt dat de AI-sector een resonantiedaling zal ervaren in deze context.</p>
<p>Het is vermeldenswaard dat de volgende winstconferentie van NVIDIA zal plaatsvinden op 20 november, wat mogelijk een nieuwe golf van AI-tokenhype zal inluiden.</p>
<h2 id="h2-Met20brede20vooruitzichten20wanneer20zal20AI20zijn20neergang20beindigen248167"><a name="Met brede vooruitzichten, wanneer zal AI zijn neergang beëindigen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Met brede vooruitzichten, wanneer zal AI zijn neergang beëindigen?</h2><p>De AI-sector is een van de meest opwindende nieuwe ontwikkelingen in deze bullmarkt. Tot nu toe zijn er verschillende invloedrijke AI-cryptoprojecten geweest, zoals NEAR-protocol, <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), en Bittensor (TAO). Deze projecten tonen het uitgebreide potentieel van kunstmatige intelligentie in het crypto-veld via unieke technologische middelen, zoals sharding-technologie, gedecentraliseerde computingplatforms, intelligente agenten, enzovoort.</p>
<p>Vanuit het perspectief van toepassingsscenario’s bestrijkt de toepassing van AI in het crypto-veld meerdere aspecten zoals integratie van rekenkracht, slimme contracten, gegevensanalyse, marktvoorspelling, risicobeheer en inhoudcreatie.<br>Bijvoorbeeld, Arkham is een AI-intelligentie-analyseplatform dat de analyse van verschillende entiteiten, beurzen, fondsen, walvissen en tokens bestrijkt. Gebruikers kunnen anoniem informatie kopen en verkopen over eigenaars van blockchain-portemonnee-adressen via slimme contracten.<br>Kopers vragen intelligentie van de gemeenschap via een beloning, terwijl beloningjagers beloningen ontvangen door de gevraagde informatie in te dienen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17253816374.jpg" alt=""><br>Bron: ARKHAM</p>
<p>Zo’n fantasierijk nieuw nummer is vatbaar voor markthype. Uit eerdere ervaringen blijkt dat de ontdekking van de waarde van AI-tokens niet alleen afhangt van de effectieve praktijk van hun toepassingsvooruitzichten, maar ook van de invloed van AI-technologiestocks zoals Nvidia en TSMC. In feite is Nvidia altijd een typische vertegenwoordiger geweest van AI-verhalen in de traditionele financiële sector, met ingewikkelde zakelijke relaties met tal van AI-protocollen, en is het een feitelijk emotioneel katalysator geworden voor deze sector.</p>
<p>Vanuit een breder perspectief hebben niet alleen de AI-tokens op de cryptomarkt dit jaar achtergelopen, maar ook de AI-sector op de Amerikaanse aandelenmarkt is in een neergang beland. Veel bekende AI-toepassingslaagsoftwarebedrijven, zoals Adobe (ADBE), Snowflake (SNOW), Unity Software (U) en UiPath (PATH), missen effectieve innovatie in hun AI-business en kunnen geen nieuwe omzetgroei genereren. Als gevolg hiervan blijft hun prestatie achter bij de verwachtingen, waardoor ze een van de slechtst presterende sectoren zijn.<img src="https://gimg2.gateimg.com/image/article/17253816585.jpg" alt=""><br>Bron: news.futunn.com</p>
<p>De geschiedenis heeft aangetoond dat ontwrichtende technologieën vaak evolueren van hardware naar software en veel wendingen kennen, en AI vormt daarop geen uitzondering. Korte termijn uitdagingen zijn onvermijdelijk, maar technologische vooruitgang en praktische adoptie zullen niet te stoppen zijn. Vanuit dit perspectief is er dus nog aanzienlijke ruimte voor ontwikkeling voor bedrijven zoals NVIDIA en TSMC, terwijl AI-rekenprotocollen, zoals Render en io.net, daar ook van zullen profiteren.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>