UG9seWdvbiBndWlkYSBpbCByb3VuZCBkaSBmaW5hbnppYW1lbnRvIGRpIEVNQzogdW5hIG51b3ZhIGVyYSBwZXIgbCdpbm5vdmF6aW9uZSBibG9ja2NoYWluPw==

2024-09-11, 02:59

<p><img src="https://gimg2.gateimg.com/image/article/17260233991692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR896454"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> e Amber Group hanno guidato il round di finanziamento per EMC dove sono stati raccolti 20 milioni di dollari.</p>
<p>EMC svilupperà una blockchain che offrirà servizi DePIN.</p>
<p>L’investimento strategico di <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> in EMC gli consente di espandersi nel settore dell’IA.</p>
<h2 id="h2-Introduzione592328"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il settore blockchain sta evolvendo poiché molti progetti cripto stanno formando partnership e collaborazioni. Alcune di queste aziende utilizzano tali strategie per diversificare le loro operazioni in settori redditizi come l’intelligenza artificiale. Una ragione per cui le aziende cripto si diversificano è la forte concorrenza nel settore. Recentemente, Polygon ha mostrato molto interesse nel diversificare i suoi interessi commerciali nel settore dell’IA.</p>
<h2 id="h2-La20ricerca20di20Polygon20per20la20diversificazione2020evidente20mentre20guida20la20fase20di20finanziamento20EMC327999"><a name="La ricerca di Polygon per la diversificazione è evidente mentre guida la fase di finanziamento EMC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La ricerca di Polygon per la diversificazione è evidente mentre guida la fase di finanziamento EMC</h2><p>Polygon Ventures e Amber Group hanno guidato il round di finanziamento di Edge Matric Chain (EMC). Il round di finanziamento EMC da $20 milioni consentirà ad Edge Matric Chain di sviluppare una blockchain di livello 1 per l’AI al fine di espandere il suo business di elaborazione GPU. Edge Matric Chain, popolarmente conosciuta come EMC, si concentra su applicazioni AI decentralizzate che integrano la blockchain con la potenza di calcolo.</p>
<p>Diversi investitori tra cui One Comma, Cyberrock Venture Fund, Candaq Fintech Group, Kapley Judge, Associated Corporations e Hameem Raees Chowdhury hanno preso parte alla fase di finanziamento. I fondi permetteranno a EMC di ampliare la propria presenza e contributo nel settore delle reti di infrastrutture fisiche decentralizzate. Di fatto, si prevede che la crescita dei settori AI e DePIN contribuirà con oltre 20 trilioni di dollari al PIL globale entro il 2030. Al momento, <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Rendere</a> e Bittensor sono esempi di aziende cripto che sono leader nell’offerta di servizi DePIN.</p>
<h2 id="h2-Edge20Matric20Chain20EMC20per20espandere20i20servizi20DePIN20la20sua20visione20e20missione384711"><a name="Edge Matric Chain (EMC) per espandere i servizi DePIN: la sua visione e missione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Edge Matric Chain (EMC) per espandere i servizi DePIN: la sua visione e missione</h2><p>Edge Matric Chain è un attore chiave nel campo DePIN in quanto si concentra sulla fusione di soluzioni AI decentralizzate con reti di calcolo. L’azienda mira a potenziare l’elaborazione GPU per i progetti di intelligenza artificiale attraverso l’integrazione di applicazioni decentralizzate con le reti di potenza di calcolo. Pertanto, attraverso i suoi servizi di elaborazione GPU, i progetti di intelligenza artificiale avranno accesso alla potenza di calcolo di cui hanno bisogno. Di conseguenza, saranno in grado di integrare vari framework AI e modelli di linguaggio.</p>
<p>La potenza di calcolo renderà più facile per gli sviluppatori costruire applicazioni AI decentralizzate più facilmente che su qualsiasi blockchain esistente. Ad esempio, saranno in grado di costruire e distribuire applicazioni AI ad alta intensità di calcolo come chatbot AI generativi. La blockchain EMC sarà in grado di tokenizzare le risorse di calcolo consentendo la proprietà frazionata delle risorse GPU. La combinazione di asset del mondo reale e liquidità renderà il progetto diverso da quelli presenti sul mercato. <a href="https://earn.emc.network/" rel="nofollow noopener noreferrer" target="_blank">Pubblicando sul suo blog, EMC ha detto</a>“Questi asset di calcolo tokenizzati, supportati da GPU fisiche, sono destinati a vedere un aumento del 160% della domanda a causa dell’accelerazione rapida delle applicazioni di intelligenza artificiale.”</p>
<p>Ha aggiunto: “L’ecosistema EMC introdurrà una nuova classe di asset DeFi che sfrutta le GPU Tensor Core H100 della Nvidia tokenizzate. Questi asset reali (RWAs) saranno tokenizzati e resi disponibili per la proprietà frazionata, consentendo agli utenti di investire e beneficiare dei rendimenti generati dall’outsourcing delle risorse GPU on-chain.”</p>
<p>La blockchain di EMC completerà la sua <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">web3</a> infrastruttura che offre servizi di cloud GPU, archiviazione dei dati e servizi di oracoli. EMC ha chiarito: “Fornendo una soluzione a stack completo, EMC permette agli sviluppatori di costruire e distribuire applicazioni di intelligenza artificiale in modo trasparente, sfruttando i vantaggi della decentralizzazione e della tecnologia blockchain.”</p>
<p><em>Inoltre, la rete EMC supporterà le capacità di cross-chain con altre importanti blockchain come Arbitrum, TON e <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, garantendo l’interoperabilità e sfruttando la liquidità e le basi degli utenti di queste reti consolidate.”</em></p>
<p>È importante notare che la blockchain consentirà agli utenti di affittare la propria potenza di calcolo in eccesso per generare reddito. D’altra parte, i servizi DePIN guideranno molti aspetti della blockchain in futuro. Tom Trowbridge, co-fondatore di Fluence, ha parlato di <a href="https://www.gate.io/learn/articles/depin-track-analysis-the-future-of-decentralized-physical-infrastructure-networks/1344" target="_blank">contributo di DePIN nel settore crittografico</a>. Ha detto: “DePIN è pronto a guidare la prossima ondata di adozione della criptovaluta. I suoi servizi sono facili da capire, consentendo a milioni di persone di partecipare, e diversi progetti DePIN di rilievo sono sull’orlo di assicurarsi importanti clienti e sostanziali entrate…”</p>
<p>Leggi anche: <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Prezzo Polygon</a> previsioni <a href="https://www.gate.io/price-prediction/polygon-matic" target="_blank">dagli esperti di Gate.io</a></p>
<h2 id="h2-Lancio20del20Testnet20e20Mainnet78205"><a name="Lancio del Testnet e Mainnet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lancio del Testnet e Mainnet</h2><p>EMC ha lanciato il suo testnet per valutare la sua innovazione blockchain ad agosto. Aveva un montepremi di $5 milioni che ha attirato molte persone a partecipare. Quel testnet è riuscito a mostrare il suo impatto sull’industria e il futuro della blockchain. Attualmente, il team sta lavorando per completare il mainnet che verrà lanciato più tardi nell’anno. Dopo il lancio della blockchain, gli sviluppatori potranno distribuire le loro applicazioni AI lì.</p>
<h2 id="h2-Investimento20strategico20di20Polygon20in20EMC20i20benefici20derivati525059"><a name="Investimento strategico di Polygon in EMC: i benefici derivati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Investimento strategico di Polygon in EMC: i benefici derivati</h2><p>L’investimento strategico di Polygon in EMC mostra il suo interesse a espandersi nei settori dell’IA e DePIN attraverso collaborazioni tecnologiche. Sulla base delle attuali tendenze degli investimenti, la mossa di <a href="https://www.gate.io/learn/articles/what-is-polygon-matic/865" target="_blank">criptovaluta Polygon</a> consente di crescere e diversificarsi nelle attività legate alla tecnologia blockchain, il che aumenterà anche il suo fatturato. Probabilmente, l’altro vantaggio che la rete Polygon trarrà dall’investimento strategico è l’opportunità di gestire premi e token per le applicazioni DePIN. Polygon funzionerà insieme a EMC come parte della tecnologia finanziaria o della blockchain a scopo generale.</p>
<h2 id="h2-Espansione20di20Polygon20e20sviluppo20di20blockchain586448"><a name="Espansione di Polygon e sviluppo di blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Espansione di Polygon e sviluppo di blockchain</h2><p>Il coinvolgimento di Polygon nella fase di finanziamento EMC non è stata la prima iniziativa di raccolta fondi. Sandeep Nailwal, fondatore di Polygon, insieme a Pantera Capital e Hashkey, ha partecipato alla raccolta di 85 milioni di dollari per Sentient Labs. Sentient, che sarà… <a href="https://www.gate.io/learn/articles/what-is-polygon/73" target="_blank">costruito su Polygon</a>, è una piattaforma di sviluppo di intelligenza artificiale. Sarà un protocollo open source in cui la comunità contribuirà.</p>
<h2 id="h2-Conclusion141694"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Polygon ha preso parte alla raccolta di 20 milioni di dollari per EMC per lo sviluppo di una blockchain che si concentrerà sull’IA e sul DePIN. In precedenza, Nailwal, il fondatore di Polygon, ha partecipato alla raccolta di fondi per Sentient, un protocollo open source per lo sviluppo di modelli e applicazioni di intelligenza artificiale. Le due iniziative mostrano che Polygon sta lavorando duramente per espandersi nel settore dell’IA.</p>
<div class="blog-details-info"><br><div>Autore: Mashell C., Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Il ripostaggio dell'articolo sarà consentito a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>