TCdJQSBkaSBDaGF0R1BUIGluZmx1ZW56YSBpbCBzZXR0b3JlIHNhbml0YXJpbywgaSBwcmV6emkgaW4gYXVtZW50byBjb2xwaXNjb25vIGdsaSBhbWVyaWNhbmksIGxlIHBvbGl0aWNoZSByZWRpc3RyaWJ1dGl2ZSBkZWxsYSBDaW5hIGluZmx1ZW56YW5vIGdsaSBzdmlsdXBwYXRvcmkgaW1tb2JpbGlhcmk=

2023-01-19, 07:33

<p><img src="https://gimg2.gateimg.com/image/article/1674113338热点.jpg" alt=""></p>
<p>Come abbiamo visto in passato, gli eventi globali e il mondo delle criptovalute sono spesso interconnessi. Anche questa settimana non è stata diversa, con una serie di importanti sviluppi che hanno influenzato la comunità crypto.</p>
<h2 id="h2-Osservazioni20rapide523984"><a name="Osservazioni rapide" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Osservazioni rapide</h2><ol>
<li>SEC v. gemelli Winklevoss | Crypto</li><li>Come ChatGPT sta influenzando l’assistenza sanitaria | AI</li><li>Aumento dei prezzi che influisce sugli americani | Inflazione</li><li>BOJ difende il tetto dei rendimenti implica nessuna modifica sotto Kuroda | Commerci</li><li>Impatto delle ultime politiche della Cina sugli sviluppatori immobiliari del paese | Immobiliare</li></ol>
<h2 id="h2-Re20in20tumulto20i20re20delle20criptovalute73359"><a name="Re in tumulto i re delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Re in tumulto i re delle criptovalute</h2><p>I gemelli Winklevoss, Cameron e Tyler, non stanno attraversando un buon momento ultimamente. Dopo aver goduto di un periodo di successo con il prezzo di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> e della propria fama, ora si trovano a che fare con la caduta dei prezzi delle criptovalute, clienti infelici e la sensazione di aver potuto commettere un errore. In risposta, hanno criticato pubblicamente Barry Silbert, un collega imprenditore delle valute digitali e ex socio, e la Securities and Exchange Commission (SEC), che ha recentemente citato in giudizio la loro azienda, Gemini Trust Co.</p>
<p>Cameron e Tyler hanno accusato Silbert di avidità, imprudenza e frode contabile e hanno anche criticato la SEC come “super noiosa” e politicamente motivata. Anche altri leader delle criptovalute stanno incolpando gli altri per lo stato attuale del mercato, ma le deviazioni dei Winklevoss sono particolarmente sorprendenti date le loro precedenti affermazioni di essere sicuri e regolamentati.</p>
<h2 id="h2-ChatGPT20AI20sorprende20i20ricercatori20superando20lesame20medico20aprendo20la20strada20a20una20nuova20era20nellassistenza20sanitaria854871"><a name="ChatGPT AI sorprende i ricercatori superando l’esame medico, aprendo la strada a una nuova era nell’assistenza sanitaria" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ChatGPT AI sorprende i ricercatori superando l’esame medico, aprendo la strada a una nuova era nell’assistenza sanitaria</h2><p>ChatGPT, il potente modello AI generativo, ha appena fatto storia superando tutte e tre le parti dell’Esame di Licenza Medica degli Stati Uniti. Questo entusiasmante progresso, condotto dalla innovativa start-up sanitaria Ansible Health, è un chiaro indicatore del potenziale di ChatGPT nel rivoluzionare le diagnosi cliniche e le decisioni nel campo medico.</p>
<p>Ma, prima di entusiasmarti troppo, è importante notare che ChatGPT non è stato addestrato su nessun set di dati medici e non è progettato per fornire consigli medici. Tuttavia, i primi risultati sono promettenti e le possibilità sono infinite. Immagina ChatGPT che assiste i professionisti medici nel fornire spiegazioni ai pazienti e persino nel svolgere compiti di medico di base come controlli del benessere.</p>
<p>Ma non preoccuparti, i professionisti medici non verranno sostituiti dall’IA, è ancora nelle prime fasi e non ci si aspetta che i modelli di intelligenza artificiale siano in grado di diagnosticare autonomamente i pazienti a breve.</p>
<h2 id="h2-Prezzi20in20aumento20che20influenzano20gli20americani20nuova20indagine20rivela20tutto155168"><a name="Prezzi in aumento che influenzano gli americani: nuova indagine rivela tutto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prezzi in aumento che influenzano gli americani: nuova indagine rivela tutto</h2><p>Un nuovo sondaggio di Morning Consult rivela che la spesa complessiva dei consumatori ha subito un duro colpo a dicembre, con uno sbalorditivo calo del 4,3% rispetto al mese precedente. Questa non è una buona notizia per la crescita economica, soprattutto quando un numero crescente di americani spende più di quanto guadagna. Ma non disperare, gli acquirenti stanno diventando creativi e stanno facendo compromessi. Ad esempio, per permettersi l’aumento dei prezzi dei generi alimentari a casa, le famiglie stanno tagliando le spese per i ristoranti.</p>
<p>Ma non sono solo i lavoratori a basso reddito a sentirsi sotto pressione, anche gli americani più facoltosi stanno risentendo del calo. Il 28% di coloro che guadagnano meno di 50.000 dollari ha dichiarato che le spese superavano il reddito a dicembre, un forte aumento rispetto al 21% dell’anno scorso. I prezzi in aumento, in particolare per cibo e alloggio, stanno colpendo duramente tutti. Questo è solo un dato, ma ci si aspetta che più dati sulle vendite al dettaglio alla fine del 2022 vengano rilasciati più tardi oggi.</p>
<h2 id="h2-La20determinazione20della20BOJ20a20difendere20il20limite20di20rendimento20segnala20nessun20grande20cambiamento20nella20politica20monetaria20sotto20Kuroda596485"><a name="La determinazione della BOJ a difendere il limite di rendimento segnala nessun grande cambiamento nella politica monetaria sotto Kuroda." class="reference-link"></a><span class="header-link octicon octicon-link"></span>La determinazione della BOJ a difendere il limite di rendimento segnala nessun grande cambiamento nella politica monetaria sotto Kuroda.</h2><p>La Banca del Giappone ha deciso di mantenere i suoi tassi di interesse ultra-bassi e il tetto dei rendimenti obbligazionari, anziché eliminare il suo massiccio programma di stimolo come previsto dal mercato. Questa mossa ha fatto scivolare lo yen rispetto alle altre valute e ha fatto crollare i rendimenti obbligazionari più di quanto accaduto in decenni, poiché gli investitori hanno disfatto le scommesse fatte in previsione che la banca centrale avrebbe rivisto la sua politica di controllo dei rendimenti.</p>
<p>Il governatore Haruhiko Kuroda ha creato una nuova arma per evitare che i tassi a lungo termine salgano troppo, cosa che alcuni analisti hanno interpretato come un segnale che si tratterà di evitare grandi cambiamenti di politica nei mesi rimanenti del suo mandato.</p>
<h2 id="h2-La20nuova20era20della20redistribuzione20in20Cina20limpatto20sugli20sviluppatori20immobiliari20del20paese738013"><a name="La nuova era della redistribuzione in Cina: l’impatto sugli sviluppatori immobiliari del paese" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La nuova era della redistribuzione in Cina: l’impatto sugli sviluppatori immobiliari del paese</h2><p>Molti dei titani più ricchi e potenti del paese, come Hui Ka Yan, presidente del Gruppo China Evergrande, stanno vedendo i loro patrimoni crollare e il loro influsso politico diminuire.</p>
<p>Hui, che un tempo era la seconda persona più ricca dell’Asia con un patrimonio netto di 42 miliardi di dollari, ha visto il suo patrimonio ridursi a soli 3 miliardi di dollari. Ma non è tutto, è stato anche rimosso dall’élite della Conferenza consultiva politica del popolo cinese (CPPCC), un gruppo esclusivo composto da funzionari governativi e grandi nomi degli affari.</p>
<p>Hui non è solo in questo, poiché molti altri magnati immobiliari come Hui Wing Mau del Shimao Group Holdings Ltd., Zhang Li del Co. di Proprietà di Guangzhou R&amp;F e Hoi Kin Hong del Powerlong Real Estate Holdings Ltd. non fanno più parte del CPPCC.</p>
<p>Questo cambiamento di atteggiamento nei confronti degli sviluppatori immobiliari è un riflesso della spinta alla “prosperità comune” del presidente Xi Jinping per ridistribuire la ricchezza e frenare il debito nel settore immobiliare, che sta colpendo banche, società fiduciarie e proprietari di case. Di conseguenza, i cinque magnati immobiliari più ricchi della Cina hanno perso complessivamente 65 miliardi di dollari negli ultimi due anni.</p>
<p>Vale la pena notare che il ruolo della CPPCC è simile a un premio onorario conferito ai imprenditori che contribuiscono al paese, quindi non sorprende affatto che i magnati immobiliari che hanno causato problemi nel settore immobiliare con il loro eccessivo indebitamento siano esclusi dalla lista. È sicuramente un momento difficile per i costruttori cinesi, ma sarà interessante vedere come si evolverà questa ristrutturazione nel lungo periodo.</p>
<p><a href="https://www.gate.io/activities/crypto-news-carnival#/ &quot;![](https://gimg2.gateimg.com/blog/166564757626299037220221013-155242.png" rel="nofollow noopener noreferrer" target="_blank"><img src="https://gimg2.gateimg.com/blog/166564757626299037220221013-155242.png" alt=""></a>”)</p>
<div class="blog-details-info"><br><div>Autore:<strong> Peter L. </strong>, Ricercatore 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 a causa di violazione del copyright.<br></div><p></p><br></div></div></div>