RGUgb3Brb21zdCB2YW4gQ2hpbmVzZSBBSS11bmljb3JucyBlbiBlZW4gc3RyaWpkIG1ldCBPcGVuQUk=

2024-05-15, 06:13

<p><img src="https://gimg2.gateimg.com/image/article/1715753397rdzz.jpeg" alt=""></p>
<h2 id="h2-TL20DR805405"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Zhapu Ai, Moonshot AI, 01.AI en MiniMax zijn enkele van de toonaangevende AI-startups in China.</p>
<p>Baidu, Alibaba en Tencent hebben financiële steun verleend aan AI-startups in China.</p>
<p>De geopolitieke spanningen tussen China en de Verenigde Staten kunnen een negatieve invloed hebben op de groei van de Chinese AI-sector.</p>
<h2 id="h2-Introductie465187"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De kunstmatige intelligentie-hype begon toen ChatGPT in 2023 werd gelanceerd. Daarna waagden veel andere grote bedrijven zoals Meta zich op de markt. Echter, in 2023 leek China achter te lopen op andere toonaangevende economieën zoals de Verenigde Staten wat betreft de adoptie van AI-technologieën. De huidige trend geeft echter aan dat China momenteel zeer actief is op het gebied van AI-unicorns. Dit artikel behandelt de voortgang van China in het bevorderen van AI-technologie.</p>
<h2 id="h2-De20opkomst20van20Chinese20AIunicorns807990"><a name="De opkomst van Chinese AI-unicorns" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De opkomst van Chinese AI-unicorns</h2><p>Veel Chinese AI-start-ups zijn bezig hun inspanningen op te voeren om gelijke tred te houden met de ontwikkelingen op het gebied van AI in andere landen, met name de Verenigde Staten. Wat hun inspanningen bijzonder maakt, is het feit dat ChatGPT, de toonaangevende leverancier van generatieve AI-diensten, momenteel niet beschikbaar is in China. Dit betekent dat er veel vraag is naar AI-diensten in dat land.</p>
<p>Vier toonaangevende Chinese Generative Artificial Intelligence-unicorns hebben elk een waardering van meer dan $ 1 miljard, wat een aanzienlijke vooruitgang laat zien in de sector. Wereldwijd blijft OpenAI - het in San Francisco gevestigde AI-bedrijf - echter de leider met een waardering van meer dan $ 80 miljard. Het feit dat de AI-chatbot van OpenAI, ChatGPT, niet beschikbaar is in China, toont de betekenis van de felle concurrentie onder de toonaangevende Chinese generatieve AI-bedrijven.</p>
<p>Ondanks dat China achterloopt op de Verenigde Staten op het gebied van generatieve AI-technologie, blijft het een sterke hub voor technologische innovatie, met meer dan 369 eenhoorns. Opvallend is dat meer dan 25% van de Chinese eenhoorns actief is in kunstmatige intelligentie (AI) en gerelateerde sectoren, zoals de halfgeleiderproductie-industrie.</p>
<p>Vergeleken met de andere 15 sectoren heeft de AI-industrie in China het hoogste aantal eenhoorns, wat de grote inspanning laat zien die het land doet om te investeren in de AI-sector. Volgens de <a href="https://www.hurun.net/en-US/Info/Detail?num=9K1G2SK5X7CX" rel="nofollow noopener noreferrer" target="_blank">Wereldwijde Eenhoorn Index</a>, AI-eenhorens in China hebben een gemiddelde waardering van US$6,57 miljard. Bovendien vertegenwoordigen de AI-startups in China 14,1% van de investeringen die de Eenhoorns hebben gedaan van de 369 eenhoorns.</p>
<p>Over het algemeen loopt China echter nog steeds achter op de Verenigde Staten. Bijvoorbeeld, in de telling van vorig jaar had de Verenigde Staten 700 eenhoorns, terwijl China er 340 had. Dit is in verhouding tot de wereldwijde telling van 1.453 eenhoorns.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/crypto-unicorns-game-guide/1598" target="_blank">Crypto Unicorns Game Gids: Hoe te spelen en verdienen</a></p>
<h2 id="h2-Lokale20investeerders20ondersteunen20startups20in20China207415"><a name="Lokale investeerders ondersteunen startups in China" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lokale investeerders ondersteunen startups in China</h2><p>Het interessante is dat Big Tech-bedrijven zoals Tencent Holdings, Alibaba en Baidu de meeste toonaangevende AI-unicorns hebben geïncubeerd. Ondanks het feit dat meer dan 70% van de 369 Chinese unicorns financiële steun kreeg van buitenlandse investeerders, ondersteunden gevestigde lokale techbedrijven, waaronder HongShan, Citic Capital en Tencent, veel van deze bedrijven.</p>
<p>Alibaba, de e-commerce gigant, heeft bijvoorbeeld drie ondernemingen in de AI-ruimte gesteund, waaronder 01.AI en Baichuan. Tencent heeft ook geïnvesteerd in verschillende ontwikkelingsbedrijven voor AI-technologie, zoals Zhipu, van de Tsinghua Universiteit.</p>
<h2 id="h2-Leidend20in20de20branche20Zhipu20AI20en20Moonshot20AI714113"><a name="Leidend in de branche: Zhipu AI en Moonshot AI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Leidend in de branche: Zhipu AI en Moonshot AI</h2><p>De toonaangevende Chinese startups die zich wagen aan generatieve kunstmatige intelligentie zijn onder meer Zhipu AI, MiniMax, Moonshot AI en 01.ai. Dit zijn ook voorbeelden van Chinese venture capital unicorns die financiële steun hebben ontvangen van lokale techbedrijven zoals Baidu. In totaal hebben deze tech-startups in het eerste kwartaal van 2024 meer dan Rmb14,3 miljard ($2 miljard) opgehaald om hun activiteiten uit te breiden.</p>
<p>Evenzo zijn in totaal 262 op AI gerichte start-ups sterke alternatieven voor ChatGPT voor de Chinese markt. Hun sterke concurrentie voor OpenAI kan zich uitbreiden buiten de Chinese grenzen. Laten we eens kort kijken naar de activiteiten van een paar techbedrijven die zich richten op investeringen in kunstmatige intelligentie in China.</p>
<p><strong>Zhapu AI</strong>: Op basis van het aantal werknemers is Zhapu AI uitgegroeid tot de grootste AI-startup in China. Met een waardering van meer dan Rmb18bn ($2.5bn) heeft Zhapu meer dan 800 werknemers. Zoals eerder aangegeven wordt dit AI-bedrijf ondersteund door toonaangevende technologiebedrijven, waaronder Alibaba Cloud, Tencent en Xiaomi. Als gevolg hiervan heeft de Alibaba Tencent AI-investering Zhapu’s GLM-model geholpen om de op drie na grootste speler te worden met een groot marktaandeel op het gebied van AI in China.</p>
<p><strong>Moonshot</strong>: Moonshot, met een waardering van meer dan $2,5 miljard, richt zich op studenten en kantoormedewerkers die digitale assistenten gebruiken bij het uitvoeren van hun taken. Bijvoorbeeld, ze willen mogelijk teksten samenvatten om het gemakkelijker te begrijpen of zoekresultaten te optimaliseren. Alleen al in maart had Kimi, de AI-chatbot van Moonshot, meer dan 12 miljoen bezoeken.</p>
<h2 id="h2-De20gaming20en20productiviteitssectoren20MiniMax20en2001ai875591"><a name="De gaming- en productiviteitssectoren: MiniMax en 01.ai" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De gaming- en productiviteitssectoren: MiniMax en 01.ai</h2><p>Enkele van de belangrijkste AI-startups zijn MiniMax, een in Shanghai gevestigd bedrijf en 01.ai dat zich richt op productiviteit. MiniMax wordt gewaardeerd op $2,5 miljard terwijl 01.AI een waardering heeft van $1,2 miljard.</p>
<p><strong>MiniMax</strong>: MiniMax bevindt zich in de gamingsector met zijn op anime geïnspireerde AI-personages, die gebruikers betrekken. De avatars interacteren met de gebruikers en genereren verschillende reacties op basis van bestaande scenario’s. De app van MiniMax, Glow, stelt gebruikers in staat om virtuele personages te creëren waarmee ze kunnen chatten.</p>
<p><strong>01. AI</strong>: 01.AI maakt gebruik van open-source AI-modellen die op maat zijn gemaakt voor de Chinese markt. Gebouwd op Meta’s gratis aan te passen Lama-architectuur, presteert 01.AI’s Yi - een reeks open-sourcemodellen - goed op het gebied van coderen, redeneren, leesvaardigheid en wiskunde.</p>
<p>Lees ook: <a href="https://www.gate.io/post/CryptoNews_/status/5619305" target="_blank">AI Voorspelt dat China High-Energy Blockchains zal Verbieden</a></p>
<h2 id="h2-Het20bredere20Chinese20AIlandschap498994"><a name="Het bredere Chinese AI-landschap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het bredere Chinese AI-landschap</h2><p>De generatieve <a href="https://www.gate.io/learn/articles/the-combination-of-ai-and-blockchain-and-related-legal-risks/2273" target="_blank">AI evenals de blockchain en cryptocurrency</a> In 2023 raakten de sectoren in China verhit na de bekendmaking van OpenAI en andere Amerikaanse AI-bedrijven over hun AI-modellen en toekomstperspectieven. Als reactie ontwikkelden toonaangevende Chinese techreuzen, waaronder Alibaba, Tencent en Baidu, hun LLM’s.</p>
<p>Over het algemeen is er een hoge AI-adoptie in verschillende sectoren van de Chinese economie, waaronder de high-tech, financiële en retailsectoren. Zo zijn er veel AI-toepassingen voor de dienstverlenende sector waarmee bedrijven op een zinvolle manier kunnen communiceren met klanten, waardoor loyaliteit wordt bevorderd en veel inkomsten worden gegenereerd.</p>
<p>In de zeer nabije toekomst kunnen Chinese eenhoorns aanzienlijk bijdragen aan de transport-, logistiek- en auto-industrie. Ze kunnen ook helpen de productiviteit te verhogen in bedrijfssoftware en de ontwikkeling van gezondheidszorgfaciliteiten. Bijvoorbeeld, AI zal een belangrijke rol spelen in zelfrijdende voertuigen en het voorkomen van verkeersonglen.</p>
<h2 id="h2-Uitdagingen20waar20Chinese20AIunicorns20mogelijk20mee20te20maken20krijgen808706"><a name="Uitdagingen waar Chinese AI-unicorns mogelijk mee te maken krijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Uitdagingen waar Chinese AI-unicorns mogelijk mee te maken krijgen</h2><p>Geopolitieke spanningen zullen naar verwachting van invloed zijn op de prestaties van Chinese AI-unicorns en de blockchain- en cryptocurrencysectoren in China. Bijvoorbeeld, de grootste geopolitieke spanning die AI-technologie zou beïnvloeden, zou het tekort aan essentiële onderdelen zijn die meestal uit ontwikkelde landen zoals de Verenigde Staten komen.</p>
<p>Bijvoorbeeld, onlangs heeft de Amerikaanse regering, onder leiding van president Joe Biden, de verkoop van Nvidia Corp’s geavanceerde AI-halfgeleiders aan Chinese klanten verboden, omdat zij beweert dat China ze kan gebruiken om AI-modellen voor militaire toepassingen te trainen. Daardoor kan het tekort aan essentiële onderdelen veel druk uitoefenen op de AI- en halfgeleidersectoren in China. Nog erger is dat in de VS gevestigde productiebedrijven mogelijk stoppen met investeren in gevoelige technologieën in China die belangrijk zijn voor de groei van de AI-sector.</p>
<p>Ten tweede zal de geopolitieke spanning tussen China en de Verenigde Staten de inzamelingsinspanningen van Chinese tech-startups belemmeren. Bijvoorbeeld, de Amerikaanse handels- en investeringsbeperkende maatregelen kunnen bijvoorbeeld voorkomen dat Amerikaanse durfkapitalisten financiering verstrekken aan Chinese AI-eenhorens, wat hun potentieel kan beïnvloeden. Zo kan bijvoorbeeld het tekort aan vitale onderdelen de groei van Moonshot AI vertragen en de uitbreiding van MiniMax Gaming AI beperken.</p>
<h2 id="h2-Conclusie710713"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De AI-sector van China ontwikkelt zich snel, omdat er jaarlijks miljarden dollars naar de industrie worden geleid. Verschillende toonaangevende AI-unicorns in China hebben bijvoorbeeld waarderingen van meer dan $1 miljard elk. Zhipu AI, 01.AI, Moonshot AI en MiniMax zijn voorbeelden van grote AI-bedrijven in China. Het goede is dat grote techbedrijven zoals Alibaba, Tencent, Baidu en Xiaomi enkele van deze AI-startups in China hebben gefinancierd.</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 mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>