V0xEIHN0aWpndCBtZXQgMjgwJSBpbiB0d2VlIHdla2VuLCBhbmFseXNlZXIgaW52ZXN0ZXJpbmdzbW9nZWxpamtoZWRlbiBpbiBkZSBBSS1zZWN0b3I=

2024-02-23, 10:00

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR846649"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>De AI-track heeft de markt onlangs omhoog gebracht vanwege de nieuwste tekst-naar-video Sora van OpenAI, wat heeft geleid tot een reeks concepttokens zoals Sora en Wld.</p>
<p>Sora won snel aan populariteit vanwege zijn oneindige creativiteitssymboliek, vertegenwoordigd door het Japanse woord ‘そら’, evenals zijn uitstekende effecten en eenvoudige tekst naar video-effecten.</p>
<p>De AI-track ontstond al in 2023 door de lancering van ChatGPT door OpenAI en heeft dit jaar opnieuw aan populariteit gewonnen vanwege Sora. Dit duidt erop dat de AI-sector een belangrijk onderdeel van deze bullmarkt kan worden, wat een paradigmaverschuiving zal veroorzaken.</p>
<h2 id="h2-Kennismaking658887"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Sinds het Chinese Nieuwjaar heeft de AI-markt in de cryptocurrency-markt een welvarend beeld laten zien, met voortdurende populariteit die op de eerste plaats staat. Met Sora, de nieuwste tekst-naar-video van OpenAI, als aanleiding, hebben een reeks AI-concepttokens zoals Sora en Wld de markt geleid in sterke winsten. Daarom zal in de volgende tekst een voor een worden geanalyseerd of deze ronde van AI-koorts duurzaam is en hoe investeringsmogelijkheden in deze sector moeten worden beoordeeld.</p>
<h2 id="h2-Sora20Onthuld20Luidt20een20Nieuw20Tijdperk20van20Kunstmatige20Intelligentie20In40879"><a name="Sora Onthuld, Luidt een Nieuw Tijdperk van Kunstmatige Intelligentie In?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sora Onthuld, Luidt een Nieuw Tijdperk van Kunstmatige Intelligentie In?</h2><p>Tijdens het Lentefestival leidde OpenAI actief de trend van AI-chipinvesteringen en lanceerde een nieuw niet-open-sourceproduct Sora voor door tekst gegenereerde video’s, wat een reeks AI-tokens zoals Sora, een meme-munt met dezelfde naam, en het project Wld van OpenAI-oprichter Ultraman veroorzaakte.</p>
<p>Sommige mensen hebben opgemerkt dat de opkomst van Sora wordt gekenmerkt door ‘ultralange lengte van de jaren 60,’ enkele video’s met meerdere hoeken,’ en ‘wereldmodellen,’ die de komst van een nieuw tijdperk van visueel vertellen aankondigen. Het kan de verbeelding van mensen omzetten in levendige dynamische beelden en de magie van tekst omzetten in een visueel feest.<img src="https://gimg2.gateimg.com/image/article/1708682213img_v3_028b_3c970e8b-9797-4d3d-a9f9-9852846f71ix.jpg" alt=""><br>Bron: @OpenAI</p>
<p>Sora is een geavanceerd kunstmatig intelligentiemodel ontwikkeld door het Amerikaanse kunstmatige intelligentie-onderzoeksinstituut OpenAI, dat op basis van door gebruikers verstrekte tekstbeschrijvingen overeenkomstige video’s kan genereren. Sora’s technologische fundament is gebouwd op het tekst-naar-beeldgeneratiemodel DALL-E van OpenAI, en door verder onderzoek en optimalisatie heeft het de mogelijkheid verworven om tekst naar video om te zetten.</p>
<p>Wat betreft de trainingsgegevens van het model heeft OpenAI echter de specifieke hoeveelheid en exacte bron niet bekendgemaakt, alleen dat deze gegevens openbaar beschikbare video’s en auteursrechtelijk beschermde video’s omvat die specifiek zijn geautoriseerd voor trainingsdoeleinden.</p>
<p>Hoewel Sora nog steeds gebruikmaakt van de Transformer-architectuur en het diffusiemodel, ligt de grootste innovatie in zijn vermogen om natuurwetten zoals vlamreflectie en objectbewegingsinertie nauwkeurig weer te geven in gegenereerde video’s. In vergelijking met andere diffusiemodellen vertoont de videouitvoer van Sora een uiterst hoge stabiliteit en coherentie. Daarom bieden de door AI gepresenteerde video’s gebruikers een samenhangende, logische en zeer plezierige ervaring. Het is vermeldenswaard dat Sora nog steeds de schaalwet van AI volgt. OpenAI wijst duidelijk in de technische documentatie erop dat met de toename van trainingsberekening de monsterkwaliteit aanzienlijk is verbeterd, wat verder bevestigt dat het multimodale tijdperk is aangebroken.</p>
<p>Naast Sora heeft Nvidia ook de langverwachte AI lokale implementatietool Chat met RTX zoals gepland uitgebracht. Ondertussen heeft Google Gemini geüpgraded en versie 1.5 uitgebracht. Als gevolg hiervan heeft de positieve vooruitgang van de wereldwijde AI-sector de populariteit van de AI-sector op de cryptomarkt sterk gestimuleerd, vooral Sora, dat snel populair werd vanwege zijn oneindige creativiteit vertegenwoordigd door het Japanse woord “leeg”, uitstekende effecten en eenvoudige praktische toepasbaarheid. Eenmaal gelanceerd, stimuleerde het al snel het algehele succes van de AI-sector op de cryptocurrency-markt.</p>
<h2 id="h2-De20tokens20van20de20AIsector20leidden20de20stijging20met20de20hoogste20populariteit20ter20wereld800835"><a name="De tokens van de AI-sector leidden de stijging, met de hoogste populariteit ter wereld." class="reference-link"></a><span class="header-link octicon octicon-link"></span>De tokens van de AI-sector leidden de stijging, met de hoogste populariteit ter wereld.</h2><p>Op de schrijfdatum heeft de AI-sector nieuwe hoogtepunten bereikt met het financiële rapport van NVIDIA op woensdag, dat ver boven de verwachtingen uitkwam, maar het is nog steeds zeer populair in verschillende sectoren. Volgens de Gate.io-markt behoren de top drie qua marktwaarde tot Bittensor (TAO), <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Renderen</a> (RNDR) en <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a> (FET), met marktwaardes van respectievelijk $3.9B, $2.8B en $1.1B.<img src="https://gimg2.gateimg.com/image/article/1708682263img_v3_028b_285c3da9-da1d-4e90-9aa9-453c01cc7aix.jpg" alt=""><br>Bron: Gate.io</p>
<p>Als het gaat om de meest populaire Worldcoin (WLD), is het nodig voor ons om de basisachtergrond uit te leggen. Het project werd geïnitieerd door OpenAI-oprichter Ultraman en het projectteam heeft een apparaat genaamd Orb gebouwd, dat een afbeelding van het oog van een persoon kan vastleggen en converteren naar een korte numerieke code. Het heeft recentelijk aandacht gekregen van Vitalik.</p>
<p>Het is niet moeilijk om te zien aan de hand van de prijsgrafiek dat sinds de release van Sora, WLD is gestegen van het laagste punt van $2,1 naar het hoogste punt van $8,4, met een marktwaarde vergelijkbaar met <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>Bron: Gate.io</p>
<p>In feite is WLD zelf niet de AI-sector token, maar de grootste begunstigde, en de aanzienlijke stijging van de muntkoersen is grotendeels te wijten aan de gekte veroorzaakt door de associatie met de oprichter van OpenAI.</p>
<p>De meer orthodoxe AI-token is <a href="/price/livepeer-lpt" rel="nofollow noopener noreferrer" target="_blank">Livepeer</a> Na de release van Sora steeg de prijs van de coin snel met meer dan 60%, (LPT).</p>
<p>Livepeer is een gedecentraliseerd video streaming netwerk gebaseerd op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain. Vanwege de grote hoeveelheid GPU (grafische verwerkingseenheid) rekenkracht die nodig is om hoogwaardige videomateriaal te genereren en de hoge kosten, weerspiegelt de stijging van de LPT-tokenprijzen de toenemende vraag naar hoogwaardige videogeneratie op de markt. Ondertussen is de Livepeer-gemeenschap van plan om zijn netwerk in de komende maanden te integreren met tekst gegenereerde videotechnologie. Hoewel het specifieke tijdschema en details nog niet zijn aangekondigd, wordt verwacht dat dit plan de waarde van LPT-tokens verder zal versterken.</p>
<p>Bovendien heeft SingularityNET (AGIX), als platform dat de creatie, deling en monetisatie van AI-diensten op grote schaal mogelijk maakt, een aanzienlijke groei doorgemaakt in zijn eigen token AGIX, met een stijging van meer dan 30%.</p>
<p>Volgens de laatste statistieken van CoinMarketCap bedraagt de totale marktwaarde van het AI&amp;Big Data segment $23B, met in totaal 237 tokens, waarvan 197 tokens geprijsd en online verhandeld zijn, wat overeenkomt met 1.19% van de totale crypto marktwaarde.</p>
<h2 id="h2-Kan20de20populariteit20van20de20AIsector20blijven20groeien20en20wat20is20de20investeringswaarde20ervan515144"><a name="Kan de populariteit van de AI-sector blijven groeien en wat is de investeringswaarde ervan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kan de populariteit van de AI-sector blijven groeien en wat is de investeringswaarde ervan?</h2><p>Natuurlijk kan, op basis van eerdere ervaringen, de populariteit van geen enkele sector in de cryptocurrency-markt onveranderd blijven. Met de afname van de hype rond winstnemingen en de toename van risico’s in kunstmatige intelligentie, kan de populariteit van de AI-sector worden aangepast.</p>
<p>De innovatie van AI-technologie heeft zowel enorme kansen als potentiële risico’s met zich meegebracht. Om de veiligheid ervan te waarborgen voordat Sora-technologie wordt gebruikt, heeft OpenAI een reeks beveiligingsmaatregelen genomen. Ze werken samen met leden van het rode team om de risico’s in belangrijke gebieden met behulp van Sora te beoordelen en nodigen beeldend kunstenaars, ontwerpers en filmmakers uit om feedback te geven om de praktische toepasbaarheid van het model voor creatieve professionals te optimaliseren.</p>
<p>OpenAI waarschuwt echter ook dat ondanks uitgebreid onderzoek en testen, het nog steeds moeilijk is om te voorspellen hoe gebruikers zullen profiteren van of misbruik zullen maken van de technologie. Sterker nog, sommigen beweren dat deze technologie kan worden misbruikt door cryptofraudsters. Oplichters kunnen Sora gebruiken om nep-beroemdheidsaanbevelingsvideo’s te maken, video’s met vooringenomenheid of onjuiste informatie, en deze breed verspreiden via sociale mediaplatforms.<img src="https://gimg2.gateimg.com/image/article/1708682354img_v3_028b_2234f8cd-3965-4705-9c82-5830ece93dix.jpg" alt=""><br>Bron: @OpenAI</p>
<p>Daarnaast zijn er ook enkele projecten die zich voordoen als AI-namen die mogelijk profiteren van verkeersvoordelen om te lanceren, en de risico’s en verborgen gevaren op deze gebieden zijn het waard dat beleggers waakzaam zijn.</p>
<p>Wanneer we de populariteit van het AI-track als geheel bekijken, is het niet moeilijk om te zien dat de grotere macro-achtergrond is dat naarmate de cryptocurrency-markt steeds volwassener wordt, de verwachtingen van mensen blijven stijgen. Vooral met de komende halvering van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> in april en de lancering van Sora heeft de aandacht van de markt een nieuw hoogtepunt bereikt.</p>
<p>De opkomst van kunstmatige intelligentie op het gebied van cryptocurrency is niet tolig. Al in het eerste kwartaal van 2023 zorgden nieuwe technologieën zoals ChatGPT en MidJourney voor de eerste lancering van kunstmatige intelligentie cryptocurrencies. Deze technologieën leiden niet alleen een nieuwe golf van technologie, maar stimuleren ook technologieën zoals Fetch de stijging van AI-tokens zoals AI (FET), SingularityNet (AGIX), en zelfs DePIN-sectoren zoals Akash (AKT).</p>
<p>Over het algemeen heeft de opkomst van Sora, een innovatieve technologie die in 2024 begon, het enthousiasme van de markt voor AI-technologie opnieuw aangewakkerd en de aandacht getrokken van investeerders en technologieliefhebbers, samen met de aandacht van talloze Altcoins en Meme-munten die nauw verwant zijn aan AI-technologie. Beleggers moeten ook letten op kortetermijnfluctuaties om speculatieve risico’s te verminderen, terwijl ze deze investeringsmogelijkheid “dikke helling en lange sneeuw” nauwlettend volgen.</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 visie van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>