Q29yZVdlYXZlLCBlZW4gdm9vcm1hbGlnZSBFdGhlcmV1bS1taWpud2Vya2VyLCBzbHVpdCBlZW4gbWlsamFyZC1kb2xsYXIgQUktY29tcHV0aW5nY29udHJhY3QgYWYgbWV0IE1pY3Jvc29mdA==

2023-06-14, 02:31

<p><img src="https://gimg2.gateimg.com/image/article/1684401663RDZZ.jpeg" alt=""><br>CoreWeave heeft een meerjarig AI-computercontract ter waarde van miljarden dollars met Microsoft.</p>
<p>De twee bedrijven hebben nog niet gepubliceerd hoeveel de deal precies waard is.</p>
<p>CoreWeave, gewaardeerd op $2 miljard, werd in 2017 opgericht als een ETH mijnbouwbedrijf.</p>
<p>Trefwoorden: ETH-mining, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> miner, ChatGPT, AI-deal, AI-computingcontract, investering</p>
<h2 id="h2-Introductie471654"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De prominente generatieve kunstmatige intelligentie (AI) die door ChatGPT is getriggerd, transformeert de communicatie- en kunstindustrie op een manier die nooit eerder is bedacht. De ontwikkelingen die hebben plaatsgevonden sinds de introductie van generatieve AI hebben aangetoond dat AI bepaalde functies kan uitvoeren die menselijke wezens doen.</p>
<p>Als gevolg hiervan hebben veel bedrijven AI-technologieën in hun bedrijfsmodellen opgenomen. In dit artikel wordt onderzocht hoe de samenwerking tussen<br><strong>CoreWeave en Microsoft</strong> zal bedrijven en mensen in het algemeen helpen.</p>
<h2 id="h2-CoreWeave20werkt20samen20met20Microsoft20om20AItechnologie20te20bevorderen362450"><a name="CoreWeave werkt samen met Microsoft om AI-technologie te bevorderen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CoreWeave werkt samen met Microsoft om AI-technologie te bevorderen</h2><p>De tech-gigant, Microsoft, heeft een partnerschap aangegaan met CoreWeave, dat wordt ondersteund door Nvidia, om de AI-capaciteiten van Microsoft te verbeteren. Microsoft heeft al verschillende stappen gezet op het gebied van kunstmatige intelligentie door het integreren van het GPT-4-systeem van OpenAI in zijn twee webbrowsers, Microsoft Edge en Bing.</p>
<p>De meer miljard dollar strategische deal tussen deze twee bedrijven zal Microsoft in staat stellen om CoreWeave, een voormalige Ethereum-mijnwerker, cloud computing-infrastructuur te gebruiken om zijn door AI ondersteunde diensten te stimuleren. Opmerkelijk is dat CoreWeave, dat in 2017 is opgericht, concurrerende en schaalbare cloud GPU-rekenkrachtdiensten biedt.</p>
<p>De financiële details van deze deal zijn niet openbaar gemaakt, hoewel betrouwbare bronnen zeiden dat het gaat om miljarden dollars. Ook zal deze samenwerking zich uitstrekken over meerdere jaren.</p>
<h2 id="h2-Wat20is20de20capaciteit20van20CoreWeave788817"><a name="Wat is de capaciteit van CoreWeave?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de capaciteit van CoreWeave?</h2><p>We kunnen het belang van deze deal het beste begrijpen als we de capaciteit van CoreWeave om betrouwbare computingservices te bieden waarderen. In de eerste plaats biedt CoreWeave een GPU-service voor high-performance computing tegen lage kosten. In feite, <a href="https://www.coreweave.com/why-coreweave" rel="nofollow noopener noreferrer" target="_blank">CoreWeave beweert</a> dat het GPU’s levert die 80% minder duur zijn dan ‘legacy cloud providers.’</p>
<p>De Nvidia’s GPU’s die CoreWeave aanbiedt, maken deel uit van de infrastructuur die geavanceerde AI-en ondersteunt, zoals het GPT-4-model van OpenAI. Momenteel zijn de grafische verwerkingseenheden (GPU’s) die CoreWeave biedt de beste op de markt die werken met AI-technologie zoals GPT’s. Daarom zal de strategische samenwerking van CoreWeave met Microsoft het AI-landschap positief veranderen.</p>
<p>Toen het in 2017 werd opgericht, was de hoofdfunctie van CoreWeave het gebruik van zijn GPU’s om Ethereum-transacties te valideren. Daarom was het betrokken bij ETH-mining totdat het een ander hiaat ontdekte in de computerindustrie. Daarom verlegde het zijn focus naar het bieden van cloud-GPU-rekeningservice op een betaalbaar maar duurzaam niveau, beginnend in 2019.</p>
<p>Enkele dagen na de aankondiging van de samenwerking met Microsoft heeft CoreWeave zijn Series B financieringsronde uitgebreid waarbij het $200 miljoen heeft veiliggesteld. In totaal heeft het $421 miljoen opgehaald via de financieringsronde van serie B, waar bedrijven zoals Magnetar Capital aan hebben deelgenomen. Nvidia is de belangrijkste investeerder in CoreWeave, dat momenteel gewaardeerd wordt op $2 miljard.</p>
<p>Ondertussen citeerde Businesswire Michael Intrator, de CEO van CoreWeave, toen hij de uitbreiding uitlegde die het bedrijf doet met betrekking tot het leveren van GPU-computingservice. <a href="https://www.businesswire.com/news/home/20230531005132/en/CoreWeave-Secures-200-Million-Series-B-Extension-Bringing-Total-Round-to-421-Million" rel="nofollow noopener noreferrer" target="_blank">Hij zei</a>, “In mijn 25-jarige carrière heb ik nog nooit deel uitgemaakt van een bedrijf dat zo snel groeit. Het is een ongelooflijk moment in de tijd. Vanuit een vraagperspectief, omzet en klantschaal is de groei exponentieel geweest en Magnetar is vanaf het begin een geweldige partner geweest.”<br><img src="https://gimg2.gateimg.com/image/article/16867096531.png" alt=""><br>Microsoft Partners CoreWeave - Binance</p>
<h2 id="h2-De20betrokkenheid20van20Microsoft20bij20AI187204"><a name="De betrokkenheid van Microsoft bij AI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De betrokkenheid van Microsoft bij AI</h2><p>De samenwerking van Microsoft met CoreWeave is niet haar eerste avontuur op het gebied van AI. In het eerste kwartaal van 2023 investeerde het $10 miljoen in OpenAI, een bedrijf dat achter de <a href="https://www.gate.io/live/video/90b1e91dd5e7fb207b1509a809e5b444" target="_blank">AI-gebaseerde chatbot, ChatGPT</a>. In wezen zou de samenwerking met CoreWeave Microsoft in staat moeten stellen om gebruik te maken van de transformerende kracht van kunstmatige intelligentie in haar bedrijfsmodel en haar technologie naar nieuwe grenzen te duwen.</p>
<h2 id="h2-Wat20is20het20belang20van20de20samenwerking20tussen20Microsoft20en20CoreWeave108978"><a name="Wat is het belang van de samenwerking tussen Microsoft en CoreWeave?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het belang van de samenwerking tussen Microsoft en CoreWeave?</h2><p>De samenwerking tussen Microsoft en CoreWeave zal naar verwachting de transformerende kracht van AI laten zien in zowel Web2.0 als Web 3.0. Het laat ook zien dat cryptobedrijven innovaties kunnen brengen die van toepassing zijn op web2-infrastructuur.</p>
<p>Ten tweede zal Microsoft waarschijnlijk nieuwe grenzen bereiken in zijn streven om transformerende producten en diensten te introduceren. Dit komt doordat het nu toegang heeft tot technologie die het in staat stelt om naar nieuwe hoogten te schalen. Ook zal dit naar alle waarschijnlijkheid de gegevensanalyse en machine learning revolutioneren die essentieel zijn voor moderne bedrijven die vertrouwen op innovatie om opkomende problemen op te lossen.</p>
<p>Deze samenwerking toont ook het belang van het integreren van blockchain- en AI-technologieën. Belangrijker nog, dit zal waarschijnlijk veel techbedrijven doen inzien hoe belangrijk de web3-industrie is. En dit zal naar alle waarschijnlijkheid ook de verdere adoptie van blockchaintechnologie in verschillende sectoren bevorderen.</p>
<p><strong>Lees ook: <a href="https://www.gate.io/blog_detail/2064/chatgpt-ai-impacts-healthcare-rising-prices-hit-americans-chinas-redistributive-policies-affect-property-developers" target="_blank">ChatGPT AI heeft invloed op de gezondheidszorg, Stijgende prijzen treffen Amerikanen, China’s herverdelingsbeleid beïnvloedt vastgoedontwikkelaars</a></strong></p>
<h2 id="h2-Hoe20verdien20je20ETH677273"><a name="Hoe verdien je ETH?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe verdien je ETH?</h2><p>Gate.io biedt zijn gebruikers een geweldige <a href="https://www.gate.io/lend-earn" target="_blank">mogelijkheid om ETH te verdienen</a> door middel van staken. Het heeft momenteel een APR van 4,6%, wat concurrentieel is op de markt. De crypto-uitwisseling biedt een handige ETH 2.0 stakingoplossing waar investeerders kleine hoeveelheden van de cryptocurrency kunnen staken.</p>
<p>Om te staken en ETH te verdienen, bezoek <a href="https://www.gate.io/eth2" target="_blank">Gate.io</a> waar u uw investering meteen kunt verwerken. Zodra u daar bent, klikt u op “Nu staken”, zoals aangegeven op het onderstaande diagram.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16867098822.png" alt=""></p>
<p>Er zal een pop-up verschijnen waar u uw ETH-bedrag zult invoeren. Zodra u akkoord gaat met de voorwaarden, bevestigt u uw transactie. ETH-staking is een waardevolle investering, aangezien de prijs van Ether waarschijnlijk in de toekomst zal stijgen.</p>
<p><strong>Lees ook: <a href="https://www.gate.io/blog_detail/2420/gateio-strategy-bot-introduces-ai-optimization-and-neutral-strategies" target="_blank">Gate.io Strategy Bot introduceert AI-optimalisatie en neutrale strategieën</a></strong></p>
<h2 id="h2-Conclusie666884"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Onlangs sloot Microsoft een AI-deal met CoreWeave die mogelijk enkele jaren kan duren. Het AI-rekencontract stelt CoreWeave, de voormalige Ethereum-mijnwerker, in staat om GPU-rekeningservice aan Microsoft te bieden. Analisten geloven dat deze samenwerking andere fintech-bedrijven kan verleiden om de kracht van AI en blockchaintechnologieën te benutten.</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 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 zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>