RmluYW5jacOrbGUgbWlqbHBhYWwgdmFuIE9wZW5BSSB6b3JndCB2b29yIG9udmVyd2FjaHRlIG5lZXJnYW5nIHZhbiBBSSBDcnlwdG9zIFRBTyBlbiBGRVQ=

2024-10-16, 07:09

<p><img src="https://gimg2.gateimg.com/image/article/17290621171690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR913782"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>OpenAI heeft $6,6 miljoen opgehaald in een financieringsronde waarbij toonaangevende durfkapitaalfondsen hebben deelgenomen.</p>
<p>Tijdens de eerste week van oktober vertoonden TAO en FET tekenen van toenemende bearish momentum.</p>
<p>Bij het investeren in AI-cryptovaluta moeten investeerders de diversificatiestrategie hanteren.</p>
<h2 id="h2-Introductie954592"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>OpenAI heeft geholpen om het concept van generatieve kunstmatige intelligentie onder de aandacht te brengen van veel mensen, instellingen en overheden. Die bewustwording begon in 2022 toen het ChatGPT lanceerde, een generatieve kunstmatige intelligentie-chatbot. Andere populaire door kunstmatige intelligentie aangedreven chatbots zijn Gemini, Chatsonic, Claude en Jasper. Vandaag richten we ons op OpenAI’s recente financieringscampagne gericht op het verkrijgen van kapitaal om zijn AI-diensten te verbeteren en uit te breiden.</p>
<h2 id="h2-OpenAI20haalt206620miljard20op20te20midden20van20hoge20verwachtingen20voor20AImunten802308"><a name="OpenAI haalt $6,6 miljard op te midden van hoge verwachtingen voor AI-munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>OpenAI haalt $6,6 miljard op te midden van hoge verwachtingen voor AI-munten</h2><p>Onlangs heeft OpenAI een inzamelingsinitiatief afgerond waarbij het $6,6 miljard heeft opgehaald. Het doel van het fonds is om de prestaties te verbeteren, de infrastructuur op te schalen en oplossingen te ontwikkelen voor de uitdagingen waarmee het momenteel wordt geconfronteerd. De waardering is gestegen van $29 miljard naar $80 miljard, wat duidt op zijn dominante positie in de AI-sector. Dat toont ook zijn interesse in het behouden van zijn leidende positie en het uitbreiden van zijn onderzoekscapaciteit.</p>
<p>In zijn blogpost van 2 oktober commentaar geven <a href="https://openai.com/index/scale-the-benefits-of-ai/" rel="nofollow noopener noreferrer" target="_blank">OpenAI zei</a>, “De nieuwe financiering stelt ons in staat om onze leidende positie in AI-onderzoek in de frontlinie te verdubbelen, rekencapaciteit te vergroten en tools te blijven ontwikkelen die mensen helpen moeilijke problemen op te lossen.” De groei in het OpenAI-ecosysteem was het gevolg van ChatGPT. Op dit moment heeft ChatGPT gemiddeld 250 miljoen actieve gebruikers, waarvan 11 miljoen abonnees. Wat betreft de omzet wordt verwacht dat OpenAI in 2024 een omzet van ongeveer $3,7 miljard zal genereren en in 2025 $11,6 miljard.</p>
<p>Enkele van de gevestigde bedrijven die deelnamen aan de financiering van OpenAI zijn chipfabrikant Nvidia, de Japanse groep SoftBank, Thrive Capital en MGX. Na het succesvolle financieringsinitiatief wordt de waardering ervan gelijkgesteld met het Amerikaanse multinationale transportbedrijf Uber. De marktkapitalisatie is echter nog steeds veel lager dan die van Microsoft, een van de investeerders.</p>
<p>Lees ook: <a href="https://www.gate.io/blog/4139/the-rise-of-chinese-ai-unicorns-and-a-battle-with-openai" target="_blank">De opkomst van Chinese AI-unicorns en een strijd met OpenAI</a></p>
<h2 id="h2-Marktprestaties20van20toonaangevende20AIcryptocurrencies20TAO20en20FET20worden20geconfronteerd20met20aanzienlijke20neergangen204277"><a name="Marktprestaties van toonaangevende AI-cryptocurrencies: TAO en FET worden geconfronteerd met aanzienlijke neergangen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktprestaties van toonaangevende AI-cryptocurrencies: TAO en FET worden geconfronteerd met aanzienlijke neergangen</h2><p><a href="https://www.gate.io/how-to-buy/bittensor-tao" target="_blank">Bittensor (TAO)</a> de prijs kan stijgen als er een opmerkelijke vermindering is in de verkoopdruk. Als het verkoopmomentum afneemt en meer investeerders AI crypto kopen, kan de prijs stijgen tot ongeveer $ 617,90.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/how-do-ai-large-models-and-web3-coexist-all-creation-camp-ai-crypto-studio/1675" target="_blank">Hoe kunnen AI grote modellen en Web3 naast elkaar bestaan?</a></p>
<p>Gebaseerd op de <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">FET prijs</a> analyseer de AI crypto ondervond hetzelfde lot als TAO. Tegen 3 oktober waren er sterke tekenen dat het depressief was en er was geen teken van een bullish ommekeer. De prijs stond op die dag op $1,40 en was lager dan de 20-daagse. <a href="https://www.gate.io/learn/articles/what-is-the-exponential-moving-average/423" target="_blank">Exponentieel Voortschrijdend Gemiddelde</a> (EMA, dat een grote neerwaartse druk liet zien. Over het algemeen, als de prijs boven de 20 EMA ligt, geeft dit aan dat er bullish momentum is. Veel technische indicaties lieten een sterke mogelijkheid van een aanhoudende neerwaartse trend zien. Het niet op tijd herstellen zou ertoe leiden dat de prijs onder $1,22 zou vallen. Op basis van de bestaande marktvoorspelling zou het herstel en een toename van het bullish momentum de prijs richting $1,74 duwen.</p>
<h2 id="h2-Het20SelltheNews20Effect20op20AI20Crypto191771"><a name="Het Sell-the-News Effect op AI Crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het Sell-the-News Effect op AI Crypto</h2><p>Het concept van ‘koop het gerucht’, verkoop het nieuws’ is erg populair in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptocurrency markt</a>. Deze strategie draait om het feit dat bepaalde gebeurtenissen invloed hebben op de prijzen van beleggingsactiva, waardoor ze stijgen of dalen. Daarom kunnen onbevestigde geruchten een sterke invloed hebben op de prijsrichting van digitale activa zoals kunstmatige intelligentie munten. Daarom kopen de meeste handelaren AI-crypto-activa wanneer er geruchten zijn over positieve ontwikkelingen in de sector of een verbetering van het economische vooruitzicht. Als voorbeeld kochten sommige investeerders FET en TAO na het nieuws over een mogelijke financieringsronde van OpenAI. Echter, wanneer het vermeende evenement plaatsvond, kan de prijs stabiliseren of zich omkeren.</p>
<p>In werkelijkheid kan een eenvoudige tweet van een bekende investeerder de prijs van een munt doen stijgen of dalen. Nieuws over de lancering van een nieuw AI-project, verbetering in de blockchain technologie, renteverlagingen, een wereldwijde crisis of regelgevende veranderingen kunnen handelaren dwingen om te verkopen of <a href="/crypto/buy" rel="nofollow noopener noreferrer" target="_blank">crypto kopen</a> Activa. Positief nieuws zoals de goedkeuring van een cryptocurrency door een beroemdheid kan de prijs doen stijgen. Negatief nieuws zoals een lopende juridische procedure tegen een crypto project kan een bearish momentum teweegbrengen.</p>
<h2 id="h2-Vooruitblik20de20daling20van20FET20een20nadere20kijk20op20markttrends20en20voorspellingen2199"><a name="Vooruitblik: de daling van FET: een nadere kijk op markttrends en voorspellingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vooruitblik: de daling van FET: een nadere kijk op markttrends en voorspellingen</h2><p>Ondanks de recente bearish markt van TAO vertoont het tekenen van herstel. De opkomst van TAO is verbonden met het Grayscale Decentralized AI Fund. Belangrijker nog, de boost kwam weken geleden toen Grayscale zijn toewijzing van het fonds met 27,6% verhoogde tegen 4 oktober. Interessant genoeg heeft TAO een aandeel van 30,2% van het fonds. Als gevolg hiervan steeg het handelsvolume van TAO met 286% tussen 7 september en 7 oktober. Tegelijkertijd steeg de marktkapitalisatie van $1,7 miljard naar $4,7 miljard. Met deze ontwikkelingen kan TAO zijn all-time high van $757,60 overstijgen, tijdens dit kwartaal.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/an-overview-of-the-grayscale-ethereum-trust-ethe/4331 &quot;An Overview of the Grayscale Ethereum Trust (ETHE" rel="nofollow noopener noreferrer" target="_blank">Een overzicht van de Grayscale Ethereum Trust (ETHE)</a>”)</p>
<p>Afgezien van TAO de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> Verwacht wordt dat de prijs van FET ook in dit kwartaal zal stijgen en zal herstellen van de huidige niveaus. Het vertoont al tekenen van marktherstel. Zo stuiterde FET bijvoorbeeld op 11 oktober van het ondersteuningsniveau van $1,26 en testte het de weerstandsmarkering van $1,40 opnieuw. Als het deze grens echter overschrijdt, kan het verdere weerstand ondervinden op het prijsniveau van $1,85. Belangrijk is dat als het deze hindernis overwint, de waarde ervan kan stijgen naar $3,08. Een vergelijkbaar scenario deed zich voor in maart. Niettemin moet de prijs met 115% stijgen om dit niveau te bereiken. Aan de andere kant kan de prijs dalen naar $1,26 als het niet boven het niveau van $1,85 uitkomt.</p>
<h2 id="h2-Investeringsstrategien20voor20AI20Crypto20Enthusiasts437572"><a name="Investeringsstrategieën voor AI Crypto Enthusiasts" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Investeringsstrategieën voor AI Crypto Enthusiasts</h2><p>Om rendement te behalen bij het investeren in AI-cryptocurrencies, moeten investeerders bewezen crypto-beleggingsstrategieën gebruiken. Laten we kort kijken naar de strategieën die het meest geschikt zijn voor crypto-activa.</p>
<p>Diversificatie: Een slimme crypto-investeerder moet zijn/haar fondsen toewijzen aan verschillende activa die mogelijk <a href="https://www.gate.io/blog/4578/tao-surges-driving-new-narrative-in-ai-sector" target="_blank">inclusief TAO</a>, FET, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en ETH. Aangezien AI-cryptocurrencies goede rendementen beloven, moet een individu AI-crypto-assets kopen die verschillende sectoren bedienen.</p>
<p>Gebruik technische analyse: Het is belangrijk dat elke crypto-investeerder technische analyse gebruikt bij het selecteren van cryptocurrencies om in te investeren. Bijvoorbeeld, investeerders moeten grafieken, volumes en andere metrics zoals MVRV analyseren om toekomstige prijsbewegingen van verschillende digitale valuta’s te voorspellen.</p>
<p>Fundamentele analyse: Het is niet genoeg om de technische aspecten van een activum te analyseren. Men moet ook de fundamentals ervan beoordelen, zoals token distributie en totale aanbod. Het is ook nodig om de use-cases van de munt en het team erachter te kennen.</p>
<p>Sentimentanalyse: Het feit dat de cryptosector wordt beïnvloed door publieke opinies laat zien dat het belangrijk is om de heersende <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> sentiment. Bijvoorbeeld, <a href="https://www.gate.io/price/view/artificial-intelligence" target="_blank">als je AI crypto koopt</a> wanneer de gemeenschap een negatief sentiment heeft, kan de toekomst ervan somber zijn.</p>
<p>Andere Belangrijke Aspecten: Naast de bovenstaande strategieën moeten beleggers gebruik maken van passende risicobeheersingsinstrumenten. Ze moeten ook het laatste nieuws volgen dat van invloed kan zijn op de prijzen van digitale valuta.</p>
<h2 id="h2-Conclusie709272"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>OpenAI slaagde erin om $6,6 miljoen op te halen, waar het naar streeft om zijn onderzoekscapaciteit te verbeteren. Ook streeft het ernaar zijn infrastructuur te verbeteren om betrouwbare service aan de markt te bieden. In gerelateerd cryptonieuws kunnen de TAO- en FET-prijzen zich in de rest van het jaar herstellen. Dit komt doordat de positieve ontwikkelingen die plaatsvinden in de sector van kunstmatige intelligentie de waarde van AI-cryptovaluta zoals TAO en FET stimuleren.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling. Alle investeringen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>