T3BlbkFJIHByZXNlbnRhIENoYXRHUFQgU2VhcmNoOiBsJ2FsYmEgZGVsbCdJQSBhdXRvbm9tYSBuZWwgMjAyNQ==

2024-11-12, 07:41

<p><img src="https://gimg2.gateimg.com/image/article/17313970141692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR253295"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>OpenAI ha lanciato il suo strumento di ricerca integrato con ChatGPT.</p>
<p>Google, Perplexity e Bing di Microsoft sono alcuni dei concorrenti del motore di ricerca ChatGPT.</p>
<p>Lo strumento di ricerca OpenAI analizza i dati in tempo reale, consentendo agli utenti di ottenere gli aggiornamenti delle ultime informazioni.</p>
<h2 id="h2-Introduzione880743"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’intelligenza artificiale continua a trasformare la vita delle persone in molti modi. È diventata un componente importante nel settore della ricerca dei dati. Ad esempio, ci sono molti strumenti di ricerca alimentati dall’IA che rendono accessibili informazioni essenziali a molte persone. OpenAI è l’ultima azienda a lanciare il suo strumento di ricerca basato sull’IA. Tuttavia, mira a migliorarlo e rendere l’infrastruttura più accessibile a molte persone di quanto non lo sia attualmente.</p>
<p>Ultime notizie: <a href="https://www.gate.io/blog/4600/openai-s-funding-milestone-triggers-unexpected-downturn-for-ai-cryptos-tao-and-fet" target="_blank">Il raggiungimento del traguardo di finanziamento di OpenAI provoca un’improvvisa flessione per i criptovalori dell’IA TAO e FET</a></p>
<h2 id="h2-Un20nuovo20strumento20di20ricerca20basato20su20AI20la20funzione20di20ricerca20di20ChatGPT20di20OpenAI949592"><a name="Un nuovo strumento di ricerca basato su AI: la funzione di ricerca di ChatGPT di OpenAI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un nuovo strumento di ricerca basato su AI: la funzione di ricerca di ChatGPT di OpenAI</h2><p>Il 31 ottobre OpenAI ha annunciato il lancio della sua funzione di ricerca all’interno di ChatGPT. Questo sviluppo lo rende uno dei più grandi concorrenti di Google, Perplexity e Bing di Microsoft. Il suo nuovo strumento consentirà al suo chatbot ChatGPT di esaminare il web e ottenere risposte a varie domande. La funzione consente anche agli utenti web di ottenere risposte alle loro domande da varie fonti. La portata delle informazioni che gli utenti ottengono è ampia, dalle previsioni del tempo alle notizie di tendenza. Questo perché ottiene i dati da fornitori di notizie globali e altre fonti di informazione.</p>
<p>In passato, ChatGPT aveva un limite di conoscenza fisso, il che significava che le risposte alle domande conversazionali provenivano da un periodo specifico. Con la nuova funzionalità di ricerca, il chatbot può ora fornire dati in tempo reale, rendendolo più rilevante per gli utenti. Un altro aspetto importante è che lo strumento di ricerca fornisce collegamenti alle fonti per dimostrare l’autenticità delle informazioni. Inoltre, ciò consente agli utenti di visualizzare le informazioni originali. Ciò aumenta la trasparenza e favorisce la fiducia tra gli utenti. Le persone possono ottenere le informazioni desiderate, coprendo diversi aspetti che includono informazioni finanziarie, previsioni del tempo e risultati sportivi. Copre anche contenuti legati agli aspetti educativi, di svago e di business.</p>
<p>OpenAI non ha intenzione di lanciare un prodotto separato, ma di integrare la funzionalità con l’interfaccia esistente di ChatGPT. Anche se ci sono momenti in cui la funzionalità può determinare quando cercare informazioni aggiuntive, gli utenti possono attivarla per farlo. Durante una demo pre-lancio, Adam Fry, responsabile della ricerca di OpenAI ChatGPT, ha dimostrato come utilizzare la funzionalità per trovare dati sulle azioni di Apple. I risultati sono stati incoraggianti poiché lo strumento ha mostrato informazioni rilevanti, inclusi un grafico interattivo delle azioni. Ha anche mostrato notizie relative alle performance delle azioni e al loro futuro. <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">previsione del prezzo</a>. Come spiegato in precedenza, i risultati di ricerca includono del materiale di riferimento. Il nuovo strumento di ricerca è disponibile su diverse piattaforme di ChatGPT che includono iOS, Windows, Android e app per desktop per macOS.</p>
<p>Il lancio dello strumento di ricerca ChatGPT di OpenAI ha inaugurato una nuova era nel settore delle informazioni. Commentando questo sulla sua pagina del blog, <a href="https://openai.com/index/introducing-chatgpt-search/" rel="nofollow noopener noreferrer" target="_blank">OpenAI ha detto</a>“Ora, la chat può condurti a una risposta migliore: Fai una domanda in modo più naturale e conversazionale e ChatGPT può scegliere di rispondere con informazioni dal web.”</p>
<p>Inoltre, <a href="https://openai.com/index/introducing-chatgpt-search/" rel="nofollow noopener noreferrer" target="_blank">Louis Dreyfus, CEO &amp; Publisher di Le Monde ha detto</a> Siamo convinti che la ricerca di intelligenza artificiale sarà, nel prossimo futuro e per le prossime generazioni, un modo primario per accedere alle informazioni.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/a-simple-guide-to-ritual-the-open-ai-infrastructure-network/4594" target="_blank">Una semplice guida ai rituali: la rete di infrastrutture Open AI</a></p>
<h2 id="h2-Partnerships20che20migliorano20le20capacit20di20ChatGPT167149"><a name="Partnerships che migliorano le capacità di ChatGPT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Partnerships che migliorano le capacità di ChatGPT</h2><p>OpenAI ha stretto partnership con diverse aziende per garantire il successo del suo progetto di ricerca basato sull’IA. Alcuni dei suoi partner includono Condé Nast, Dotdash Meredith, Associated Press, Reuters, Axel Springer, Financial Times, GEDI, Hearst, Le Monde, News Corp, The Atlantic, Time e Vox Media. Anche se la lista è piuttosto lunga, l’obiettivo è uno: fornire informazioni pertinenti agli utenti. Inoltre, queste fonti di informazione soddisfano determinati criteri per controllare la qualità dei contenuti che forniscono.</p>
<p>Leggi anche: <a href="https://akcdn.gate.io/learn/articles/in-depth-analysis-what-kind-of-sparks-can-ai-and-web3-create/3179" target="_blank">Che tipo di scintille può creare l’IA e il Web3?</a></p>
<h2 id="h2-Concorrenti20di20ricerca20OpenAI20ChatGPT144000"><a name="Concorrenti di ricerca OpenAI ChatGPT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Concorrenti di ricerca OpenAI ChatGPT</h2><p>OpenAI non è stata la prima azienda a disporre di uno strumento di ricerca alimentato da intelligenza artificiale di qualità. Alcuni dei principali strumenti di ricerca autonomi AI includono Meta Search Tool, Microsoft Copilot, Perplexity, Brave, Consensus e Phind. Ad esempio, Perplexity, sostenuto da Nvidia e Jeff Bezos, è un motore di ricerca conversazionale che ottimizza la ricerca di informazioni per soddisfare le esigenze individuali degli utenti. D’altra parte, Brave è un motore di ricerca integrato nel browser Brave.</p>
<h2 id="h2-Il20Futuro20dellAI20Autonoma20Approfondimenti20dai20Dirigenti20di20OpenAI170472"><a name="Il Futuro dell’AI Autonoma: Approfondimenti dai Dirigenti di OpenAI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il Futuro dell’AI Autonoma: Approfondimenti dai Dirigenti di OpenAI</h2><p>Sulla base delle tendenze tecnologiche del 2025, l’autonomia dell’IA aumenterà probabilmente in futuro portando a nuove funzionalità. Ad esempio, la ricerca personalizzata interattiva potrebbe cambiare il modo in cui le persone interagiscono con le informazioni disponibili. In futuro, gli strumenti di ricerca basati sull’IA potrebbero aiutare a coordinare varie attività importanti come viaggi e shopping. Pertanto, con l’introduzione di funzionalità pertinenti, è probabile che ChatGPT giochi un ruolo maggiore rispetto a fornire semplicemente risposte a poche domande. Ad esempio, le persone potrebbero utilizzare lo strumento per effettuare prenotazioni di hotel e organizzare viaggi.</p>
<p>Le previsioni dell’industria tecnologica mostrano che gli strumenti di ricerca alimentati dall’IA potrebbero fornire informazioni e raccomandazioni più personalizzate, come confronti di prezzi o consigli sugli investimenti. Le raccomandazioni potrebbero derivare dalle ricerche che un individuo farebbe di volta in volta. Questa personalizzazione renderà gli strumenti di ricerca adattabili, affidabili e compagni intelligenti.</p>
<p>Inoltre, gli strumenti di ricerca potrebbero integrare funzionalità vocali. Con questo, le persone potrebbero utilizzare query attivate dalla voce. In cambio, potrebbero esserci opzioni per ottenere risposte tramite messaggi vocali. Tali comandi vocali aumenterebbero il coinvolgimento degli utenti. Allo stesso modo, tale sviluppo porterebbe a strumenti di ricerca che funzionano come alcuni assistenti digitali moderni avanzati come Siri, Google Assistant e Alexa. Attraverso la combinazione di ricerca web e query attivate dalla voce, gli strumenti di ricerca web creeranno interfacce dinamiche e senza soluzione di continuità per fornire informazioni.</p>
<h2 id="h2-LAI20autonoma2020il20prossimo20grande20trend20nella20tecnologia311048"><a name="L’AI autonoma è il prossimo grande trend nella tecnologia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’AI autonoma è il prossimo grande trend nella tecnologia</h2><p>È certo che l’AI autonoma porterà molti cambiamenti che beneficeranno i suoi utenti in futuro. Ad esempio, una delle probabili tendenze tecnologiche del 2025 sarà l’AI agente, la tecnologia che consente agli agenti di macchine autonome di fare molto di più che semplici compiti di interrogazione e risposta. Invece, i bot generativi saranno in grado di eseguire compiti correlati all’impresa senza l’intervento umano.</p>
<p>Durante un <a href="https://www.reddit.com/r/ChatGPT/comments/1ggixzy/ama_with_openais_sam_altman_kevin_weil_srinivas/?rdt=34940" rel="nofollow noopener noreferrer" target="_blank">AMA su Reddit alcuni</a> I membri esecutivi di OpenAI hanno evidenziato i miglioramenti che apporteranno all’utensile di ricerca ChatGPT in futuro. Ad esempio, il team ha affermato che continuerà a migliorare i suoi modelli regolari e in serie, inclusi ChatGPT 3, 4 e 5. Hanno anche sottolineato che l’input di immagini arriverà presto su o1, probabilmente nel 2025. A tal proposito, il CPO di OpenAI ha dichiarato: ‘In generale, le serie di modelli otterranno funzionalità come multimodalità, utilizzo di strumenti, ecc. nei prossimi mesi’.</p>
<p>Un altro membro del team ha spiegato che vorrebbero migliorare lo strumento di ricerca ChatGPT al punto da consentirgli di comprendere le informazioni personali di ogni utente e svolgere alcune attività al loro posto. Stanno anche lavorando all’introduzione di agenti di intelligenza artificiale in grado di riassumere i rapporti. A riguardo, Altman ha detto: ‘Avremo modelli sempre migliori, ma… la prossima grande svolta saranno gli agenti’.</p>
<p>Markchen90 ha anche spiegato alcuni sviluppi prossimi futuri come il miglioramento delle risposte alle query. Ha detto: “Stiamo ponendo molta attenzione alla riduzione delle allucinazioni, ma è un problema fondamentalmente difficile: i nostri modelli imparano dal testo scritto dall’uomo e gli esseri umani talvolta dichiarano con sicurezza cose di cui non sono sicuri. I nostri modelli stanno migliorando nella citazione, che basa le loro risposte su fonti affidabili, e crediamo anche che l’RL aiuterà con le allucinazioni: quando possiamo verificare programmaticamente se i modelli allucinano, possiamo premiarli per non farlo.” Così, il team OpenAI sta lavorando per migliorare vari aspetti del suo strumento di ricerca.</p>
<p>Leggi anche su <a href="https://www.gate.io/blog/4139/the-rise-of-chinese-ai-unicorns-and-a-battle-with-openai" target="_blank">La crescita degli unicorni cinesi dell’IA e una battaglia con OpenAI</a></p>
<div class="blog-details-info"><br><div>Autore: Mashell C., Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni oculate.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il repostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>