R2F0ZS5pbyBBTUEgY29uIEVwaUsgUHJvdG9jb2w6IHVuYSBibG9ja2NoYWluIG9yaWVudGF0YSBhbGwnSUEgY2hlIG1pcmEgYSB1bmEgcmV0ZSBkYXRpIEFJIGFwZXJ0YSBlIGNvbGxhYm9yYXRpdmEgYWNjZXNzaWJpbGUgYSB0dXR0aSBuZWxsJ0FJIGluIFdlYjM=

<p><img src="https://gimg2.gateimg.com/image/article/16916481861.jpeg" alt=""><br><strong>Ora: 11 settembre 2021, 10:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con James Lim, CEO di EpiK Protocol nella <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Web Ufficiale: <a href="https://epik-protocol.io/" rel="nofollow noopener noreferrer" target="_blank">https://epik-protocol.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/EpikProtocol" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/EpikProtocol</a></strong><br><strong>Segui EpiK Protocol su <a href="https://twitter.com/EpikProtocol" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/EpikProtocol" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16916484572.jpg" alt=""><br><strong>James Lim - CEO di EpiK Protocol</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio528488"><a name="Domande e risposte da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte da Gate.io</h2><h3 id="h3-Q120Potresti20raccontarci20del20protocollo20EpiK20con20la20sua20specifica20esplorazione20pratica20nellindustria20e20quale2020attualmente20il20progresso20nello20sviluppo186481"><a name="Q1: Potresti raccontarci del protocollo EpiK con la sua specifica esplorazione pratica nell’industria e quale è attualmente il progresso nello sviluppo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti raccontarci del protocollo EpiK con la sua specifica esplorazione pratica nell’industria e quale è attualmente il progresso nello sviluppo?</h3><p><strong>Marmellate</strong>: In una parola, EpiK Protocol è il primo protocollo di archiviazione decentralizzata al mondo per i dati sull’IA.</p>
<p>Attraverso l’integrazione della tecnologia di archiviazione IPFS, del meccanismo di incentivazione dei token e del modello di governance DAO, creiamo una comunità autonoma aperta globale per lavorare insieme a un costo di gestione estremamente basso e produrre continuamente dati di intelligenza artificiale di alta qualità che possono essere costruiti e condivisi congiuntamente.</p>
<p>Il Protocollo EpiK mira a ampliare gli orizzonti dell’IA e ad aprire l’era dell’intelligenza cognitiva.</p>
<p>Attualmente, il Protocollo EpiK ha lanciato con successo la rete principale il 15 agosto 2021.<br><img src="https://gimg2.gateimg.com/image/article/16916484873.jpg" alt=""><br>Nella main-net, EpiK Protocol ha due sistemi di contributo: sistema di etichettatura dei dati AI e sistema di archiviazione dei dati AI.</p>
<p>Nel sistema di etichettatura dei dati AI, gli utenti si uniscono a noi per produrre dati AI di alta qualità. Nel sistema di archiviazione dei dati AI, gli utenti si uniscono a noi per archiviare i dati AI prodotti nel sistema di etichettatura e fornire il servizio di download.<br><img src="https://gimg2.gateimg.com/image/article/16916485094.jpg" alt=""><br>Entro un mese dal lancio della main-net, il sistema di archiviazione dei dati AI è stato costruito molto al di là delle nostre aspettative. Ci sono già 3000 nodi di conoscenza attivi nel sistema di archiviazione.</p>
<p>Questo è incredibile.</p>
<p>D’altra parte, il sistema di etichettatura ha accumulato più di 3000 etichette umane attive giornaliere in tutto il mondo. Queste etichette provengono da 16 paesi e padroneggiano più di 10 lingue.</p>
<p>Benvenuti a unirvi al nostro sistema di etichettatura tramite il download dell’app Knowledge Mainland <a href="https://epikg.com" rel="nofollow noopener noreferrer" target="_blank">https://epikg.com</a>.</p>
<p>Con il lancio del main-net, oltre 330.000 EPK vengono distribuiti quotidianamente ai contributori nel sistema di etichettatura e nel sistema di archiviazione. La velocità di raccolta dei dati AI da parte del Protocollo EpiK verrà drasticamente aumentata, e ci saranno più modi per la comunità di partecipare al Protocollo EpiK e lavorare insieme per creare continuamente un valore reale per l’industria dell’IA e della blockchain.</p>
<h3 id="h3-Q220In20termini20di20archiviazione20distribuita20quale20soluzione20tecnica20specifica2020stata20adottata20dal20protocollo20EpiK572771"><a name="Q2: In termini di archiviazione distribuita, quale soluzione tecnica specifica è stata adottata dal protocollo EpiK?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: In termini di archiviazione distribuita, quale soluzione tecnica specifica è stata adottata dal protocollo EpiK?</h3><p><strong>Marmellate</strong>: La soluzione di storage decentralizzato del protocollo EpiK è stata adattata in base a <a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a> Go lotus di Gate.io.</p>
<p>Abbiamo utilizzato PoRep (Proof-of-Replication) e PoSt (Proofs-of-Spacetime) di <a href="/price/filecoin-fil" target="_blank" class="blog_inner_link">Filecoin</a> per garantire l’equità degli input e output dei dispositivi di archiviazione ed eliminare problemi come gli attacchi di outsourcing.</p>
<p>La differenza è che configurare un nodo minatore nel Protocollo EpiK sarà più facile e più economico rispetto a Filecoin.</p>
<p>Se hai un dispositivo con 8 core, 16 GB di memoria, SSD da 250 GB e larghezza di banda di 5 Mbps o superiore, potresti configurare un nodo minerario nel Protocollo EpiK seguendo questo tutorial. <a href="https://github.com/EpiK-Protocol/go-epik/wiki/How-to-join-Mainnet" rel="nofollow noopener noreferrer" target="_blank">https://github.com/EpiK-Protocol/go-epik/wiki/How-to-join-Mainnet</a></p>
<p>Nel frattempo, abbiamo modificato il meccanismo di penalità e il meccanismo di incentivi del sistema di archiviazione per ridurre il costo di partecipazione delle macchine di archiviazione EpiK, migliorare la decentralizzazione e la sicurezza dei dati in tutta la rete, nonché aumentare significativamente le TPS.</p>
<p>Non preoccuparti di essere punito.</p>
<p>Inoltre, abbiamo aggiunto un meccanismo di incentivi per il sistema di etichettatura, integrando la produzione di dati e lo stoccaggio dei dati in un unico protocollo per evitare che intermediari traggano profitto.</p>
<p>Un’altra innovazione è che abbiamo introdotto il meccanismo Coinbase per EpiK dal <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> sistema tecnologico, in modo che il reddito possa essere automaticamente messo in comune, il che dà indirettamente origine alla prima soluzione tecnologica di mining pool aperto per l’ecosistema di storage decentralizzato.</p>
<p>Se hai solo da 1 a 2 nodi minerari, potresti beneficiare molto da un pool di mining.</p>
<h3 id="h3-Q320Come20verr20costruito20il20knowledge20graph20in20futuro20Quali20sono20i20tuoi20punti20di20forza186778"><a name="Q3: Come verrà costruito il knowledge graph in futuro? Quali sono i tuoi punti di forza?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Come verrà costruito il knowledge graph in futuro? Quali sono i tuoi punti di forza?</h3><p><strong>Marmellate</strong>: Al momento, il protocollo EpiK dispone già di strumenti che mettono in fila gli esperti di dominio, i cacciatori di taglie e i nodi di conoscenza.<br>Il lavoro principale degli esperti di dominio è quello di definire lo schema del grafo della conoscenza di diversi domini e verificare la qualità dei dati.</p>
<p>Il compito principale dei bounty hunter è di aiutare gli esperti di dominio a completare un lavoro specifico di raccolta e accettazione dei dati.</p>
<p>Il lavoro principale dei nodi di conoscenza è quello di memorizzare i dati del grafo di conoscenza e fornire accesso a pagamento ad esso per gli utenti esterni.</p>
<p>Questi strumenti ci consentono di costruire per la prima volta un sistema operativo per l’economia della condivisione dei dati, con un alto grado di fiducia reciproca tra tutte le parti, in modo che i contributori di dati possano continuare a godere dei benefici futuri realizzati dei dati.<br><img src="https://gimg2.gateimg.com/image/article/16916485255.jpg" alt=""><br>Questo meccanismo ha facilmente ottenuto un vantaggio in termini di costi 10 volte superiore rispetto all’etichettatura tradizionale dei dati nei nostri test nel mondo reale. La significativa riduzione dei costi fornirà una fonte continua di energia per lo sviluppo futuro dell’IA.</p>
<p>Come dicono i migliori esperti di IA, nel processo di costruzione di razzi AI, gli algoritmi di rete neurale sono i motori del razzo mentre i dati sono il carburante.</p>
<p>È molto bello che utenti con diverse esperienze lavorino insieme per produrre dati di alta qualità per rendere l’IA più intelligente in modo decentralizzato.</p>
<p>Crediamo che il Protocollo EpiK giocherà un ruolo enorme nell’implementazione della tecnologia AI in futuro.</p>
<h3 id="h3-Q420Cosa20vedi20nel20futuro20del20mercato20delle20criptovalute20e20come20pensi20che20la20tua20piattaforma20verr20riconosciuta20mentre20lo20spazio20continua20a20evolversi502743"><a name="Q4: Cosa vedi nel futuro del mercato delle criptovalute e come pensi che la tua piattaforma verrà riconosciuta mentre lo spazio continua a evolversi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Cosa vedi nel futuro del mercato delle criptovalute e come pensi che la tua piattaforma verrà riconosciuta mentre lo spazio continua a evolversi?</h3><p><strong>Marmellate</strong>: A mio parere, l’attività economica umana è una grande rete in cui gli individui sono i nodi e le transazioni sono i collegamenti.</p>
<p>Gli affari ci fanno lavorare insieme per migliorare la velocità di generazione e trasferimento del valore in questa rete. La tecnologia dell’AI è brava a migliorare l’efficienza della generazione di valore e la blockchain è brava a ridurre il costo del trasferimento di valore.</p>
<p>Crediamo che ci saranno sicuramente progetti che combinano i vantaggi dell’IA e della blockchain per fare una grande differenza in questo futuro.</p>
<p>Speriamo che EpiK Protocol sia uno di loro e anche il capo di loro.</p>
<p>L’IA è composta da dati, algoritmi e potenza di calcolo. Pensiamo che l’etichettatura dei dati sia la migliore situazione in cui la blockchain potrebbe svolgere un ruolo importante ORA.</p>
<p>Ecco perché abbiamo avviato il Protocollo EpiK l’anno scorso.</p>
<h3 id="h3-Q520Il20vostro20progetto20prevede20di20operare20in20modo20pubblico20e20trasparente20il20che2020positivo20ma20quanto20coinvolta20sar20la20comunit20allinterno20del20progetto20per20prendere20le20migliori20decisioni20e20quindi20rafforzare20lecosistema662890"><a name="Q5: Il vostro progetto prevede di operare in modo pubblico e trasparente, il che è positivo, ma quanto coinvolta sarà la comunità all’interno del progetto per prendere le migliori decisioni e quindi rafforzare l’ecosistema?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Il vostro progetto prevede di operare in modo pubblico e trasparente, il che è positivo, ma quanto coinvolta sarà la comunità all’interno del progetto per prendere le migliori decisioni e quindi rafforzare l’ecosistema?</h3><p>Crediamo che nessuno possa prendere sempre le migliori decisioni nell’industria blockchain tranne Satoshi Nakamoto che è scomparso.</p>
<p>All’inizio del protocollo EpiK, avevamo un piano per costruire l’EpiK DAO al fine di regolare dinamicamente il modello economico e stabilire una governance credibile.</p>
<p>Abbiamo recentemente rilasciato il nostro whitepaper sulla governance per presentare l’EpiK DAO. E per nostra sorpresa di recente, c’è effettivamente un’assenza di DAO nel dominio odierno dello storage decentralizzato.</p>
<p>EpiK DAO potrebbe essere il primo DAO in un ecosistema di archiviazione decentralizzato.</p>
<p>Secondo la nostra roadmap, EpiK DAO verrà integrato nella nostra main-net nel quarto trimestre del 2021. Prima che EpiK DAO prenda vita, rilasceremo EpiK PreDAO questa settimana per prendere decisioni importanti nella nostra comunità.</p>
<h3 id="h3-Q620Il20reddito2020un20aspetto20importante20per20tutti20i20progetti20per20sopravvivere20e20mantenere20il20progettolazienda20in20funzione20Qual2020il20vostro20modo20di20generare20profittoreddito20Qual2020il20modello20di20reddito803779"><a name="Q6: Il reddito è un aspetto importante per tutti i progetti per sopravvivere e mantenere il progetto/l’azienda in funzione. Qual è il vostro modo di generare profitto/reddito? Qual è il modello di reddito?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Il reddito è un aspetto importante per tutti i progetti per sopravvivere e mantenere il progetto/l’azienda in funzione. Qual è il vostro modo di generare profitto/reddito? Qual è il modello di reddito?</h3><p><strong>Marmellate</strong>: Il token nativo è $EPK nella rete del protocollo EpiK.</p>
<p>A proposito, $EPK potrebbe essere scambiato in Gate.</p>
<p>Il modello di economia dei token del Protocollo EpiK è progettato basandosi sul principio che ogni giocatore nell’ecosistema possa lavorare insieme per promuovere la crescita complessiva del progetto massimizzando nel contempo i propri benefici.</p>
<p>Nell’ecosistema EpiK ci sono diversi ruoli: esperti di dominio, cacciatori di taglie (utenti dell’app Knowledge Mainland), nodi di conoscenza e gateway di conoscenza (aziende di intelligenza artificiale). Ognuno di loro svolge i propri compiti e forma un ciclo chiuso ecologico completo.</p>
<p>Tra di essi, gli esperti del settore, i cacciatori di taglie (utenti dell’app Mainland Knowledge) sono responsabili della produzione di dati AI; i nodi di conoscenza sono responsabili dello stoccaggio dei dati; e le porte di conoscenza sono responsabili dell’indicizzazione dei dati.</p>
<p>Gli esperti del settore, i cacciatori di taglie e i nodi di conoscenza saranno premiati in base al loro contributo.</p>
<p>I gateway di conoscenza devono impegnarsi a utilizzare $EPK per accedere ai dati nella rete del Protocollo EpiK.</p>
<p>1 EPK significa 10 Mib di dati.</p>
<p>Nel Main-net del protocollo EpiK, verranno prodotti 332.000 EPK al giorno. Il 75% di essi verrà dato ai nodi di conoscenza, il 9% agli esperti di dominio, l’1% agli utenti votanti e il 15% ai cacciatori di taglie.</p>
<p>Attualmente, i nodi di conoscenza potrebbero recuperare il loro capitale in 90 giorni. Gli utenti che votano possono ottenere un rendimento annualizzato del 190%. Ogni cacciatore di taglie potrebbe ottenere 2-3 EPK ($1,3 per EPK) in circa 1-2 ore al giorno.</p>
<p>Nel protocollo EpiK, lavoriamo insieme per produrre dati AI di alta qualità e poi vendiamo dati alle aziende di AI. E la verità è che quasi ogni azienda di AI ha fame di dati.</p>
<h3 id="h3-Q720Gli20utenti20non20cripto20sono20molto20importanti20per20ladozione20mainstream20Come20pensi20di20attirare20gli20utenti20non20cripto20verso20il20tuo20progetto20Ci20sono20delle20partnership20imminenti20che20porteranno20utenti20non20cripto20e20casi20duso20reali32109"><a name="Q7: Gli utenti non cripto sono molto importanti per l’adozione mainstream. Come pensi di attirare gli utenti non cripto verso il tuo progetto? Ci sono delle partnership imminenti che porteranno utenti non cripto e casi d’uso reali?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Gli utenti non cripto sono molto importanti per l’adozione mainstream. Come pensi di attirare gli utenti non cripto verso il tuo progetto? Ci sono delle partnership imminenti che porteranno utenti non cripto e casi d’uso reali?</h3><p><strong>Marmellate</strong>: È una buona domanda per ogni progetto blockchain.</p>
<p>In realtà, più della metà dei cacciatori di taglie nella rete del Protocollo EpiK non sono utenti di criptovalute. Provengono dall’industria tradizionale dell’etichettatura dei dati. Il Protocollo EpiK è più popolare nell’ambito dell’IA che nell’industria blockchain. Abbiamo molti partner nell’industria dell’IA. Sono tutti assetati di dati di alta qualità. Li puoi trovare sul nostro sito web: <a href="https://epik-protocol.io" rel="nofollow noopener noreferrer" target="_blank">https://epik-protocol.io</a> .</p>
<p>Si prega di seguire i nostri social media per ottenere le ultime notizie.<br>Twitter: <a href="https://twitter.com/EpikProtocol" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/EpikProtocol</a><br>Medio: <a href="https://epikprotocol.medium.com/" rel="nofollow noopener noreferrer" target="_blank">https://epikprotocol.medium.com/</a></p>
<h3 id="h3-Q820Hai20qualche20piano20per20aggiungere20NFT20al20tuo20ecosistema20poich2020largomento20pi20caldo20nello20spazio20cripto850556"><a name="Q8: Hai qualche piano per aggiungere NFT al tuo ecosistema poiché è l’argomento più caldo nello spazio cripto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q8: Hai qualche piano per aggiungere NFT al tuo ecosistema poiché è l’argomento più caldo nello spazio cripto?</h3><p><strong>Marmellate</strong>: Certo. La combinazione di NFT e Knowledge Mainland è perfetta. L’intenzione originale di Knowledge Mainland era quella di gamificare il lavoro di annotazione dei dati e di iniziare a costruire il mondo nel gioco intorno a elementi di <a href="/price/terra-luna" target="_blank" class="blog_inner_link">terra</a> e edifici (che è ciò su cui si sta concentrando il concetto di ‘Metaverse’ adesso).</p>
<p>Knowledge Mainland di per sé è già un gioco Play-to-Earn significativo, non solo un gioco per passare il tempo. Abbiamo recentemente pubblicato la Wave I del Programma di sovvenzioni del Protocollo EpiK. Se avete idee fantastiche per rendere Knowledge Mainland più divertente tramite giochi basati su NFT, vi preghiamo di presentare la vostra candidatura per le nostre sovvenzioni tramite questo <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a>. <a href="https://www.epik-protocol.io/grants" rel="nofollow noopener noreferrer" target="_blank">https://www.epik-protocol.io/grants</a></p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti relativi a questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione Gate.io sia referenziato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>