Z2F0ZUxpdmUgQU1BIFJlY2FwLU9yaWdpblRyYWls

2024-05-30, 11:20

<p><img src="https://gimg2.gateimg.com/image/article/1717067850traiblog.jpeg" alt=""></p>
<h2 id="h2-Q120Cos20OriginTrail243542"><a name="Q1: Cos’è OriginTrail?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Cos’è OriginTrail?</h2><p>OriginTrail è un ecosistema che costruisce un Internet verificabile per l’AI, fornendo un quadro inclusivo che affronta le sfide del mondo nell’era dell’AI, come allucinazioni, pregiudizi e collasso del modello, garantendo la provenienza e la verificabilità dei dati utilizzati dai sistemi AI. OriginTrail è utilizzato da leader globali come British Standards Institution, Swiss Federal Railways, Supplier Compliance Audit Network (SCAN), che rappresenta oltre il 40% delle importazioni degli Stati Uniti e diversi consorzi finanziati dall’Unione europea, tra gli altri. Consigliato dal vincitore del premio Turing Dr. Bob Metcalfe, famoso per la sua legge degli effetti di rete, il team di Trace Labs (sviluppatori principali di OriginTrail) svolge un ruolo cruciale nella promozione di un’AI più inclusiva, trasparente e decentralizzata.</p>
<h2 id="h2-Q220Quali20sono20i20casi20duso20del20mondo20reale20di20OriginTrail386246"><a name="Q2: Quali sono i casi d’uso del mondo reale di OriginTrail?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Quali sono i casi d’uso del mondo reale di OriginTrail?</h2><p>Inizialmente adottata nelle catene di approvvigionamento globali per fornire un hub di condivisione dati affidabile, la tecnologia di OriginTrail è sempre più vitale in vari settori, tra cui la tokenizzazione di asset, costruzioni, assistenza sanitaria, il metaverso e altro ancora, grazie alla sua capacità di autenticare e proteggere le informazioni.</p>
<p>(1)Nel settore della supply chain, BSI e SCAN stanno utilizzando OriginTrail per garantire l’integrità delle verifiche di sicurezza per alcuni dei più grandi importatori statunitensi.</p>
<p>(2) BSI sta anche sfruttando la tecnologia OriginTrail per facilitare il <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> di beni attraverso i confini del Regno Unito.</p>
<p>(3)Le Ferrovie Federali Svizzere utilizzano OriginTrail per garantire la sicurezza dei viaggi in treno, monitorando ogni pezzo di materiale ferroviario.</p>
<p>(4)In campo sanitario, OriginTrail viene utilizzato per garantire che i medicinali donati raggiungano i pazienti previsti, anche in ambienti complessi.</p>
<p>(5)Nella costruzione, la tecnologia OriginTrail è utilizzata per costruire una base di conoscenze affidabile con l’obiettivo di migliorare l’efficienza, ridurre gli errori e aumentare la trasparenza e la fiducia, portando in ultima analisi a progetti di costruzione più sostenibili.</p>
<p>(6) Nel metaverso, OriginTrail è integrato con Traverse, un progetto di narrazione che utilizza Graph NFT per offrire un’esperienza di narrazione coinvolgente e senza precedenti.</p>
<h2 id="h2-Q320Ultime20innovazioni20nello20spazio20dellIA114594"><a name="Q3: Ultime innovazioni nello spazio dell’IA?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Ultime innovazioni nello spazio dell’IA?</h2><p>Il team Trace Labs (sviluppatori principali di OriginTrail) ha presentato ChatDKG, un’Intelligenza Artificiale veramente aperta, che guida le sinergie nel panorama delle soluzioni di AI per affrontare le allucinazioni, il bias e il collasso del modello poiché non dovrebbe esserci alcun compromesso nella progettazione delle soluzioni di AI quando si tratta di proprietà dei dati, provenienza delle informazioni, verificabilità delle informazioni o bias che includerebbero qualsiasi approccio di censura per design. Il rischio di questa rivoluzione che non si dispiega in modo inclusivo è una minaccia sociale nel creare un monopolio sull’AI.</p>
<p>Il team ha quindi introdotto un modo efficace di stabilire un nuovo paradigma, utilizzando un framework di generazione potenziato da recupero decentralizzato (dRAG). dRAG avanza il modello RAG organizzando le fonti esterne in un grafo di conoscenza decentralizzato (DKG) e introducendo incentivi per far crescere una rete globale e crowdsourced di conoscenza resa disponibile per l’uso dei modelli di intelligenza artificiale. Il framework dRAG consente un sistema ibrido e decentralizzato di intelligenza artificiale che unisce metodologie di intelligenza artificiale neurali (ad esempio LLM) e simboliche (ad esempio Knowledge Graph).</p>
<p>A differenza dell’utilizzo di un approccio AI neurale basato esclusivamente sulla probabilità, l’approccio AI simbolico lo potenzia con la forza dei Knowledge Graphs, introducendo un componente più deterministico. Per sfruttare uno sviluppo armonioso tra i fondamenti di <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> e i sistemi AI rapidamente implementati, l’approccio consiste nell’integrare le tecnologie di base di Web3 come il Decentralized Knowledge Graph (DKG) di OriginTrail e i sistemi AI (OpenAI, Gemini, Microsoft Co-pilot, Grok di xAI e altri). Possiamo realizzare il potenziale di un’AI affidabile creando una Verifiable Internet for AI fondata su principi di neutralità, inclusività e usabilità, garantendo agli utenti la libertà di scelta con un framework di AI multimodale e multimo-dello.</p>
<h2 id="h2-Q420Possibili20integrazioni20con20ChatDKG159906"><a name="Q4: Possibili integrazioni con ChatDKG?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Possibili integrazioni con ChatDKG?</h2><p>Le soluzioni AI centralizzate e globalmente più adottate come Google Gemini, OpenAI, xAI, Perplexity offrono un immenso valore per una serie di casi d’uso. Sfruttando Origin Trails dRAG - nome del marchio ChatDKG.ai, possono migliorare i loro punti deboli sfruttando la sinergia tra AI neuro-simbolica, proprietà dei dati e migliori prestazioni a costo. Pertanto, ChatDKG.ai non si sta confrontando con alcuna soluzione AI consolidata, ma piuttosto conferisce potere agli utenti per migliorarle con il suo dRAG, guidando la verificabilità delle conoscenze, l’efficienza dei costi, la sovranità degli utenti nel possesso dei loro dati e la libertà di scelta del modello AI.</p>
<p>La natura open source e senza permessi di OriginTrail DKG consente l’inclusività e la neutralità, offrendo agli utenti un enorme livello di libertà su tutti i livelli: scegliere modelli di intelligenza artificiale abilitati dalla portabilità dei dati DKG, scegliere fonti di conoscenza scopribili in DKG e selezionare servizi di intelligenza artificiale, centralizzati o decentralizzati su diverse blockchain.</p>
<p>Gli stessi principi si applicano agli agenti di intelligenza artificiale, ai motori di ricerca e a una crescente varietà di servizi di intelligenza artificiale che si integrano in ogni strumento esistente - sfruttando dRAG, consentiranno la libertà di scelta dell’utente, l’autonomia e la fiducia dell’IA, il tutto sfruttando gli effetti di rete attraverso la connettività.</p>
<h2 id="h2-Q520Roadmap2020Cosa20succeder20dopo904473"><a name="Q5: Roadmap - Cosa succederà dopo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Roadmap - Cosa succederà dopo?</h2><p>Il prossimo aggiornamento V8 del Grafo della Conoscenza Decentralizzato (DKG) rappresenta un significativo progresso nell’Intelligenza Artificiale Decentralizzata, basandosi sui successi delle precedenti innovazioni introdotte da V6. Il DKG V6 ha materializzato la conoscenza come una nuova classe di attività, con i suoi Asset di Conoscenza pronti per l’AI che preparano il terreno per applicazioni avanzate di AI nei domini degli asset del mondo reale (RWAs), della scienza decentralizzata (DeSci), dell’industria 4.0 e altro ancora.</p>
<p>Andando avanti, DKG V8 introduce una crescita autonoma DKG e aumenta significativamente la scalabilità. Con questo, il Decentralized Retri Augmented Generation (dRAG) diventa un quadro fondamentale instillato nel DKG V8, avanzando significativamente una serie di applicazioni di grandi modelli linguistici (LLM).</p>
<p>DKG V8 è stato progettato per guidare la prossima generazione di intelligenza artificiale attraverso contenuti multi-modali, che sono fondamentali per un ecosistema di intelligenza artificiale diversificato e robusto. L’integrazione di dRAG e altre funzionalità di intelligenza artificiale decentralizzata consente una maggiore verificabilità e sicurezza nell’applicazione delle tecnologie di intelligenza artificiale, affrontando sfide come la disinformazione, il bias dei dati e il collasso del modello.</p>
<p>L’aggiornamento della roadmap DKG V8 si concentra su catalizzatori progettati per avviare e accelerare questi sviluppi, tra cui processi avanzati di mining della conoscenza, integrazione attraverso più ecosistemi blockchain e miglioramenti della scalabilità volti a sostenere una crescita espansiva degli asset di conoscenza. Queste iniziative garantiscono che DKG V8 non solo estenda i suoi effetti di rete fondamentali, ma rafforzi anche la sua posizione come fondamento dei futuri sviluppi dell’IA.</p>
<div class="blog-details-info"><br><div>Autore: <strong>GateLive</strong>, Team 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. Sarà consentito il ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>