Nel dibattito sull’IA, si tende ad attribuire una persona artificiale a quest’ultima, utilizzando pronomi come ‘Lei’ o ‘Lui’. Anche io, a volte, cappo in questo errore durante i discorsi. La motivazione di questo lapsus, a mio avviso, è legata soprattutto alla complessità del tema dell’Intelligenza, sebbene seguito dall’aggettivo “Artificiale”, questo lemma induce nell’immaginario del cervello umano un’associazione con la figura umana, perché l’intelligenza è stata tradizionalmente vista come caratteristica peculiare dell’essere umano.

Parlare dell’AI come se fosse umana presenta un problema sia a livello lessicale che cognitivo, poiché può portare a conseguenze dannose: far percepire al cervello il testo AI come parte integrante di un ragionamento cosciente. È fondamentale, quindi, prima di utilizzare queste tecnologie, specialmente per i più giovani, distinguere tra ciò che è prodotto da un algoritmo basato su una valutazione statistica su centinaia di miliardi di dati e ciò che invece è prodotto di esperienza umana, influenzata da intuito e coscienza.

L’AI nell’ambiente lavorativo

L’algoritmo non può replicare la coscienza umana, poiché questa deriva da sentimenti e riflessioni generate dalle esperienze vissute.

Essere umani significa conoscere il dolore, che ci guida verso una maggiore empatia. Immaginiamo una persona appena licenziata pronta a raccontare la sua storia.

La risposta di un sistema di intelligenza artificiale sarebbe una cosa di questo genere:
“Mi dispiace che tu abbia perso il lavoro. È una situazione difficile. Potresti considerare di aggiornare il tuo curriculum, cercare nuove opportunità online e valutare corsi di formazioni per migliorare le tue competenze”.

La risposta è accurata e razionale, ma manca di empatia per la situazione umana.

Un essere umano empatico probabilmente avrebbe risposto:
“Accidenti… Mi dispiace davvero tanto. So quanto ci tenevi a quel lavoro. Devi attraversare un momento molto pesante da digerire. Se ne vuoi parlare sono qui. Adesso cerca di digerire la cosa e quando ti sentirai più lucido magari possiamo ragionare insieme su come muoverti per cercare un’altra occupazione. Se potrò ti darò una mano chiedendo a qualche persone che conosco se ha bisogno di una figura come la tua”.

In questo contesto si osservano azioni tipicamente umane: il riconoscimento dell’emozione come un’esperienza condivisa, la condivisione emotiva che induce l’ascoltatore ad entrare in sintonia con lo stato d’animo di chi ha subito il licenziamento. C’è una presenza relazionale che fornisce disponibilità: “possiamo ragionare insieme”, “Se potrò ti darà una mano”.Invece di un aiuto tecnico immediato, c’è uno scambio emotivo, una comprensione reciproca e una soluzione proposta dopo un periodo di riflessione.

L’empatia umana va oltre la semplice comprensione logica; include una componente di risonanza emotiva.

Un esempio ancora più forte può essere questo:
“Oggi ho venduto il violino di mio padre”.

Una possibile risposta dell’AI potrebbe essere: “Se mi dici modello e marca del violino e prezzo di vendita posso dirti se hai fatto un buon affare”.

Una possibile risposta di un umano: “Ma il violino che suonava sempre tuo padre che custodivi gelosamente in quella teca? Deve essere stato molto pesante per te disfartene, quel violino portava sicuramente tanti ricordi!”.

Qui è ancora più evidente che l’attenzione dell’interlocutore non si focalizza sull’oggetto ma su ciò che c’è dietro l’oggetto. Ricordi, emozioni, vita vissuta.

Ma attenzione, anche l’AI, a seconda del modello potrebbe dare una risposta simile… Cosa significa? È fondamentale ricordare che i modelli di IA si basano su informazioni fornite dagli esseri umani. In questa situazione potrebbe emulare un comportamento umano, ma è importante precisare che non lo è effettivamente. Fornirebbe semplicemente la risposta più statisticamente probabile che un essere umano darebbe a una simile affermazione, però ancora una volta priva di qualsiasi emozione.

Perché molte persone si “aprono” con un modello AI?

Sono numerose le testimonianze di individui che rivelano di condividere pensieri e sentimenti con modelli AI più spesso rispetto alle persone reali. Questa situazione è preoccupante, ma ha una spiegazione plausibile.

Per effettuare comparazioni valide, l’AI non va confrontata con elementi negativi estremi, ma con modelli umani di riferimento razionali. In caso di necessità, affidarsi ad un’intelligenza artificiale potrebbe essere più sicuro rispetto a doversi affidare ad un assassino (la fiera della banalità), ma fortunatamente gli assassini sono pochi e il mondo è ancora popolato da persone oneste.

Quando pensiamo ai ragazzi che subiscono bullismo scolastico, è naturale comprendere come possano sentirsi a proprio agio nell’ aprirsi all’AI perché trovano un supporto che:

• Non li incolpa
• Non li bullizza
• Non li prende in giro
• Gli da dei consigli apparentemente razionali
• È raggiungibile istantaneamente 24/7

Sebbene efficace nell’elaborazione del testo, il sistema non è in grado di comprendere ed integrare le emozioni, operando esclusivamente su dati testuali. Nell’interazione sociale, i gesti rivelano molto sulle emozioni degli individui. L’AI, a causa della limitata comprensione del linguaggio non verbale, fatica a costruire relazioni reali. Anche il tono utilizzato svolge un ruolo fondamentale.

Il lato oscuro delle persone

Con grande frequenza, quando vengo contattato da aziende, il luogo comune è questo: “Ingegnere, dove posso integrare l’Intelligenza Artificiale per risparmiare sul costo del personale?”… Tradotto… Dove posso mettere AI per licenziare un po’ di gente e mettermi più soldi nelle tasche?

Non posso esimermi dal definire questa visione imprenditoriale decisamente miope!

L’integrazione dell’AI mira alla produttività e alla velocità, non al licenziamento dei propri dipendenti. Con una solida situazione economica e liquidità a disposizione, quale beneficio deriva dall’utilizzo dell’AI per la riduzione della forza lavoro?

Sarebbe come dire che ho una macchina, metto un motore più potente ma tolgo i freni perché il mio scopo è solo quello di accelerare più velocemente. Ok, ma quando poi davanti ti trovi un muro cosa fai? Gli chiedi di spostarsi?

L’integrazione di AI per ridurre il personale è sensata solo in un caso specifico: l’azienda sta attraversando un periodo critico con calo del lavoro, debiti crescenti e impossibilità di far fronte ai pagamenti. Per evitare la chiusura, si procede con riduzioni del personale in un tentativo di contenere i costi e preservare alcune posizioni lavorative cercando di rimpiazzare quella forza lavoro con l’AI.

Questa però è un’eccezione, uno stato di emergenza, non una norma! È come dire: “Salviamo ciò che possiamo licenziando 10 persone prima che sia troppo tardi e perdano il lavoro 100 persone”.

Il problema è che le aziende che mi pongono domande del genere spesso non hanno carenze di liquidità, e non sperimentano alcuna fatica nel mantenere il loro attuale livello occupazionale.

Sorge dunque una complessa questione etica per l’imprenditore e l’azienda chiamata a sviluppare questi strumenti.

Un regolamento giuridico in materia sarebbe fondamentale per garantire ai dipendenti una maggiore serenità nell’affrontare l’introduzione dell’intelligenza artificiale come alleato nel contesto lavorativo, e garantirebbe la continuità del livello occupazionale evitando i classici scontri etici che si hanno tra imprese clienti e software house. Perché cari lettori… Einstein diceva che “è più facile spezzare un atomo che un pregiudizio”. Personalmente ogni volta che mi trovo dinnanzi a proposte del genere provo con tutto me stesso a convincere chi sta davanti a me della sua visione miope: “utilizza questo personale in comparti più strategici, magari nel marketing per aumentare la domanda”, ma diciamoci la verità, molti imprenditori si concentrano unicamente sul guadagno a breve termine, ignorando le implicazioni etiche di eventuali decisioni e trascurando

D’altra parte è però richiesto anche uno sforzo da parte del dipendente. Diamo come si suol dire un calcio al cerchio e uno alla botte… Il contratto a tempo indeterminato non deve essere visto come un certificato di Laurea; ok ora mi sono laureato e sto a posto così, questo pezzo di carta non me lo toglie più nessuno. Molti dipendenti si “rilassano” per usare un eufemismo, quando vengono convertiti a tempo indeterminato. C’è chi accumula malattie su malattie anche se in perfetto stato di salute. C’è chi arriva in ufficio e scalda solo la sedia facendo il minimo indispensabile.
Naturalmente quando io parlo di mantenimento di livello occupazionale con gli imprenditori mi batto per i lavoratori virtuosi, non per gli scalda poltrona!

In questa intervista tocchiamo alcuni di questi punti. Buona visione.

L'articolo La mia intervista a Esperti del Settore: AI ed etica proviene da RENOR & Partners S.r.l..

Intelligenza artificiale e lavoro: l’ansia collettiva alimentata dai media

Titoli catastrofisti e sensazionalismo: “l’AI ci sostituirà tutti”

Nell’immaginario collettivo, l’Intelligenza Artificiale è spesso descritta come una forza oscura pronta a spazzare via milioni di posti di lavoro. Questa percezione è alimentata da titoli allarmistici che fanno leva sul panico e sull’incertezza più che sulla realtà dei dati. “L’AI sostituirà l’80% dei posti di lavoro”, “Addio impiegati: l’AI li renderà tutti inutili”, “Lavoreremo solo 3 giorni a settimana o saremo disoccupati a vita?”…

Questi sono alcuni dei titoli che popolano quotidiani, social e blog, generando un senso diffuso di angoscia sociale.

Il problema non è l’enfasi con cui vengono presentati, ma il totale e assoluto vuoto analitico che li accompagna. Questi articoli non distinguono mai settori, ruoli automatizzabili e non, attività che saranno assistite e quelle che effettivamente verranno eliminate. Il risultato di questa catastrofe mediatica è un messaggio di paura: o ti adegui o sparisci. In realtà, la verità è molto più sfumata e meno radicale.

Questo approccio propagandistico utilizzato solo per generare click mi fa venire in mente altri momenti storici in cui una nuova tecnologia veniva demonizzata per ignoranza o per difesa dello status quo. Lo si è visto con i computer, con internet, con i social, con l’automazione industriale. L’AI non fa eccezione: viene interpretata non come un potenziale strumento, ma come un agente ostile e autonomo che agisce per “rubare” qualcosa all’essere umano.

In un contesto di questo genere è fondamentale recuperare una visione lucida e informata, capace di distinguere tra ipotesi, paure e dati concreti. Solo con la conoscenza è possibile superare l’isteria collettiva e affrontare un imminente cambiamento con intelligenza strategica anziché con un panico irrazionale e immotivato.

Confusione tra automazione e estinzione

Una delle distorsioni più comuni nei vari dibattiti sull’Intelligenza Artificiale riguarda a mio avviso la confusione tra l’automazione di attività e l’estinzione di professioni. È un grossolano errore concettuale che amplifica paure infondate e paralizza il pensiero critico e strategico.

La realtà è molto più articolata: l’AI non sistituisce i mestieri, ma trasforma i compiti all’interno dei mestieri. Mi rendo conto che la frase può essere non chiara a tutti quindi facciamo un esempio.
Il lavoro del giornalista… L’AI può automatizzare la redazione di articoli standardizzati (come report sportivi o bollettini finanziari), ma non può e con buona probabilità, non potrà mai sostituire la sensibilità editoriale, l’indagine critica, la capacità di costruire un’inchiesta, fare domande pertinenti a un’intervista o interpretare un contesto culturale.

Tutto ciò vale non solo per l’editoria, ma per una moltitudine di altri settori. L’AI può assistere, ottimizzare, velocizzare molte delle fasi del lavoro, ma ciò non implica che l’intera professione venga annullata. Anzi, i dati mostrano che in molti casi, la presenza dell’AI crea nuove funzioni, nuove responsabilità e nuovi ruoli ibridi.

Confondere l’automazione con la cancellazione di una professione è come dire che l’invenzione della lavatrice abbia cancellato il mestiere di chi lavava i panni a mano. Oggi possiamo dire che non è così; ha liberato tempo e risorse, permettendo alle persone di dedicarsi ad altro: all’educazione, alla creatività, allo studio o ad attività a maggior valore aggiunto.
Il vero nodo quindi non è la perdita, ma la trasformazione: un processo che richiede adattamento, formazione continua, apertura mentale. L’AI toglierà senso solo a quei ruoli che si rifiutano di evolvere, non a quelli che accettano la sfida del cambiamento utilizzando AI a proprio vantaggio.

L’AI fa paura a chi non dovrebbe esserci: che sia finalmente la fine dei ruoli immeritati?

Un aspetto poco discusso nel dibattito pubblico è che l’AI fa davvero paura solo a due categorie di lavoratori: quelli troppo verticali, ma soprattutto quelli troppo deboli per merito e che sono protetti da dinamiche non trasparenti. Ovvero specialisti incapaci di aggiornarsi fuori dalla loro nicchia perché non hanno sviluppato una mente capace di destreggiarsi in contesti trasversali e soprattutto persone che occupano ruoli per cui non hanno reali competenze, ma che si sono trovati lì per raccomandazione o parentela. Sì, specialmente queste persone farebbero bene a iniziare a preoccuparsi!

In Italia, Paese ancora fortemente ancorato a logiche di titoli, anzianità e posizionamento, più che di valore reale, l’AI sta diventando uno specchio scomodo. Non perché umili l’uomo, ma perché smaschera l’inutilità funzionale di molti ruoli. Se bastano 30 secondi con ChatGPT per ottenere un documento che richiederebbe a certi uffici 3 giorni e 6 firme, la domanda è lecita: serviva davvero quella posizione?

In questa luce, il timore verso l’AI non è paura del cambiamento, ma paura della trasparenza. Per la prima volta, una tecnologia è in grado di misurare (molto spesso in tempo reale), il valore prodotto rispetto al tempo impiegato, alla ridondanza operativa e al contributo effettivo.

Forse, paradossalmente, l’avvento dell’intelligenza artificiale rappresenta l’occasione per avviare, anche indirettamente, un processo di meritocrazia naturale. Non quella imposta per decreto, ma quella che emerge quando il sistema smette di tollerare l’inutile perché esiste un’alternativa oggettivamente più efficiente.

La paura è quindi giustificata solo in un senso: se il tuo ruolo esiste solo perché non sei in grado di poter fare altro e non sei in grado di reinventarti, non generi un valore aggiunto e rappresenti oggettivamente un peso perché non ti dedichi al tuo lavoro con passione e dedizione ma solo per arrivare alla fine del mese e prendere il tuo stipendio.

Chi è creativo non può aver paura di qualcosa che per definizione non è creativa. L’AI non ha intuizioni, si limita a svolgere compiti per come è stata addestrata a farli.

Il paradosso della produttività: temiamo ciò che ci dovrebbe sollevare

Una delle contraddizioni più evidenti nel dibattito sull’Intelligenza Artificiale è il fatto che molti lavoratori sembrano temere proprio ciò che, in teoria, dovrebbe alleggerirli.

Da sempre le innovazioni tecnologiche hanno come obiettivo quello di ottimizzare i tempi, ridurre gli errori, automatizzare i processi. Eppure, di fronte all’AI questa logica si rovescia. Se un tempo l’efficienza era desiderabile, ora diventa una minaccia. Ma perché?

Perché in molte organizzazioni sia pubbliche che private, la produttività reale non è mai stata una variabile dell’equazione. Si lavora o si finge di farlo per riempire orari, difendere ruoli, mantenere equilibrio tra competenze deboli e mansioni ripetitive. In questi contesti, l’arrivo di un sistema che può fare in 5 minuti ciò che un team impiega 3 giorni a consegnare non viene percepito come liberazione, ma come pericolo esistenziale.

Il vero problema, quindi, non è l’AI in sé; è che l’AI mette in discussione alcune attività il cui valore era già discutibile. L’automazione rende visibile l’assurdità di interi processi aziendali costruiti sulla lentezza, sull’intermediazione inutile, sulla ripetizione fine a sé stessa.

Ma c’è anche un altro aspetto ancora più profondo: la produttività crea spazio vuoto e il vuoto, culturalmente, fa paura. Chi lavora in aziende che non premiano l’iniziativa individuale, la creatività e il pensiero strategico si chiede: “Se l’AI mi libera 3 ore al giorno… Cosa farò di quel tempo? Sarò valutato per ciò che riesco a creare o per ciò che non ho più da fare?”.

In questa ambiguità si inserisce il vero paradosso: la tecnologica che potrebbe finalmente permettere agli umani di concentrarsi su ciò che conta, viene vissuta come un attentato alla sopravvivenza. Ma forse, il problema non è la tecnologia ma il modello culturale che ci ha abituati a lavorare per esistere, anziché per produrre valore.

Casi storici analoghi

Quando arrivarono gli ecommerce si disse: “È la fine dei negozi”

L’introduzione degli ecommerce generò, a suo tempo, un’ondata di panico molto simile a quella che oggi accompagna l’Intelligenza Artificiale. Si temeva che i negozi fisici avrebbero chiuso in massa, che lo shopping reale sarebbe diventato obsoleto e che interi settori, dalla vendita al dettaglio alla logistica, fino ad arrivare al mercato immobiliare degli affitti dei negozi, sarebbero collassati.

Eppure, col senno del poi, oggi sappiamo che non è andata così… Gli ecommerce non hanno distrutto il commercio tradizionale: lo hanno costretto ad evolversi. Molti piccoli negozi hanno iniziato a vendere online, i centri commerciali hanno integrato strategia omnicanale, i grandi brand hanno investito in piattaforme ibride. È nato il click&collect, il live commerce, il drive-in digitale. L’esperienza d’acquisto non è morta, si è trasformata in esperienza phygital ovvero un’esperienza fisica e digitale assieme aprendo anche scenari che prima erano solamente locali ed oggi possono mostrarsi ad un pubblico internazionale.

In realtà quello che è successo è esattamente ciò che sta accadendo oggi con l’AI: chi ha resistito è rimasto indietro; chi ha adattato il proprio modello ha prosperato. Il negoziante che ha visto l’ecommerce come una minaccia ha chiuso. Quello che lo ha visto come un’opportunità, un’estensione del proprio servizio, ha guadagnato nuove fette di mercato, anche estero. Questa riprova ci insegna che ogni tecnologia non cancella l’esistente ma rimodula il contesto competitivo. Non è la tecnologia che uccide un’attività, ma l’incapacità di adattarsi al nuovo paradigma.

L’industrializzazione e la fine degli artigiani?

A fine Ottocento, quando le prima macchine a vapore e i telai meccanici cominciarono a sostituire il lavoro manuale degli artigiani, si gridò allo scandalo: “Questa è la morte della dignità del lavoro” dissero in molti. E non mancavano motivazioni concrete: chi aveva passato una vita a lavorare il legno, il ferro, il tessuto con sapienza e dedizione, vedeva improvvisamente il proprio mestiere ridotto a un processo ripetitivo, impersonale, automatizzato.

Ma anche in questo caso, la profezia apocalittica si rivelò inesatta. L’industrializzazione non uccise il lavoro umano, lo moltiplicò.
Nacquero nuove figure, nuove specializzazioni, nuove gerarchie professionali. Il lavoro artigianale non scomparve: cambiò ruolo, si ridusse in scala ma non perse valore. Anche oggi possiamo comprare una giacca di un famoso brand e pagarla 300 euro. Farsela fare da un artigiano su misura, scegliendone il tessuto, i bottoni, lo stile, la lavorazione può costare 3000 euro!
Esiste dunque ancora oggi un contesto in cui l’unicità e la qualità sono parametri molto più importanti della quantità.

Dalla transizione al coraggio

Quella transizione industriale fu una delle più potenti leve di crescita economica e sociale della storia. Ha permesso la nascita delle classi operaie, l’urbanizzazione, i diritti sindacali, il concetto stesso di orario di lavoro regolamentato. Senza quel passaggio non ci sarebbero state le tutele moderne, l’accesso di massa al consumo, né la possibilità di lavorare fuori da un contesto agricolo o feudale.

Chi ebbe il coraggio di passare dalla paura all’organizzazione, dalla bottega alla fabbrica, non solo mantenne la propria dignità professionale, ma contribuì attivamente alla costruzione di un nuovo modello di civiltà. È proprio grazie all’industrializzazione e alla razionalizzazione della produzione che abbiamo potuto assistere a un’accelerazione senza precedenti delle scoperte scientifiche e tecnologiche, con un impatto diretto sul benessere collettivo: aspettativa di vita più lunga, maggiore disponibilità di beni, progressi nella medicina, nell’alimentazione e nei trasporti.

Non a caso, nei Paesi che non hanno conosciuto un processo industriale su larga scala, spesso per ragioni storiche, geopolitiche o strutturali, si riscontrano ancora oggi gravi problemi come la malnutrizione, la diffusione di malattie curabili e una più bassa aspettativa di vita.
Quando la crescita demografica non è accompagnata da un parallelo sviluppo nelle capacità di produrre beni e servizi, il sistema sociale entra in crisi. L’industrializzazione, con tutti i suoi limiti e contraddizioni, è stata uno degli strumenti più efficaci per superare questo squilibrio.

Oggi l’AI è vista con lo stesso sospetto: fredda, impersonale, disumanizzante; ma anche in questo caso, non è lo strumento in sé a determinare il cambiamento, bensì la capacità del sistema di assorbirlo, modularlo e incanalarlo verso nuovi significati sociali e professionali.

L’informatizzazione e il lavoro d’ufficio

Tra la fine degli anni ’80 e l’inizio dei ’90, l’introduzione massiva dei personal computer negli uffici fu vissuta, ancora una volta, come una minaccia. Si diceva che i computer avrebbero azzerato il bisogno di personale amministrativo, che i documenti cartacei sarebbero spariti e che l’essere umano sarebbe diventato un semplice accessorio del software.

Una parte di verità c’è… Molte funzioni ripetitive e manuali sono state sostituite da fogli di calcolo, database, sistemi di gestione documentale. Ma ciò che si è perso in attività meccaniche è stato compensato dalla nascita di nuove responsabilità cognitive e digitali. L’informatizzazione ha dato origine a figure professionali che prima non esistevano: data entry specialist, sistemisti, project manager, responsabili IT, analisti funzionali, sviluppatori, ingegneri del software, ecc. ecc.

Il segretario è diventato office manager, il contabile ha imparato a usare software di contabilità, l’archivista si è evoluto con archiviazione digitale… Il lavoro è rimasto ma ha cambiato pelle.

Questo dimostra che ogni volta che una tecnologia entra in un’azienda, non distrugge l’intero ecosistema, ma ricombina le attività esistenti efficientandole. Alcune si contraggono, altre si espandono, altre ancora nascono da zero.

Ancora una volta l’AI oggi si presenta con un impatto simile a quello dell’informatizzazione: potente, trasversale, poco visibile a occhio nudo ma capace di ridefinire profondamente processi. E come allora il risultato dipenderà da una sola cosa: la disponibilità di ciascun professionista ad aggiornarsi.

Le previsioni sbagliate del passato recente

Come abbiamo visto, la storia dell’innovazione è disseminata di previsioni disastrose che non si sono di fatto mai avverate, ma del resto tira molto di più un titolo catastrofista… Nei paragrafi precedenti, ci sono moltissime innovazioni tecnologiche che hanno portato la paura di un cambiamento, paura infondata dal momento che il cambiamento è stato sempre positivo. Una tecnologia nasce quando si sente l’esigenza di usarla… Inizio a pensare ad un martello solo quando ho l’esigenza di piantare un chiodo al muro, non prima.

Gli errori di previsione non nascono da incompetenza, ma da un errore metodologico ricorrente: si considera la tecnologia come agente attivo, e l’essere umano come passivo. In realtà se da un lato la tecnologia evolve, dall’altro l’uomo reagisce, si adatta, si reinventa; ed è proprio lì che le profezie catastrofiche vanno in frantumi.

La trasformazione dei ruoli esistenti

Una delle evidenze più importanti ma meno comprese è che la maggior parte dei cambiamenti portati dall’AI non comporta la scomparsa dei ruoli, bensì la loro trasformazione interna. I job title restano, le mansioni si riscrivono. Cambiano le priorità, le modalità operative, gli strumenti e le competenze richieste.

Un grafico pubblicitario oggi non può più limitarsi a impaginare elementi statici, deve conoscere prompt visuali per generare bozze con DALL-E o Midjourney, deve saper modificare testi in ottica SEO e in alcuni casi interagisce con tool AI che ottimizzano campagne. La parte strategica però (messaggio, posizionamento e tono di voce) resta totalmente in mano all’umano perché è lui che ha l’intuizione ed è qui che si genera valore.

Un architetto un tempo concentrato unicamente su software CAD e vincoli edilizi, oggi può utilizzare AI generativa per creare varianti progettuali, esplorare nuovi materiali, testare soluzioni in ambienti virtuali pertanto non è sostituito, è potenziato!

In ambito di Copywriting e supporto

Un copywriter non scrive più tutto da zero, orchestra il testo, combinando l’intuizione umana con lo sviluppo del testo con AI. Il suo ruolo si sposta dalla produzione alla cura e supervisione semantica; e nel frattempo nasce una nuova figura in questo contesto, quella del prompt writer ovvero colui che sa chiedere alle AI nel modo giusto per ottenere i risultati che si aspetta.

Anche nei settori apparentemente più esposti come il customer care o il supporto tecnico, l’AI gestisce i livelli base, ma l’umano si eleva ai livelli superiori dove è necessaria empatia, adattamento e negoziazione. I professionisti che un tempo si occupavano di ticket ripetitivi ora diventano formatori di chatbot, supervisori della qualità, designer delle esperienze di supporto e risolvono problemi di customer care dove l’AI non ha i toni e l’empatia per poterli risolvere.

In questo scenario, chi si aggiorna, chi è disposto ad osservare l’AI come un solido alleato può salire di livello, non essere spinto fuori. L’unico rischio reale è restare identici a sé stessi mentre il mondo sta cambiando.

Lavorare con l’AI, non contro: il professionista “aumentato”

La reazione istintiva più diffusa verso l’AI è difensiva: “devo proteggermi”, “devo evitare che mi rubi il lavoro”. Ma questa è una mentalità statica, perdente. Il punto non è se l’AI ti sostituirà. Il punto è se tu saprai usarla a tuo vantaggio per diventare migliore.

Le AI generative, conversazionali, predittive, non sono entità nemiche, sono strumenti. Esattamente come lo sono stati l’elettricità, il computer, gli ecommerce, il motore a scoppio, il cloud. E come ogni strumento potente, il loro valore dipende da chi li maneggia.

Oggi un avvocato che sa usare ChatGPT o Claude per redigere una prima bozza, estrarre riferimenti giurisprudenziali o simulare una linea argomentativa non è meno competente: è più veloce, più scalabile e più competitivo.

Un designer che sa usare DALL-E per generare una decina di proposte visive in 30 secondi non è meno creativo, è più libero di scegliere, iterare e osare.

Un recruiter che usa modelli AI per estrarre pattern ricorrenti nei curriculum e verificarli con il proprio occhio critico non è superato: è potenziato.

L’AI non è una forza che ti spinge via. È una forza che ti affianca se glielo permetti e sei disposto a farla entrare nel tuo asset lavorativo. È proprio come accade in una squadra, l’intelligenza collettiva cresce se ognuno conosce il proprio valore. In questo caso l’umano resta insostituibile nei campi dove servono: intuito, empativa, visione strategica, responsabilità morale. Il futuro del lavoro non è umano o artificiale, è umano e artificiale insieme.

La mentalità vincente: adattiva, non difensiva

C’è un tratto comune che accomuna tutte le persone che hanno saputo attraversare indenni i grandi cambiamenti storici: una mentalità adattiva. Non necessariamente geniali, non sempre tecnicamente brillanti, ma capaci di leggere i segnali del cambiamento, accettarli e agire di conseguenza. Lottare contro qualcosa di inevitabile non è solo inutile è una perdita di tempo prezioso. Queste persone non hanno opposto resistenza: hanno studiato, osservato, sperimentato. Hanno compreso che il vero pericolo non è il cambiamento in sé, ma l’immobilismo.

Oggi più che mai questo principio torna centrale. In un mondo che evolve alla velocità della luce, il valore non è più nella posizione che occupi ma nella velocità con cui riesci a spostarti, a ricollocarti e a reinventarti. L’AI non premia chi ha una scrivania, ma chi ha visione e punisce, silenziosamente e inesorabilmente, chi si arrocca nella nostalgia di “come funzionavano le cose prima”.

Cambiamento opzionabile? Non lo credo!

Tante persone resteranno ferme perché si illudono che il cambiamento sia opzionale. Non lo è! Adattarsi è l’unica possibile via da percorrere. Resistere non è una strategia, è solo una lenta condanna. Eppure molti preferiscono negare, rifiutare, sminuire ciò che non conoscono nel perfetto stile italiano.

Serve oggi più che mai una postura mentale totalmente rinnovata. Non quella del “mi difendo” ma quella del “mi preparo”; non quella del “mi basta quello che so”, ma quella del “voglio capire come posso trasformarmi e cosa posso diventare in meglio.

Non serve essere ingegneri, serve essere curiosi, aperti e veloci nell’apprendere. Serve leggere, provare, farsi aiutare da un tool AI, domandarsi come potrebbe essere utile alla propria professione. Non tutto funziona, ma il solo fatto di provarci ti mette avanti rispetto a chi nemmeno si pone la domanda.

In fondo non è la tecnologia a decidere chi resta e chi va.
È la mentalità con cui la si affronta.
Chi ha mentalità adattiva, non solo sopravvive ma fiorisce!

Il lavoro non sta morendo, sta evolvendo e ci chiede di fare lo stesso

Abbiamo visto come ogni rivoluzione abbia avuto il suo mostro da temere. Ogni volta si è temuto il peggio e ogni volta la realtà si è rivelata diversa: non meno lavoro, ma lavoro diverso. Non meno umanità, ma umanità distribuita, riscritta e talvolta costretta a uscire dalla zona di comfort.

L’AI non è diversa è solo più veloce, più profonda e più persuasiva, ma non è qui per distruggere il lavoro, è qui per dare una scossa a ciò che già non funzionava: ruoli deboli, ripetitività improduttiva, burocrazia inefficiente, protezioni immotivate. Fa paura perché mette a nudo l’inutilità, e perché rende evidente ciò che fino a ieri si poteva ancora fingere di non vedere.

Ma per chi ha talento, per chi ha voglia di imparare, per chi è pronto al cambiamento l’AI non è una minaccia, è una leva. Un’opportunità per salire di livello e per liberarsi del superfluo, qualcosa per ricentrarsi su ciò che conta davvero: l’intuizione, la progettualità, la relazione, la visione.

Il lavoro non sta morendo, sta mutando forma. Sta chiedendo a ognuno di noi: “Cosa sei disposto a diventare?”.

Chi saprà rispondere con lucidità, coraggio e intelligenza adattiva, non solo non perderà il proprio posto, costruirà qualcosa di nuovo e superiore.

L'articolo Intelligenza artificiale e lavoro: perché non stiamo assistendo alla fine delle professioni proviene da RENOR & Partners S.r.l..

Durante la fase di sviluppo ci siamo imbattuti in un ostacolo cruciale: garantire che la fotografia degli ingredienti fosse sufficientemente nitida da permettere un’accurata estrazione del testo (OCR) e, di conseguenza, un’analisi affidabile.

Sul backend, Google Cloud Vision fornisce già un indicatore di confidenza dell’OCR; applicando soglie opportune potremmo decidere se proseguire con l’analisi oppure respingere l’immagine per scarsa qualità. Tuttavia, delegare questo controllo al cloud comporta un costo inutile, paghiamo comunque l’invocazione di un servizio esterno anche quando la foto è palesemente inutilizzabile.

Per ridurre al minimo i costi era quindi indispensabile spostare il controllo qualità sul client. Abbiamo sviluppato una funzione JavaScript, basata sulla varianza del Laplaciano, che valuta in tempo reale la nitidezza dell’immagine: la libreria può essere eseguita direttamente durante l’anteprima della fotocamera, evitando di inviare al backend scatti fuori fuoco o mossi.

In questo modo otteniamo una doppia ottimizzazione: l’esperienza utente migliora (il feedback di “immagine sfocata” è immediato) e i costi di elaborazione cloud si riducono sensibilmente.

Misurare la nitidezza di un’immagine con la varianza del Laplaciano

La qualità percettiva di una fotografia dipende in larga misura dalla nitidezza: un’immagine fuori fuoco o affetta da motion blur appare poco gradevole e, in vari ambiti applicativi (visione artificiale, diagnostica, fotografia mobile), può compromettere l’intero processo di analisi automatica.

Esistono numerose tecniche per stimare quantitativamente il livello di sfocatura. In questo articolo presentiamo un approccio rapido, privo di dipendenze esterne e adatto al tempo reale, basato sulla varianza dell’operatore Laplaciano. Partiremo dai fondamenti teorici per poi giungere a un’implementazione completa in JavaScript, corredata da una piccola interfaccia Web per poter effettuare dei test.

L’obiettivo finale sarà quello di costruire un widget che assegni un punteggio da 1 a 10 alla nitidezza di qualsiasi immagine caricata dall’utente.

La nitidezza come problema di frequenze

Ogni immagine digitale può essere vista come la somma di componenti a diverse frequenze spaziali:

• Basse frequenze hanno variazioni lente, aree uniformi e gradienti dolci
• Alte frequenze danno luogo a transizioni brusche, bordi, dettagli fini.

Una sfuocatura agisce come filtro passa-basso ovvero attenua le alte frequenze. Quindi più un’immagine è sfuocata, meno energia residua avremo nello spettro ad alta frequenza.

Il progetto si occuperà quindi di tradurre questa osservazione in un singolo numero facile da interpretare.

La varianza del Laplaciano: da milioni di pixel a un solo numero

Utilizzando la varianza laplaciana blur immagine è possibile discriminare immagini nitide da immagini fuori fuoco senza ricorrere a modelli di intelligenza artificiale.
Ma come possiamo condensare queste informazioni in un singolo valore numerico che descriva in modo oggettivo quanto l’immagine sia nitida?

La risposta più semplice ed efficace è: calcolare la varianza di questi valori.
Per quanto detto prima, un’immagine ben a fuoco presenta molti bordi e transizioni nette quindi i valori del Laplaciano sono ampiamente distribuiti, sia positivi che negativi: c’è quindi alta varianza.
Un’immagine sfocata, attenua i bordi pertanto i valori del Laplaciano sono vicini allo zero e poco variabili: c’è quindi bassa varianza.

La varianza misura proprio quanto i valori si discostino dalla media: più è grande questo scarto, più l’immagine contiene dettagli e risulta nitida.
Nel contesto della computer vision, la varianza laplaciana blur immagine rappresenta una metrica affidabile e computazionalmente leggera.

Definizione matematica

Data una matrice di risposta Laplaciana , dove indica ciascun pixel valido (escludendo il bordo), calcoliamo:

dove:

• è la media dei valori Laplaciani;
• è il numero totale di pixel coinvolti (di solito );
• è la varianza del Laplaciano, cioè il nostro indicatore di nitidezza.

Ora dobbiamo passare da un valore grezzo a uno score interpretabile.

I valori di dipendono da variabili hardware e ambientali: risoluzione, rumore, compressione JPEG, qualità della lente. Perciò non ha senso usare una soglia fissa: occorre normalizzare il valore rispetto a un intervallo empirico.

Definiamo:

• : varianza tipica di una foto molto sfocata → corrisponde a score 1;
• : varianza tipica di una foto perfettamente nitida → corrisponde a score 10.

Quindi:

Dopo il calcolo, il valore viene arrotondato all’intero più vicino per restituire un punteggio compreso tra 1 e 10. Questo approccio rende il risultato leggibile anche per l’utente finale, oltre che utile per logiche di controllo lato software.

Il valore numerico restituito dalla varianza laplaciana blur immagine cresce all’aumentare dei dettagli ad alta frequenza.

Implementazione in JavaScript

L’algoritmo può essere implementato in JavaScript puro utilizzando le API Canvas per accedere ai pixel di un’immagine caricata o ripresa da fotocamera. La funzione seguente prende in input un elemento HTML (<img>, <canvas>, <video> o ImageBitmap) e restituisce un oggetto con score (1–10) e variance.

/**
 * Evaluate image sharpness using Laplacian variance.
 *
 * @param {HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|ImageBitmap} source
 * @param {{ thresholdMin?: number, thresholdMax?: number }=} opts
 * @return {Promise<{ score: number, variance: number }>}
 */
export async function blurMeter(source, opts = {}) {
  const T_min = opts.thresholdMin ?? 9;   // calibrated: blurry photo
  const T_max = opts.thresholdMax ?? 50;  // calibrated: sharp photo

  // 1. Prepare off-screen canvas
  const w =
    source.width ||
    source.videoWidth ||
    source.naturalWidth;

  const h =
    source.height ||
    source.videoHeight ||
    source.naturalHeight;

  if (!w || !h) {
    throw new Error("Source has invalid dimensions");
  }

  const off =
    typeof OffscreenCanvas === "function"
      ? new OffscreenCanvas(w, h)
      : (() => {
          const c = document.createElement("canvas");
          c.width = w;
          c.height = h;
          return c;
        })();

  const ctx = off.getContext("2d");
  ctx.drawImage(source, 0, 0, w, h);

  const { data } = ctx.getImageData(0, 0, w, h);

  // 2. Convert to grayscale
  const gray = new Float32Array(w * h);
  for (let i = 0, j = 0; i < data.length; i += 4, ++j) {
    gray[j] =
      0.299 * data[i] +
      0.587 * data[i + 1] +
      0.114 * data[i + 2];
  }

  // 3. Apply Laplacian (4-neighbour kernel)
  const lap = new Float32Array(w * h);
  const idx = (x, y) => y * w + x;

  for (let y = 1; y < h - 1; ++y) {
    for (let x = 1; x < w - 1; ++x) {
      const i = idx(x, y);
      lap[i] =
        4 * gray[i] -
        gray[idx(x - 1, y)] -
        gray[idx(x + 1, y)] -
        gray[idx(x, y - 1)] -
        gray[idx(x, y + 1)];
    }
  }

  // 4. Compute variance
  let sum = 0;
  let sumSq = 0;
  const count = (w - 2) * (h - 2);

  for (let y = 1; y < h - 1; ++y) {
    for (let x = 1; x < w - 1; ++x) {
      const v = lap[idx(x, y)];
      sum += v;
      sumSq += v * v;
    }
  }

  const mean = sum / count;
  const variance = sumSq / count - mean * mean;

  // 5. Map to score
  const norm = Math.max(
    0,
    Math.min(1, (variance - T_min) / (T_max - T_min))
  );

  const score = Math.round(1 + 9 * norm);

  return { score, variance };
}

/**
 * Evaluate image sharpness using Laplacian variance.
 *
 * @param {HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|ImageBitmap} source
 * @param {{ thresholdMin?: number, thresholdMax?: number }=} opts
 * @return {Promise<{ score: number, variance: number }>}
 */
export async function blurMeter(source, opts = {}) {
  const T_min = opts.thresholdMin ?? 9;   // calibrated: blurry photo
  const T_max = opts.thresholdMax ?? 50;  // calibrated: sharp photo

  // 1. Prepare off-screen canvas
  const w =
    source.width ||
    source.videoWidth ||
    source.naturalWidth;

  const h =
    source.height ||
    source.videoHeight ||
    source.naturalHeight;

  if (!w || !h) {
    throw new Error("Source has invalid dimensions");
  }

  const off =
    typeof OffscreenCanvas === "function"
      ? new OffscreenCanvas(w, h)
      : (() => {
          const c = document.createElement("canvas");
          c.width = w;
          c.height = h;
          return c;
        })();

  const ctx = off.getContext("2d");
  ctx.drawImage(source, 0, 0, w, h);

  const { data } = ctx.getImageData(0, 0, w, h);

  // 2. Convert to grayscale
  const gray = new Float32Array(w * h);
  for (let i = 0, j = 0; i < data.length; i += 4, ++j) {
    gray[j] =
      0.299 * data[i] +
      0.587 * data[i + 1] +
      0.114 * data[i + 2];
  }

  // 3. Apply Laplacian (4-neighbour kernel)
  const lap = new Float32Array(w * h);
  const idx = (x, y) => y * w + x;

  for (let y = 1; y < h - 1; ++y) {
    for (let x = 1; x < w - 1; ++x) {
      const i = idx(x, y);
      lap[i] =
        4 * gray[i] -
        gray[idx(x - 1, y)] -
        gray[idx(x + 1, y)] -
        gray[idx(x, y - 1)] -
        gray[idx(x, y + 1)];
    }
  }

  // 4. Compute variance
  let sum = 0;
  let sumSq = 0;
  const count = (w - 2) * (h - 2);

  for (let y = 1; y < h - 1; ++y) {
    for (let x = 1; x < w - 1; ++x) {
      const v = lap[idx(x, y)];
      sum += v;
      sumSq += v * v;
    }
  }

  const mean = sum / count;
  const variance = sumSq / count - mean * mean;

  // 5. Map to score
  const norm = Math.max(
    0,
    Math.min(1, (variance - T_min) / (T_max - T_min))
  );

  const score = Math.round(1 + 9 * norm);

  return { score, variance };
}

Questa funzione è leggera, autonoma e può essere eseguita direttamente lato client, ad esempio in un’applicazione web per fotocamera live o analisi immagini.

Prossimo passo: creiamo un’interfaccia semplice con HTML e Tailwind per usare questa funzione in modo interattivo.

Interfaccia HTML + Tailwind

Consumiamo ora la funzione in una semplice interfaccia utente realizzata in HTML e Tailwind che permette all’utente di caricare un’immagine, visualizzarne l’anteprima e ricevere immediatamente uno score di nitidezza con una barra colorata da rosso (sfuocato) a verde (nitido).

<!DOCTYPE html>
<html lang="it">
<head>
  <meta charset="UTF-8">
  <title>Blur Meter Demo</title>

  <!-- Tailwind CSS via CDN -->
  <script src="https://cdn.tailwindcss.com"></script>

  <meta name="viewport" content="width=device-width, initial-scale=1">
</head>

<body class="min-h-screen bg-slate-100 flex items-center justify-center p-4">
  <div class="w-full max-w-lg bg-white shadow-xl rounded-2xl p-6 space-y-6">
    <h1 class="text-2xl font-semibold text-center">
      Image Blur Meter
    </h1>

    <!-- File input -->
    <label class="flex flex-col items-center justify-center w-full h-40 px-4 transition bg-white border-2 border-dashed rounded-lg cursor-pointer hover:border-indigo-500">
      <span class="text-sm text-gray-500">
        Click here to upload an image
      </span>
      <input
        id="uploader"
        type="file"
        accept="image/*"
        class="hidden"
      >
    </label>

    <!-- Image preview -->
    <div id="previewWrapper" class="hidden">
      <img
        id="preview"
        alt="preview"
        class="mx-auto max-h-64 rounded-lg shadow-md"
      >
    </div>

    <!-- Results -->
    <div id="result" class="hidden space-y-3">
      <p
        id="scoreText"
        class="text-center text-lg font-medium"
      ></p>

      <!-- Progress bar -->
      <div class="w-full bg-gray-200 rounded-full h-4">
        <div
          id="scoreBar"
          class="h-4 rounded-full transition-all duration-500"
          style="width: 0%;"
        ></div>
      </div>

      <p
        id="varianceText"
        class="text-center text-sm text-gray-500"
      ></p>
    </div>
  </div>

  <script type="module">
    import { blurMeter } from './js/blur-meter.js';

    const uploader     = document.getElementById('uploader');
    const preview      = document.getElementById('preview');
    const previewWrap  = document.getElementById('previewWrapper');
    const scoreText    = document.getElementById('scoreText');
    const varianceText = document.getElementById('varianceText');
    const scoreBar     = document.getElementById('scoreBar');
    const resultBlock  = document.getElementById('result');

    const scoreToColor = score => {
      const t = (score - 1) / 9;
      const r = Math.round(220 + (22  - 220) * t);
      const g = Math.round( 38 + (163 -  38) * t);
      const b = Math.round( 38 + ( 74  -  38) * t);
      return `rgb(${r}, ${g}, ${b})`;
    };

    uploader.addEventListener('change', async event => {
      const file = event.target.files[0];
      if (!file) return;

      const url = URL.createObjectURL(file);
      preview.src = url;
      previewWrap.classList.remove('hidden');

      await new Promise(resolve => {
        preview.onload = resolve;
      });

      const { score, variance } = await blurMeter(preview);

      scoreText.textContent =
        `Sharpness Score: ${score}/10`;

      varianceText.textContent =
        `Laplacian variance: ${variance.toFixed(2)}`;

      const percent = ((score - 1) / 9) * 100;
      scoreBar.style.width = percent + '%';
      scoreBar.style.backgroundColor = scoreToColor(score);

      resultBlock.classList.remove('hidden');

      URL.revokeObjectURL(url);
    });
  </script>
</body>
</html>

<!DOCTYPE html>
<html lang="it">
<head>
  <meta charset="UTF-8">
  <title>Blur Meter Demo</title>

  <!-- Tailwind CSS via CDN -->
  <script src="https://cdn.tailwindcss.com"></script>

  <meta name="viewport" content="width=device-width, initial-scale=1">
</head>

<body class="min-h-screen bg-slate-100 flex items-center justify-center p-4">
  <div class="w-full max-w-lg bg-white shadow-xl rounded-2xl p-6 space-y-6">
    <h1 class="text-2xl font-semibold text-center">
      Image Blur Meter
    </h1>

    <!-- File input -->
    <label class="flex flex-col items-center justify-center w-full h-40 px-4 transition bg-white border-2 border-dashed rounded-lg cursor-pointer hover:border-indigo-500">
      <span class="text-sm text-gray-500">
        Click here to upload an image
      </span>
      <input
        id="uploader"
        type="file"
        accept="image/*"
        class="hidden"
      >
    </label>

    <!-- Image preview -->
    <div id="previewWrapper" class="hidden">
      <img
        id="preview"
        alt="preview"
        class="mx-auto max-h-64 rounded-lg shadow-md"
      >
    </div>

    <!-- Results -->
    <div id="result" class="hidden space-y-3">
      <p
        id="scoreText"
        class="text-center text-lg font-medium"
      ></p>

      <!-- Progress bar -->
      <div class="w-full bg-gray-200 rounded-full h-4">
        <div
          id="scoreBar"
          class="h-4 rounded-full transition-all duration-500"
          style="width: 0%;"
        ></div>
      </div>

      <p
        id="varianceText"
        class="text-center text-sm text-gray-500"
      ></p>
    </div>
  </div>

  <script type="module">
    import { blurMeter } from './js/blur-meter.js';

    const uploader     = document.getElementById('uploader');
    const preview      = document.getElementById('preview');
    const previewWrap  = document.getElementById('previewWrapper');
    const scoreText    = document.getElementById('scoreText');
    const varianceText = document.getElementById('varianceText');
    const scoreBar     = document.getElementById('scoreBar');
    const resultBlock  = document.getElementById('result');

    const scoreToColor = score => {
      const t = (score - 1) / 9;
      const r = Math.round(220 + (22  - 220) * t);
      const g = Math.round( 38 + (163 -  38) * t);
      const b = Math.round( 38 + ( 74  -  38) * t);
      return `rgb(${r}, ${g}, ${b})`;
    };

    uploader.addEventListener('change', async event => {
      const file = event.target.files[0];
      if (!file) return;

      const url = URL.createObjectURL(file);
      preview.src = url;
      previewWrap.classList.remove('hidden');

      await new Promise(resolve => {
        preview.onload = resolve;
      });

      const { score, variance } = await blurMeter(preview);

      scoreText.textContent =
        `Sharpness Score: ${score}/10`;

      varianceText.textContent =
        `Laplacian variance: ${variance.toFixed(2)}`;

      const percent = ((score - 1) / 9) * 100;
      scoreBar.style.width = percent + '%';
      scoreBar.style.backgroundColor = scoreToColor(score);

      resultBlock.classList.remove('hidden');

      URL.revokeObjectURL(url);
    });
  </script>
</body>
</html>

Test di funzionamento

Abbiamo testato la funzione su tre diverse tipologie di immagine…

Completamente sfuocata

Moderatamente sfuocata

Nitida

Conclusione

In conclusione, la varianza laplaciana blur immagine è ideale per pipeline di image processing deterministiche. La sua forza risiede nella rapidità computazionale, nell’assenza di dipendenze esterne e nella coerenza con la percezione visiva umana.

Nel nostro caso d’uso, applicato all’App CeliachIA, questa metrica ci ha permesso di anticipare il controllo qualità direttamente sul dispositivo dell’utente, evitando costi superflui di invocazioni cloud quando le immagini non sono idonee all’analisi OCR.

La pipeline realizzata con JavaScript e Canvas API, abbinata a una semplice interfaccia web sviluppata con Tailwind, rappresenta un esempio concredo di come concetti matematici e strumenti ingegneristici possano confluire in una soluzione robusta, economica e user-friendly.

In definitiva, dotarsi di un sistema automatico di scoring della nitidezza non è solo un vezzo tecnic, ma una componente essenziale per garantire qualità, efficienza e sostenibilità nelle pipeline di analisi delle immagini moderne.

Potete scaricare questo strumento dal mio account GitHub al link: https://github.com/thesimon82/Laplacian-Blur-Detector/

L'articolo Valutazione del livello di Blur tramite Varianza Laplaciana proviene da RENOR & Partners S.r.l..

L’intelligenza artificiale è, senza ombra di dubbio, una delle più importanti evoluzioni tecnologiche e “scoperte” del nostro tempo. Uso il termine “scoperte” tra virgolette perché in realtà, la teoria alla base dell’AI risale addirittura al 1956, anno della celebre conferenza di Dartmouth che ne sancì la nascita ufficiale.
Eppure, solo negli ultimi anni, l’AI ha fatto irruzione nell’universo consumer e manageriale, diventando una parola magica buona per ogni contesto: marketing, prodotti, slide per gli investitori, report aziendali, ecc.
È uno dei tanti esempi di AI washing, ovvero l’uso dell’intelligenza artificiale come etichetta alla moda anche quando una soluzione deterministica sarebbe più che sufficiente.

Il punto è che, se ieri la moda era l’iPhone, oggi la moda è l’intelligenza artificiale, in piena logica di AI washing. Tutti vogliono inserirla ovunque, anche dove non c’è nessuna necessità di integrarla. A volte infatti, non è solamente inutile: è meno efficiente, più fragile e più costosa da mantenere rispetto ad un classico algoritmo a stati finiti. Ma poco importa: l’importante è dire che c’è l’AI.

Per spiegare meglio cosa intendo, voglio partire da un esempio lampante e assolutamente reale.

AI? No, basta un while: il caso del PDF intelligente

Poco tempo fa per una società di somministrazione che abbiamo come cliente, mi è stato chiesto di sviluppare qualcosa che li aiutasse ad inviare tutte le CU. Parlando di migliaia di dipendenti potete immaginare il tempo che avrebbe tolto ai poveri operatori amministrativi, spacchettare manualmente un PDF contenente tutte le CU di tutti i dipendenti, ed inviarle una ad una manualmente.

Immaginiamo quindi di avere un PDF testuale, contenente migliaia di Certificazioni Uniche, di ogni dipendente. Migliaia di documenti multipli di utenti consecutivi. Ogni utente ha la sua CU che può avere 8, 10, 12 pagine e noi vogliamo dividerlo in tanti PDF quanti sono i dipendenti presenti.

Uno sviluppatore cosa farebbe?
Per prima cosa aprirebbe il file da dividere, lo analizzerebbe, e si accorgerebbe che la prima pagina di ogni CU di ogni utente contiene in intestazione il codice fiscale. Bene: c’è un pattern!
Cosa pensa allora?

“Fantastico! Scrivo uno script con una while che mi cicla ogni pagina del documento partendo dalla prima fino all’ultima, all’interno del ciclo inserisco una regex che mi cerchi un codice fiscale, lo valido per essere certo che quello che mi ha pescato sia effettivamente un codice fiscale e se la validazione va a buon fine, segno quella pagina come inizio di una nuova CU del dipendente. Proseguendo nell’elaborazione delle altre pagine, appena ne trovo un altro, salvo tutto il blocco precedente in un nuovo PDF e lo invio in allegato ad una mail estraendo dal DB i dati del dipendente utilizzando come parametro di ricerca proprio il codice fiscale che ho nella mia bella variabile e proseguo così fino alla fine”.

Soluzione elegante. Lineare. Leggibile. Affidabile e soprattutto molto veloce!
Nessuna AI. Solo logica strutturata, programmazione deterministica e analisi del pattern.

Eppure volevano l’AI: “Ma non possiamo usare l’AI per individuare automaticamente dove inizia ogni documento?”.

Certo che puoi utilizzare l’AI, ma utilizzare l’AI per capire da quale pagina a quale pagina inizi e finisca una CU è come dotarsi di un cannone laser per uccidere una formica. Inoltre l’AI ha tempi molto lunghi di inferenza, rispetto all’algoritmo deterministico che processa enormi moli di dati in pochi secondi.

Ma i costi?

Certamente! Ci sono anche i costi!
Processare un documento con migliaia di CU dei dipendenti e decine di migliaia di pagine oltre a richiedere tempi lunghi ha costi che possono essere tutt’altro che indifferenti. A seconda del modello si potrebbero spendere anche più di 500 euro per processare decine di migliaia di pagine PDF.

AI washing e determinismo: due approcci a confronto

Una volta chiarito che nel nostro esempio del PDF la soluzione più semplice ed efficace è deterministica, vale la pena riflettere più in generale su quando conviene usare un approccio logico e prevedibile e quando invece può aver senso introdurre un layer di intelligenza artificiale.

L’approccio deterministico

Logico, trasparente, tracciabile

Un algoritmo deterministico è composto da regole esplicite e comportamenti prevedibili. Per ogni input noto, l’output è garantito e replicabile. Non impara, ma fa esattamente ciò che gli dici di fare.

Nel caso del nostro PDF la struttura è chiara perché abbiamo il pattern fisso del codice fiscale, la variabilità è praticamente nulla e l’obiettivo è definibile logicamente. In questi casi l’approccio deterministico ha enormi vantaggi: ha molta efficienza computazionale e può quindi girare con successo anche su dispositivi con risorse minime. È affidabile, facilmente testabile ed è possibile effettuare debug immediato. L’intero flusso è comprensibile anche da un team non esperto di Machine Learning. Ed è per questo che andare oltre questa soluzione perché vogliamo l’AI è oltre che ingiustificato anche controproducente.

L’approccio AI-driven

Flessibile ma scarsamente prevedibile, costoso e non sempre giustificabile.

Quando si parla di AI s’intendono spesso sistemi capaci di apprendere da esempi (machine learning), generalizzare pattern anche in contesti non perfettamente definiti, gestire ambiguità e rumore nei dati. Tutto questo è utile se e solo se i dati non seguono pattern rigidi o non noti a priori, il contesto è caotico, ad esempio OCR su foto scattate da smartphone che hanno una variabilità di qualità imprevedibile oppure per ultimo la logica esplicita fallisce perché i casi limite sono infiniti o comunque imprevedibili.

Nel nostro esempio del PDF, non ci sono ambiguità, non c’è rumore: usare una rete neurale per individuare il codice fiscale è uno spreco, sia tecnica che economico.

Tutto ciò però non impedisce a certe aziende, guidate più dalla moda che dall’ingegneria e da una logica di AI washing, di proporre soluzioni tipo: “addestriamo un modello NLP per riconoscere le intestazioni oppure usiamo GPT per segmentare i documenti, o ancora usiamo un classificatore supervisionato per capire se un documento è l’inizio o no… tutto ciò per… Fare quello che un preg_match() risolve in una riga di codice.

Ritorniamo coi piedi per terra e ricordiamoci che l’AI per quando impressionante è solo uno strumento. Non esiste o comunque, almeno per uno sviluppatore, non dovrebbe esistere una guerra tra approccio deterministico e AI. Sono entrambi strumenti… Ma la logica ingegneristica ci insegna a scegliere lo strumento più semplice, efficace e giustificato per il problema che deve risolvere. L’AI ha senso dove il determinismo non arriva: visione artificiale su immagini sfocate, riconoscimento del parlato, predizioni basate su serie storiche complesse, analisi semantica profonda. Ma laddove esiste una regola, una struttura prevedibile, una logica valida, l’intelligenza artificiale non è solo inutile: è rumore, complicazione e costo.

L’intelligenza non è artificiale, è progettuale

L’intelligenza artificiale è uno strumento straordinario ma come tutti gli strumenti potenti, va maneggiata con giudizio. Non è una bacchetta magica da agitare sopra ogni problema, né una chiave da infilare nei pitch per far colpo sugli investitori.

C’è una differenza sostanziale tra fare innovazione e fare finta innovazione. Oggi, troppe soluzioni vengono pensate partendo dallo strumento e non dal problema.
Il risultato sono sistemi sovra-ingegnerizzati, costosi, fragili, spesso anche poco reattivi e in definitiva inutili.

Scusate tanto, ma se entrate in un’azienda per risolvergli dei problemi ed efficientarla tecnologicamente la prima cosa che fate qual’è? Vedere dove si può applicare l’Intelligenza Artificiale? Oppure comprendere da dove nasce il dato, come si muove, studiare come lavora l’azienda, identificare i processi macchinosi che possono essere automatizzati e poi proporre delle soluzioni in base ai problemi riscontrati?

Direi ad occhi chiusi la seconda!

Nel mondo reale, l’ingegneria buona è quella che risolve il problema nel modo più semplice, elegante e sostenibile possibile, evitando l’AI washing. Anche se non fa notizia. Anche se non c’è scritto “AI-powered”.

Il futuro dell’informatica non sarà dominato da chi infila modelli neurali ovunque, ma da chi sa scegliere quando serve davvero. Da chi ha il coraggio di dire: “No, qui basta una if()”.

Forse proprio da questa sobrietà tecnica potrà rinascere un’idea nuova di competenza: una che non si misura in buzzwords, ma in chiarezza progettuale, efficienza e responsabilità.

L'articolo AI washing: quando basterebbe una if() proviene da RENOR & Partners S.r.l..

È l’effetto del sexy secondo algoritmo, una nuova forma di attrazione costruita dall’intelligenza artificiale a partire dai nostri stessi dati. Questo sarà un articolo poco tecnico, per chi si avvicina o vuole sapere qualcosa di più sull’intelligenza artificiale. Nel giro di pochi anni l’AI ha imparato a generare immagini di donne talmente realistiche, seducenti e perfettamente composte da confondersi con modelle vere, dando forma a una nuova bellezza artificiale. Ma come fa una macchina, priva di emozioni, desideri o esperienza sensoriale, a capire cosa significa ‘essere sexy’ al punto da generare effettivamente un’immagine che evochi questo status? Se vuoi approfondire, per capire come funzionano i modelli generativi di immagini, vedi DALL·E, un algoritmo sviluppato da OpenAI capace di generare immagini a partire da descrizioni testuali clicca qui.

La risposta è nei dati

L’AI non desidera… Calcola; e per farlo ha visto milioni di immagini, dai ritratti rinascimentali ai selfie su Instagram, dalle copertine dei primi Playboy alle fotografie di moda. Interessante anche il progetto StyleGAN. Ogni curva, ogni posa, ogni sguardo, sono stati scomposti in vettori, metriche, pesi e correlazioni statistiche. Quando chiedi all’AI di creare una foto di una donna sexy, l’algoritmo non inventa nulla, si limita unicamente a ricomporre il desiderio medio globale. Il risultato finale è una donna generata da AI che incarna il compromesso statistico del desiderio collettivo.

La foto che otteniamo è pertanto una media di tratti, proporzioni fisiche, grandezza di seno, trucco, ecc. che rientrano nella media del desiderio medio delle persone nel mondo.

Questo ovviamente solleva un problema di natura filologica…

Chi decide cose è sexy e cosa no?

“La bellezza è soggettiva“ quanti di voi non hanno mai sentito questa frase? La si dice talmente tante volte che ormai la si ritiene lapalissiana, vera a prescindere.

Io non sono d’accordo! Perché se la bellezza fosse davvero soggettiva, allora dovremmo accettare anche l’idea che una persona universalmente riconosciuta bella possa essere definita brutta. E invece no. Esistono dei limiti, anche alla soggettività.

Prendiamo la nostra Monica Bellucci all’apice della sua bellezza

Se la bellezza fosse soggettiva ciò significherebbe che nel mondo dovrebbe esistere qualcuno capace di ritenere che alla Bellucci gli si possa dare l’appellativo di “Brutta”.

Comprendo che possano esserci persone che, vuoi per preferenze personali, vuoi per antipatie, possano preferire altri tipi di bellezza. C’è chi può preferire una bionda, c’è chi può preferire un seno più piccolo o ancora più grande, ma definire come “Brutta” la Bellucci può essere solo segno di invidia (se pronunciato da donne) o di antipatia (se pronunciato da maschi) ma in realtà entrambi sanno che Monica Bellucci è tutt’altro che brutta.

Con questo ragionamento ne ricavo che la soggettività dell’estetica esiste con alcuni limiti, soprattutto quando entra in gioco un’estetica algoritmica. Abbiamo portato l’esempio della Bellucci ma avremmo potuto parlare di Angelina Jolie, di Cindy Crawford, di Naomi Campbell, di Charlize Theron, come per altri punti di riferimento estetici maschili come Gabriel Garko, Paul Newman, Alain Delon, Henry Cavill, ecc. ecc. L’estetica vera è secondo me qualcosa di oggettivo: il “bello” è bello per definizione.

C’è poi anche una ragione statistica… Se il 99% della popolazione mondiale identifica in una persona il senso estetico, allora si può dire che quella persona conserva delle caratteristiche estetiche oggettive.

La bellezza secondo l’AI

Chi decide dunque cosa è sexy quando a crearla è una macchina che ci guarda? Siamo noi che lo decidiamo. Siamo noi ad educare l’algoritmo, e l’AI non fa altro che restituirci uno specchio: ci mostra i tratti di ciò che è statisticamente ritenuto più sexy dalla maggior parte del mondo. Una donna generata da AI è un ritratto collettivo del nostro gusto inconscio. In questo senso, il sexy secondo algoritmo non è una creazione autonoma della macchina, ma una proiezione matematica delle nostre preferenze aggregate.

La bellezza, dicevano, è negli occhi di chi guarda. Ma oggi quegli occhi sono digitali e imparano in fretta!

Sexy secondo algoritmo è un viaggio nell’intelligenza artificiale e bellezza, fatto di prompt, reti neurali e desideri che non sappiamo più distinguere dalla realtà.

E tu? Pensi davvero che la bellezza sia soggettiva? Oppure l’intelligenza artificiale ha svelato qualcosa che non vogliamo ammettere?

Perché questa donna non esiste, ma ci seduce comunque.

L'articolo Sexy secondo algoritmo: la nuova estetica creata da chi ci osserva proviene da RENOR & Partners S.r.l..

Introduzione

Fino a ieri, per ottenere un profilo dettagliato su una persona, che si trattasse di un potenziale partner, un candidato, un investitore o un competitor, dovevi svolgere ricerche che potevano richiedere ore tra LinkedIn, Google, articoli, Curriculum, social network, database aziendali, ecc. Oggi, grazie all’Intelligenza Artificiale Generativa e in particolare alla funzione “Deep Search” presente su ChatGPT e altri brand, è possibile automatizzare questo processo in modo sorprendentemente efficace.

Questo articolo ti spiega passo dopo passo come funziona questa tecnologia, quali vantaggi offre rispetto alle ricerche tradizionali, quali accortezze adottare per ottenere risultati utili e come integrarla nei propri flussi di lavoro che attualmente (maggio 2025) non possono essere automatizzati.

Cos’è Deep Search

Deep Search è un insieme di tecniche di prompt engineering e contestualizzazione che permettono di ottenere da ChatGPT un’analisi dettagliata e multidimensionale su un soggetto (persona, azienda, o qualsiasi altra chiave di ricerca), generando una risposta strutturata che include, nel caso di persone ad esempio, aspetti biografici, comportamentali, psicologici, professionali e comunicativi.

Ad esempio a partire da un prompt tipo:

“Analizza Mario Rossi (mariorossi.com)”

Può restituire: una sintesi del profilo professionale, i punti di forza e di debolezza, il tipo MBTI (Myers-Briggs), l’enneatipo psicologico, lo stile decisionale, un’analisi SWOT, il tono comunicativo prevalente, un pitch da presentare a investitori, una stima della reputazione online percepita.

Tutto ciò viene generato in base a informazioni note nella base di dati del modello, inferenze basate su pattern di comportamento comuni e coerenza interna con il prompt iniziale.

È evidente che un’analisi di questo tipo risulti possibile soltanto laddove esista materiale reperibile online da cui l’intelligenza artificiale possa attingere informazioni. In ogni caso, tale attività non costituisce una violazione della privacy della persona, proprio perché si fonda esclusivamente si dati di dominio pubblico già disponibili in rete.

Differenza tra prompt semplice e Deep Search contestuale

Nel mondo dell’intelligenza artificiale generativa, non tutti i prompt sono uguali. Un prompt semplice è una richiesta diretta, spesso formulata in una sola frase, che restituisce una risposta istantanea ma generalmente superficiale. Al contrario, il Deep Search contestuale rappresenta un approccio molto più raffinato e potente: si basa su una conversazione guidata, stratificata, in cui l’utente costruisce il contesto pezzo dopo pezzo, orientando l’AI verso un’analisi profonda e coerente. È come la differenza tra chiedere “Chi è Mario Rossi?” e domandare “Costruisci un profilo professionale e psicologico di Mario Rossi, CEO nel settore fintech, analizzandone punti di forza, debolezze, stile decisionale e impatto comunicativo”. La seconda modalità, attivabile comunque selezionando l’apposito switch, è detta appunto Deep Search, e non si limita a elencare fatti, ma interpreta, connette e deduce, offrendo una sintesi complessa che unisce biografia, attitudini e potenziale evolutivo. È la forma più vicina a un’intervista immaginaria condotta con metodo e intelligenza.

Il concetto di inferenza a partire da parziali

Uno degli aspetti più affascinanti dell’intelligenza artificiale di ultima generazione è la sua capacità di inferire informazioni complesse anche a partire da dati minimi o incompleti. Questo processo, noto come inferenza da dati parziali, si fonda sull’abilità del modello di riconoscere pattern ricorrenti all’interno di vasti insiemi di conoscenze già acquisite durante l’addestramento. In altre parole, l’AI non ha bisogno di sapere “tutto” per ricostruire un quadro verosimile: bastano pochi indizi, un nome, un ruolo, una società, per attivare un meccanismo deduttivo capace di generare una rappresentazione coerente e strutturata della persona o del contesto in esame. Non si tratta di fantasia, ma di plausibilità costruita su logiche statistiche e relazioni probabilistiche tra elementi di informazione.

Questo rende l’intelligenza artificiale non solo uno strumento consultivo, ma un sintetizzatore cognitivo che è in grado di simulare una conoscenza approfondita anche quando il punto di partenza è estremamente frammentario.

Come ChatGPT combina fonti note, pattern e logica deduttiva

Cominciamo col dire che a differenza dei prompt tradizionali che si basano unicamente sulle informazioni memorizzate nel modello, la funzione Deep Search di ChatGPT sfrutta un componente aggiuntivo estremamente potente: la navigazione in tempo reale su internet. Quando si attiva il Deep Search, l’AI accede direttamente al web attraverso Bing, cercando fonti aggiornate e pertinenti per costruire una risposta fondata non solo su interenze statistiche, ma anche su dati attuali, dichiarazioni ufficiali, profili social, articoli di stampa e fonti autorevoli. Questo le permette di aggiornare e ragginare continuamente il profilo analizzato, incorciando fonti note, pattern ricorrenti e logica deduttiva. Il risultato è una rappresentazione profondamente contestualizzata, che unisce l’immediatezza dell’intelligenza generativa con la precisione della ricerca documentale su web, mantenendo un equilibri tra deduzione e verifica. È questa sinergia tra AI e Web Crawling intelligente che rende il Deep Search uno strumento senza precedenti per ottenere informazioni strategiche su persone, aziende o fenomeni in tempo reale.

In quali contesti può tornare utile fare un Profilo AI

L’intelligenza Artificiale non ha sentimenti e si limita a fornire analisi oggettive rispetto alle informazioni che trova online. Tra i contesti in cui può tornare utile troviamo:

Quando la usiamo a livello personale

L’analisi tramite Deep Search può rivelarsi estremamente preziosa a livello personale. Chiedere all’intelligenza artificiale una valutazione netrua e contestualizzata del proprio profilo, permette di osservare sé stessi con uno sguoardo esterno, asettico e senza emotività alcuna. Questo tipo di autoriflessione assistita può aiutare a mettere in luce punti di forza spesso sottovalutati, ma soprattutto a identificare con chiarezza le aree di miglioramento, gli atteggiamenti disfunzionali o i limiti comportamentali che ostacolano la crescita personale o professionale. È come tenere uno specchio davanti alla propria figura, ma con l’obiettività analitica di uno strumento che non giudica: osserva, elabora e propone spunti costruttivi.

Certamente bisogna essere pronti a ricevere anche delle critiche, che potrebbero mettere in luce aspetti poco valorizzati o addirittura fragilità che si tende a ignorare. In buona sostanza bisogna pensare che un’analisi condotta da un sistema che non è influenzato da affetti non restituisce un giudizio, ma un qualcosa che può tornarci utile per evolvere. Serve lucidità, apertura mentale e senso di autocritica.

Quando la usiamo nella fase intermedia di colloqui di lavoro

Nel processo di selezione per ruoli ingegneristici, dove il recruiting si articola in più fasi, l’introduzione del Deep Search può rappresentare un valido supporto nella fase intermedia del percorso. Dopo l’analisi curriculare e il primo colloquio conoscitivo, e prima del colloquio tecnico è possibile inserire una fase di analisi approfondita tramite intelligenza artificiale. In questo momento il recruiter può fornire a ChatGPT le informazioni già emerse durante il colloquio (come risposte fornite, atteggiamenti osservati, impressioni preliminari), arricchendole con una ricerca aggiornata sul web. Il modello è così in grado di restituire una valutazione neutra, contestuale e ragionata del candidato, evidenziandone la coerenza tra immagine online e comunicazione personale, le competenze trasversali potenzialmente non dichiarate, lo stile relazionale e la compatibilità culturale con l’azienda. Questo approccio non sostituisce il giudizio umano, ma lo affianca con una lente analitica oggettiva, utile per prendere decisioni più informate e complete.

Quando la vogliamo usare per applicazioni in ambito investigativo, legale o accademico

Oltre all’utilizzo in ambito personale, HR e commerciale, la funzione di Deep Search trova applicazioni interessanti anche in contesti investigativi, legali e accademici. Nel settore investigativo, può essere impiegata per costruire profili preliminari su soggetti di interesse, ricostruendo connessioni, attività pregresse, tracce digitali e comportamenti pubblicamente documentati, il tutto senza accedere ad archivi riservati o violare la privacy. In ambito legale, può supportare gli avvocati o i consulenti tecnici nella raccolta contestuale di informazioni pubbliche su controparti, testimoni, esperti o aziende coinvolte in procedimenti, fornendo un quadro sintetico ma strutturato che agevola l’impostazione delle controparti, testimoni, esperti o aziende coinvolte in procedimenti, fornendo un quadro sintetico ma strutturato che agevola l’impostazione delle strategie difensive o negoziali. Sul versante accademico, invece, il Deep Search si rivela utile per analizzare rapidamente il profilo di autori, studiosi o ricercatori, generare panoramiche bibliografiche di base o confrontare approcci teorici tra scuole di pensiero. Naturalmente in tutti questi casi è fondamentale ricordare che l’AI si limita a rielaborare informazioni pubblicamente accessibili, restituendo interpretazioni plausibili e ordinate, ma non certificazioni né prove giuridicamente valide. È uno strumento di supporto e orientamento, non un sostituto delle fonti ufficiali.

Posso chiedere altro?

Certamente si, una volta effettuata la ricerca è possibile richiedere qualsiasi altro tipo di informazione deducibile dalla ricerca profonda effettuata.

Ad esempio: “Forniscimi un’analisi SWOT di Mario rossi”.

Il modello elaborerà quindi punti di forza, debolezza, opportunità e minacce, in relazione al contesto professionale, alla posizione attuale e alle competenze dichiarate o dedotte. Ma non ci si ferma qui: si può proseguire chiedendo una valutazione del tipo di leadership, una simulazione di colloquio comportamentale, un pitch da presentare a potenziali investitori, oppure un’analisi di compatibilità culturale con una determinata azienda.

Questo rende il Deep Search non un semplice strumento informativo, ma un ambiente di dialogo strategico, dove ogni informazione diventa il punto di partenza per una nuova inferenza, una nuova visione, un nuovo scenario di utilizzo, completamente personalizzabile in base agli obiettivi di chi lo utilizza.

Conclusioni

L’introduzione del Deep Search nelle interazioni con l’AI rappresenta un salto di qualità nell’uso quotidiano dei modelli generativi. Non si tratta più di semplici risposte a domande puntuali, ma di vere e proprie analisi strutturate, condate su un mix di ricerca web in tempo reale, inferenza deduttiva e modellazione cognitiva. Che si tratti di selezione del personale, scouting commerciale, indagini conoscitive, autoanalisi o supporto accademico, Deep Search consente di accorciare i tempi, aumentare la profondità e ampliare la prospettiva con cui si osservano individui e contesti. Come ogni strumento potente, richiede un uso consapevole, responsabile e integrato nel quadro etico e normativo vigente. Ma per chi sa porre le domande giuste e ha il coraggio di ascoltare anche le risposte più scomode, l’AI può diventare un alleato straordinario nella comprensione del mondo e di sé stessi.

[starbox]

L'articolo L’AI che sa tutto di te proviene da RENOR & Partners S.r.l..

Nel precedente articolo ci eravamo lasciati con uno schema realistico della logica applicativa per la suddivisione automatizzata dei rifiuti. Ora è arrivato il momento di iniziare a capire concretamente come questo sistema possa diventare automatizzato. Entriamo quindi nell’affascinante mondo della meccatronica e della robotica.

Per risparmiare tempo nella divisione manuale dei rifiuti, immagino per prima cosa un contenitore in cui poter gettare liberamente i vari scarti. Da qui, ogni rifiuto dovrà essere trasferito automaticamente nella camera dove avverrà l’analisi mediante spettroscopia Raman.

Le soluzioni per trasportare i rifiuti possono essere diverse e qui si apre una scelta cruciale per il progetto: vogliamo puntare su un compromesso pratico o desideriamo poter gestire ogni singolo tipo di rifiuto con precisione assoluta? Se scegliamo la strada più semplice e accettiamo dei compromessi, ad esempio limitandoci a contenitori rigidi come cartoni e bottiglie, potrebbe bastare solamente un nastro trasportatore dotato di palette.

Se invece optiamo per una soluzione più versatile, che ci permetta di identificare e gestire qualsiasi oggetto indipendentemente dalla sua forma o dimensione, allora sarà necessario implementare un braccio robotico dotato di visione artificiale, in grado di riconoscere e selezionare ciascun elemento prima di posizionarlo sul nastro trasportatore.

Per questo progetto, anche al fine di creare un prodotto veramente eco-friendly, scegliamo proprio quest’ultima soluzione, decidendo però di escludere la gestione dell’umido, così da evitare ulteriori complicazioni tecniche come il lavaggio continuo del nastro trasportatore che richiederebbe anche l’accortezza di progettare l’elettronica con un indice di protezione da agenti atmosferici almeno IP65.

Meccanica del dispositivo

Immaginiamo di avere un secchio iniziale contenente diversi tipi di rifiuti. Un braccio robotico, equipaggiato con una telecamera, analizza visivamente i rifiuti, li identifica, li afferra e li colloca su un nastro trasportatore. Questo nastro trasporta ciascun oggetto all’interno di una camera oscura dove è posizionato il nostro spettroscopio Raman. Lo spettroscopio identifica il materiale e, in base al risultato ottenuto, attiva un selettore di percorso: la plastica finirà nel mastello della plastica, il vetro e il metallo nel rispettivo contenitore e la carta nel mastello dedicato alla carta.

Una breve nota personale

Quando ho iniziato a descrivere questo progetto, sembrava relativamente semplice e lineare. Tuttavia dopo un’attenta riflessione, si è rivelato tutt’altro che banale. È affascinante notare come un compito che nella vita quotidiana appare così immediato e semplice, richieda invece una combinazione complessa di conoscenze tecniche.

In questo percorso capiremo insieme come gestire queste sfide e trasformare un’idea iniziale in un prodotto finale realmente funzionante e utile, open-source e che tutti possono autonomamente costruire a patto di avere i macchinari necessari alla creazione delle parti che serviranno a dar vita al prodotto.

Nel prossimo articolo tratteremo la progettazione e la stampa 3D dei vari componenti che andranno a comporre il nostro elemento di trasporto.

[starbox]

L'articolo AI, CV e Spettroscopia per la Gestione dei rifiuti – Parte 2 proviene da RENOR & Partners S.r.l..

Scommetto che è capitato anche a voi: dopo una cena tra amici o un pranzo in famiglia, arriva il momento di sistemare tutto, e improvvisamente la raccolta differenziata è lì che ti attende facendoti perdere tempo. Carta da una parte, plastica dall’altra, vetro e metallo in un altro mastello, umido in quello più piccolo… Un compito che diventa spesso noioso specialmente quando il volume dei rifiuti da dividere cresce notevolmente.

Da qui la domanda… Esiste un modo per rendere tutto questo più semplice, veloce e addirittura automatico? La tecnologia oggi può darci una mano concreta per gestire meglio questa attività quotidiana facendoci risparmiare tempo e fatica?

Come nasce un progetto tecnologico: dall’idea al prodotto finale

In questo periodo, con la grande mole di lavoro che mi ritrovo a gestire, sarà difficile trovare abbastanza tempo da dedicare a questo progetto. Tuttavia, ho deciso che sfrutterò quei pochi momenti liberi che mi restano la sera dopo cena per portarlo avanti e condividerlo con voi passo dopo passo.

Al di là dell’utilità intrinseca di questo progetto, ciò che maggiormente mi interessa, è mostrarvi come, partendo da un’idea iniziale, si arrivi concretamente al prodotto finale. Voglio farvi vedere quali sono le fasi coinvolte nella realizzazione di un progetto che a parole può apparire semplice a prima vista, ma che in realtà è estremamente complesso, perché richiede competenze trasversali ben oltre il semplice sviluppo di codice.

Per completare questo lavoro, infatti, è necessario avere conoscenze approfondite in diversi ambiti: dalla modellazione 3D alla stampa 3D, dalla prototipazione all’elettronica, fino a competenze in fisica, matematica e soprattutto intelligenza artificiale.

In questo articolo (e in quelli che seguiranno) cercherò di guidarvi lungo tutto questo percorso, condividendo con voi le sfide, gli ostacoli e le soluzioni che incontrerò strada facendo. Sarà un modo interessante per scoprire insieme come un’idea innovativa possa trasformarsi in qualcosa di realmente funzionante e la condivideremo con un progetto open-source sul mio canale GitHub.

Valutiamo le prime criticità

Tutti noi facciamo affidamento sui nostri sensi per esplorare e interpretare ciò che ci circonda. Quando riceviamo un oggetto tra le mani, possiamo osservarlo, toccarlo, annusarlo o perfino colpirlo leggermente per ascoltare il suono che produce. A volte arriviamo persino ad assaggiarlo per coglierne il sapore. Possiamo vedere i nostri sensi come le porte che ci permettono di relazionarci con il mondo.

Immaginate di ricevere una bottiglia: vi basterà guardarla o tutt’al più stringerla tra le mani per capire immediatamente se è fatta di vetro o di plastica. Se invece vi dessero un barattolo di pelati, probabilmente notereste il caratteristico colore ferroso, comprendendo così che è realizzato in metallo e se così non fosse potreste stringerla per verificare che resti deformata, perché sapete che il metallo se compresso resta deformato a differenza della plastica che entro certi limiti torna nella sua posizione iniziale.

Tutto questo è possibile grazie all’esperienza cognitiva che abbiamo maturato nel corso della nostra vita.

Ma nel caso di una macchina… Come possiamo trasferire questa capacità di comprensione a una macchina? In che modo può imparare a identificare il materiale di cui è fatto un oggetto?

Emuliamo i sensi

Ci sono diversi approcci…

Uno dei più affascinanti è quello basato sulla Computer Vision, una tecnologia che emula il senso della vista umano.

Questo approccio consiste nell’utilizzare particolari reti neurali artificiali che vengono addestrate a riconoscere vari oggetti, materiali e forme. È esattamente lo stesso principio che permette, ad esempio alle moderne automobili a guida autonoma (senza citare marche famose) di spostarsi con sicurezza sulle nostre strade.

Queste vetture sono dotate di telecamere che analizzano continuamente, centinaia di volte al secondo, tutto ciò che le circonda: strade, segnali stradali, pedoni, altre automobili e potenziali ostacoli. La rete neurale, addestrata accuratamente per mesi o anni, permette al veicolo di identificare ogni oggetto e reagire correttamente: mantenersi all’interno della corsia di marcia, rispettare scrupolosamente i segnali stradali, gli stop, le precedenze, evitare collisioni e calcolare la più sicura via di fuga in caso di pericolo.

Il primo ostacolo: non tutte le reti neurali sono facili da addestrare

Se avete seguito fin qui il discorso, vi sarete sicuramente accorti di un dettaglio importante: poco fa abbiamo parlato di reti neurali addestrate per mesi, se non anni. E qui nasce il primo vero problema del nostro progetto.

La questione infatti non è affatto semplice. Non dobbiamo insegnare a una macchina a riconoscere un pedone, cioè qualcosa che ha una testa, due braccia e due gambe. Qui dobbiamo istruire una rete neurale a capire esattamente di che materiale è fatto un rifiuto. E la difficoltà aumenta se pensiamo che lo stesso prodotto, come ad esempio il latte, può essere confezionato in una bottiglia di plastica per una certa marca, in una bottiglia di vetro per un’altra, oppure in un Tetra Pak per un terza marca ancora.

Se volessimo addestrare una rete neurale a riconoscere con precisione tutti i materiali di confezionamento per ogni singolo alimento presente sul mercato, significherebbe raccogliere e catalogare decine di migliaia, se non centinaia di migliaia di campioni diversi. Occorrerebbe infatti passare in rassegna per più volte ciascuna marca e ciascuna variante di prodotto, generando enormi quantità di dati di addestramento.

È evidente che questa strada non è percorribile in modo pratico e sostenibile. Dobbiamo quindi cercare una soluzione più intelligente, flessibile e scalabile. Una soluzione che consenta alla rete neurale di “generalizzare” tutto ciò che può essere generalizzato, riconoscendo materiali e oggetti sulla base di caratteristiche generali piuttosto che specifiche per ciascun prodotto.

Alcune idee di rinforzo

Sebbene sia difficile per alcuni tipi di rifiuti procedere con l’addestramento di una rete neurale, possiamo comunque sottoporre l’immagine del rifiuto ad una rete neurale già addestrata. Google Cloud Vision ad esempio permette l’analisi delle immagini e nei casi in cui il materiale è visibilmente molto riconoscibile, può assegnare etichette generiche come:

• plastic
• glass
• metal
• carboard
• paper

Il problema è che non è affidabile al 100%, non distingue varianti specifiche (Es. Tetra Pak vs. cartone semplice). Non legge materiali dalla texture o dal suono (cosa che farebbe un essere umano manipolando il prodotto).

C’è però una soluzione alternativa realistica. Un approccio più affidabile potrebbe essere quello di utilizzare Cloud Vision OCR per leggere il testo sull’etichetta del prodotto per poi cercare online le informazioni sul materiale (Bottiglia in PET, Packaging in Tetra Pak).

Cominciamo a schematizzare

Per evitare il rischio di dimenticare alcune cose cominciamo a buttar giù una mappa delle idee ed uno schema funzionale in modo da poterlo modificare man mano che andiamo avanti nel progetto.

Se questa soluzione non restituisce un risultato sicuro?

È possibile che nonostante tutti gli sforzi non venga comunque restituito un risultato sicuro e definitivo. Come ci comportiamo?

1. Possiamo mettere il prodotto in uno stato di verifica manuale (soluzione che non mi piace particolarmente)
2. Possiamo classificare il rifiuto come indifferenziato (anche questa soluzione non è particolarmente eco-friendly)
3. Possiamo cercare altri modi per comprendere il materiale del prodotto.

Concentriamoci sulla terza soluzione.

Quali altre possibilità ci sono per identificare un materiale?

Un sistema sicuro, veloce e in tempo reale per identificare un materiale è certamente la spettroscopia, in particolare lo spettroscopio Raman. Questa rappresenta una delle tecniche più affidabili e precise per identificare il materiale, in particolare la composizione chimica di un oggetto, anche in forma solida, liquida o polimerica.

La spettroscopia Raman si basa sull’interazione di una luce laser con una particolare frequenza, con le vibrazioni molecolari del materiale. Quando il laser colpisce un campione, una piccola parte della luce viene diffusa in modo anomalo (effetto Raman), e questo spettro diffuso è caratteristico della struttura molecolare del materiale.

Cosa può identificare uno spettroscopio Raman?

Può identificare con successo Plastica, Vetro, Carta, Composti organici e inorganici e addirittura il Tetra Pak. Non può però identificare i metalli perché i metalli riflettono la luce e non hanno pertanto segnali Raman. Questo può non essere un problema perché per esclusione, se un materiale non è tra quelli elencati è sicuramente in metallo.

Ci sono però delle difficoltà anche qui… Uno spettroscopio Raman può costare, a seconda della qualità, da qualche migliaio di euro a decine di migliaia di euro. A questo però c’è una soluzione… Costruirci un nostro spettroscopio di Raman. Vedremo questa parte in seguito in una serie di articoli dedicati.

Aggiorniamo pertanto i nostri schemi…

Sembrerebbe che in questo modo abbiamo correttamente gestito la logica applicativa del sistema. Abbiamo compreso per sommi capi come dobbiamo muoverci.

C’è ora tutta la parte di trasporto e divisione dei rifiuti che andremo a trattare nel prossimo articolo.

[starbox]

L'articolo AI, CV e Spettroscopia per la Gestione dei rifiuti – Parte 1 proviene da RENOR & Partners S.r.l..

Tuttavia qualche mese fa parlavo con un amico davanti ad uno spritz e abbiamo cominciato, come al solito, a dire una serie di sciocchezze parlando di AI (vi risparmio le idee malsane che ci sono uscite), ma ci siamo poi concentrati su un tema: “Sarebbe possibile creare una rete neurale in PHP?” La risposta breve è sì, seppur con delle limitazioni.

Per comprendere questo articolo bisogno prima fare qualche premessa…

Introduzione

Nel panorama tecnologico odierno l’Intelligenza Artificiale (IA in italiano o AI in inglese), non è più un argomento di nicchia, ma un pilastro strategico per quasi qualsiasi tipo di azienda che vogli estrarre valore dai propri dati, ottimizzare processi e offrire prodotti realmente competitivi. In ambito HR & Workforce management, per esempio, i modelli predittivi permettono di anticipare assenza improvvise, calibrarie i turni in modo dinamico e, per ultimo, risparmiare tempo e risorse: esattamnete il binomio “velocità/qualità” di cui avevamo discusso in questo articolo: https://renor.it/velocita-e-qualita-nei-progetti/.
Ma chi di voi sa veramente cosa sia l’intelligenza artificiale?

AI – Questa blasonata sconosciuta

Con il termine Intelligenza Artificiale si indica l’insieme di tecniche che permettono ad un sistema informatico di mostrare capacità normalmente attribuite all’intelligenza umana: ragionare, apprendere, prendere delle decisioni, riconoscere pattern complessi. All’interno di questo grande contenitore, il Machine Learning rappresenta l’approccio in cui l’apprendimento avviene attraverso l’analisi statistica dei dati, senza che tutte le regole sia codificate manualmente. Negli ultimi anni, l’affermazione del Deep Learning ha dato un’ulteriore spinta evolutiva: reti neurali molto profonde, formate da decine o centinaia di livelli di elaborazione, riescono a cogliere strutture nei dati che sfuggono ai modelli più tradizionali.

A cosa servono le reti neurali?

Una rete neurale artificiale è un modello matematico che si ispira alla struttura dei neuroni del nostro cervello. Del resto quasi tutte le scoperte umane si rifanno all’osservazione di ciò che esiste già in natura.
La struttura neurale del cervello permette di risolvere problemi dove la relazione tra input (ciò che percepiamo dall’esterno) e l’output (ciò che ne ricaviamo) è non lineare o di difficile formalizzazione.

Immaginiamo, ad esempio, di voler prevedere il rischio di ritardo di un dipendente in base a variabili come il traffico, le condizioni meteo, la cronologia personale di ritardi e assenze ed i programmi di trasporto pubblico. Il legame tra questi fattori è troppo complesso per essere descritto con poche istruzioni condizionali, ma una rete neurale ben addestrata può impararlo analizzando una grande quantità di esempi storici.

Il motivo di questa capacità risiede nel fatto che ogni connessione tra neuroni è associata ad un peso e ad un termine di bias. Capiremo poi cosa siano.

Durante la fase di addestramento la rete modifica questi parametri per minimizzare una funzione di errore che misura la discrepanza fra la sua previsione e il valore reale. Il procedimento di affinamento avviene attraverso l’algoritmo di back-propagation, responsabile del calcolo dei gradienti, e un metodo di ottimizzazione come la discesa del gradiente stocastico che aggiorna iterativamente i pesi. Alla fine del processo la rete non possiede una serie di regole scritte da chi l’ha programmata, ma una serie di coefficienti numerici che codificano in modo distribuito la conoscenza ricavata dai dati.

Ora che abbiamo un quadro generale possiamo capire i ruoli e le responsabilità di pesi e bias.

Il peso è il coefficiente numerico che modula l’intensità con cui un segnale in ingresso contribuisce all’attivazione del neurone successivo. Possiamo pensare che sia una manopola di un volume, aumentando il volume amplifichiamo il contributo di quella specifica caratteristica, mentre abbassando il volume la attenuiamo fino a poterne anche invertire il segno. Dal punto di vista matematico il peso moltiplica il valore dell’input e determina l’inclinazione della funzione che la rete sta apprendendo; un peso elevato indica che l’input in questione è fortemente correlato all’output, un peso prossimo allo zero lo rende praticamente irrilevante.

Il bias invece svolge il ruolo di traslatore sommandosi al prodotto tra input e peso, sposta il risultato complessivo verso l’alto o verso il basso prima che venga applicata la funzione di attivazione. Pertanto se i pesi, come abbiamo visto, rappresentano l’inclinazione di una retta, il bias ne rappresenta l’intercetta sull’ordinata, consentendo alla rete di modellare funzioni che non passano necessariamente per l’origine. In pratica il bias permette al neurone di accendersi anche quando tutti gli input sono nulli, introducendo quella flessibilità che rende l’insieme dei modelli neurali un vero e proprio approssimatore.

Durante l’addestramento i pesi e i bias vengono aggiornati con l’algoritmo di back-propagation: il gradiente della funzione di errore indica in quale direzione e di quanto variare ciascun parametro per ridurre lo scarto tra la previsione della rete e il valore reale. Iterazione dopo iterazione, la rete regola questi due tipi di parametri in modo coordinato, affinando sia la pendenza sia la posizione delle sue curve decisionali, fino a catturare la complessità del fenomeno che vogliamo modellare.

In sintesi peso e bias sono i mattoni elementari dell’intelligenza adattiva della rete: il primo controllo l’importanza relativa degli input, il secondo offre la libertà di muoversi nello spazio delle soluzioni senza vincoli geometrici predefiniti.

Perché vale la pena implementarla in PHP?

Ci si potrebbe chiedere se abbia senso costruire una rete neurale in un linguaggio tradizionalmente considerato da backend web. La risposta è sì, per alcune situazioni ben definite. Innanzitutto l’implementazione nativa evita di introdurre un runtime aggiuntivo, tipicamente Python, e dunque semplifica il ciclo di build, test e deploy quando l’intero stack applicativo è già in PHP. Inoltre, per microservizi che richiedono modelli leggeri e inferenze dell’ordine di pochi millisecondi, una soluzione self-contained risulta più che adeguata. Inoltre c’è il caro vecchio aspetto didattico non va sottovalutato: scrivere la rete riga per riga smonta l’aura di “scatola nera” che accompagni molti framework di deep learning e mette gli sviluppatori in condizione di comprendere, ottimizzare e soprattutto debuggare ogni passaggio del calcolo così da avere una panoramica puntuale sul funzionamento di una rete neurale comprendendone a pieno il funzionamento.

Anatomia di una rete neurale feed-forward minimale in PHP

Per proseguire occorre definire l’ossatura di una rete neurale “bare-metal” che possiamo realizzare con il solo motore di PHP, senza dipendere da estensioni C o librerie esterne. In pratica si tratta di modellare, con strutture dati native, tre elementi fondamentali:

1. I Layer – o elementi di elaborazione
2. Le matrici dei pesi
3. I vettori dei bias.

Ogni livello sarà rappresentato da un semplice array bidimensionale di pesi ($weights) e da un array monodimensionale di bias ($biases). Il passaggio di attivazioni fra un layer e l’altro avverrà tramite la classica moltiplicazione matrice-vettore seguita dall’applicazione di una funzione di attivazione (sigmoide, ReLU o tanh a seconda dei casi d’uso). Questo schema minimalista ha il pregio di rimanere leggibile e di faborire il debug passo passo, ma impone alcune scelte progettuali: niente parallelizzazione automatica, niente ottimizazioni SIMD, ed estrema attenzione alla complessità computazionale poiché l’uso spregiudicato di cicli foreach nidificati in PHP può farci impennare i tempi di inferenza.

Nonostante ciò, per reti a una o due hidden layer e un numero di neuroni nell’ordine delle centinaia, le performance rimangono sorprendentemente dignitose se si sfruttano gli op-cache e si evitano allocazioni ridondanti. In sostanza, prima di immergerci nel codice vero e proprio, è importante comprendere che in PHP i neuroni non sono altro che righe di array e i gradienti sono valori float aggiornati dentro un ciclo. La semplicità di implementazione rende facilmente comprensibile l’aritmetica delle rete, rendendo evidente ogni singolo passo dell’apprendimento.

Implementazione in codice: la struttura base della rete neurale

A questo punto dell’articolo è opportuno presentare nei dettagli l’implementazione bare-metal di rete neurale feed-forward a due strati scritta interamente in PHP 8.1. Il codice che segue mantiene la massima trasparenza possibile: ogni operazione matematica è esplicitata mediante semplici cicli for, ogni variabile intermedia è memorizzata in modo da poter essere ispezionata durante il debug e gli unici prerequisiti sono il motore PHP e l’opcache abilitato in produzione.

Per rendere il progetto facilmente riutilizzabile ho suddiviso il codice in due file distinti. Il primo, NeuralNetwork.php, contiene tutta la logica di rete neurale, completa di classi, funzioni di attivazione, forward-pass, back-propagation e routine di training. Il secondo, demo_xor.php, è un semplice script d’esecuzione che importa la classe, istanzia la rete, l’addestra sul classico problema XOR e stampa a video i risultati.

NeuralNetwork.php

<?php
declare(strict_types=1);

/**
 * Minimal feed-forward neural network in pure PHP
 * MIT License – (c) 2025
 */

/* ---------- Activation functions ---------- */

/** Sigmoid activation */
function sigmoid(float $x): float
{
    return 1.0 / (1.0 + exp(-$x));
}

/** Derivative of the sigmoid */
function sigmoid_derivative(float $x): float
{
    $s = sigmoid($x);
    return $s * (1 - $s);
}

/** ReLU activation */
function relu(float $x): float
{
    return max(0.0, $x);
}

/** Derivative of ReLU */
function relu_derivative(float $x): float
{
    return $x > 0 ? 1.0 : 0.0;
}

/* ---------- Layer class ---------- */

final class Layer
{
    public readonly int $in;   // number of input neurons
    public readonly int $out;  // number of output neurons

    /** @var float[][] weight matrix [out][in] */
    public array $W = [];

    /** @var float[] bias vector [out] */
    public array $b = [];

    private array $lastInput  = [];
    private array $lastZ      = [];
    private array $lastOutput = [];

    public function __construct(
        int      $in,
        int      $out,
        callable $act,
        callable $actDer
    ) {
        $this->in           = $in;
        $this->out          = $out;
        $this->activation   = $act;
        $this->activation_d = $actDer;

        // Xavier/Glorot uniform initialization
        $limit = sqrt(6 / ($in + $out));
        for ($i = 0; $i < $out; $i++) {
            $this->b[$i] = 0.0;
            for ($j = 0; $j < $in; $j++) {
                $this->W[$i][$j] = (mt_rand() / mt_getrandmax()) * 2 * $limit - $limit;
            }
        }
    }

    /** Forward propagation */
    public function forward(array $input): array
    {
        $this->lastInput = $input;
        $this->lastZ     = [];
        $this->lastOutput = [];

        for ($i = 0; $i < $this->out; $i++) {
            $z = $this->b[$i];
            for ($j = 0; $j < $this->in; $j++) {
                $z += $this->W[$i][$j] * $input[$j];
            }
            $this->lastZ[$i]      = $z;
            $this->lastOutput[$i] = ($this->activation)($z);
        }
        return $this->lastOutput;
    }

    /** Back-propagation, returns gradient for previous layer */
    public function backward(array $gradOutput, float $lr): array
    {
        $gradInput = array_fill(0, $this->in, 0.0);

        for ($i = 0; $i < $this->out; $i++) {
            $delta = $gradOutput[$i] * ($this->activation_d)($this->lastZ[$i]);

            // Propagate gradient and update weights
            for ($j = 0; $j < $this->in; $j++) {
                $gradInput[$j] += $delta * $this->W[$i][$j];
                $this->W[$i][$j] -= $lr * $delta * $this->lastInput[$j];
            }
            // Update bias
            $this->b[$i] -= $lr * $delta;
        }
        return $gradInput;
    }

    /* callable */ private $activation;
    /* callable */ private $activation_d;
}

/* ---------- NeuralNetwork class ---------- */

final class NeuralNetwork
{
    /** @var Layer[] */
    private array $layers = [];

    /** Add a layer to the network */
    public function addLayer(Layer $layer): void
    {
        $this->layers[] = $layer;
    }

    /** Forward pass through all layers */
    public function predict(array $x): array
    {
        $out = $x;
        foreach ($this->layers as $layer) {
            $out = $layer->forward($out);
        }
        return $out;
    }

    /**
     * Train the network with SGD and mean squared error
     * @param float[][] $xTrain
     * @param float[][] $yTrain
     */
    public function train(
        array $xTrain,
        array $yTrain,
        int   $epochs     = 1000,
        float $lr         = 0.1,
        bool  $verbose    = true,
        int   $logStride  = 100
    ): void {
        $n = count($xTrain);

        for ($e = 1; $e <= $epochs; $e++) {
            $loss = 0.0;

            for ($k = 0; $k < $n; $k++) {
                $out   = $this->predict($xTrain[$k]);

                // MSE derivative: 2*(ŷ - y)
                $grad  = [];
                foreach ($out as $i => $o) {
                    $diff      = $o - $yTrain[$k][$i];
                    $grad[$i]  = 2 * $diff;
                    $loss     += $diff ** 2;
                }

                // Backward pass
                for ($l = count($this->layers) - 1; $l >= 0; $l--) {
                    $grad = $this->layers[$l]->backward($grad, $lr);
                }
            }

            if ($verbose && $e % $logStride === 0) {
                printf("Epoch %d/%d - loss: %.6fn", $e, $epochs, $loss / $n);
            }
        }
    }
}

In questo file troviamo le funzioni di attivazione, sigmoide e ReLU, assieme ai loro gradienti. Averle a livello globale e non incapsulate nella classe, rende più lieve l’over-head di chiamate e permette di passarle come callable direttamente al costruttore dei laure, mantenendo flessibilità senza sacrificare performance.

La classe Layer è dichiarata final per evitare estensioni indesiderate e rappresenta l’unità logica di calcolo. Possiede gli interi in e out marcati readonly, così la loro integrità è garantita per l’intero ciclo di vita dell’oggetto. La matrice dei pesi e il vettore dei bias sono inizializzati secondo Xavier, tecnica che distribuisce i valori su un intervallo proporzionato alla radice del numero totale di connessioni in ingresso e in uscita; questo artificio matematico impedisce che le attivazioni si saturino già alle prime epoche, fenomeno che comprometterebbe l’apprendimento.

dove indica l’uniforme continua tra a e b; il termine sotto radice, , funge da limite superiore e inferiore dell’intervallo di campionamento. In alternativa si può usare una distribuzione gaussiana a media zero con varianza , ma l’espressione qui sopra, adottata nell’esempio di codice, è la forma uniforme originaria proposta da Glorot e Bengio.

Nella propagazione in avanti ogni neurone somma prodotto scalare e bias, poi applica la funzione di attivazione scelta; i risultati intermeti lastInput, lastZ e lastOutput vengono memorizzati per essere riutilizzati in retro-propagazione, così il calcolo del gradiente può procedere senza riconteggiare nulla, ideale per il debug passo-passo. Il metodo backward riceve il gradiente dell’errore dal layer successivo, lo combina con la derivata locale dell’attivazione e aggiorna persi e bias sottraendo una frazione proporzionale al learning rate, restituendo nel contempo il gradiente da inviare allo strato precedente.

Il ciclo interno è interamente manuale, scelta che evidenzia la matematica sottostante e rende il codice perfettamente trasparente anche a chi non ha mai usato librerie specialistiche.

La classe NeuralNetwork, anch’essa final, funge da orchestratore: mantiene l’array di layer e fornisce il metodo predict, che incanala un vettore di input attraverso ciascuno strato. Il metodo train implementa la discesa del gradiente stocastico con errore quadratico medio; scorre sull’insieme di addestramento per un numero di epoche specificato, calcola per ogni esempio la differenza fra output previsto e reale, raddoppia il valore e propaga il gradiente a ritroso aggiornando i layer in ordine inverso. A ogni iterazione somma la perdita per offrire un indicatore globale che, se il flag verbose è attivo, viene stampato a intervalli regolari così da monitorare in tempo reale la convergenza del modello.

Il costruttore del layer accetta callable, quindi, qualora in futuro si volessero usare funzioni di attivazione diverse, basterebbe passarne i riferimenti senza toccare l’architettura.

demo_xor.php

<?php
declare(strict_types=1);

// Include the neural network implementation
require_once __DIR__ . '/NeuralNetwork.php';

// Training data for XOR
$xTrain = [
    [0, 0],
    [0, 1],
    [1, 0],
    [1, 1],
];
$yTrain = [
    [0],
    [1],
    [1],
    [0],
];

// Build the network: 2-3-1 with sigmoid activations
$net = new NeuralNetwork();
$net->addLayer(new Layer(2, 3, 'sigmoid', 'sigmoid_derivative'));
$net->addLayer(new Layer(3, 1, 'sigmoid', 'sigmoid_derivative'));

// Train the network
$net->train($xTrain, $yTrain, epochs: 5000, lr: 0.5, logStride: 500);

// Test predictions
foreach ($xTrain as $sample) {
    $out = $net->predict($sample)[0];
    printf("Input %s ⇒ Output %.4fn", json_encode($sample), $out);
}

In questo frammento funzionale, vengono dichiarati i dataset di addestramento e di verità attesa per il classico problema XOR: quattro coppie di input binari, ciascuna accompagnata dal relativo output, che consentono di verificare la capacità del modello di apprendere una funzione non lineare.

Il cuore logico comincia con l’istanziamento dell’oggetto NeuralNetwork. Viene quindi costruita una topologia a due livelli nascosti: il primo strato accetta le due feature in ingresso e le proietta su tre neuroni di uscita, il secondo riceve quelle tre attivazioni intermedie e restituisce un unico valore scalare. In entrambi i passaggi si impiega la funzione di attivazione sigmoide, scelta per la sua semplciità didattica e per la facilità con cui il suo gradiente viene calcolato nella fase di retro-propagazione.

Riportiamo anche la funzione sigmoide:

dove è la costante di Nepero e rappresenta il valore reale in ingresso al neurone. Questa espressione garantisce un output continuo compreso tra 0 e 1, con un punto di flesso nell’origine che ne determina l’andamento a “S” caratteristico: per valori negativi molto grandi la funzione tende asintoticamente a 0, mentre per valori positivi molto grandi si avvicina a 1. In ambito di apprendimento automatico si ricorre spesso anche alla derivata della sigmoide, utile nella retro-propagazione, la cui forma compatta è

Quest’ultima relazione discende direttamente dalla definizione originaria e consente di calcolare il gradiente senza dover ricorrere ad altre funzioni esponenziali, ottimizzando la fase di aggiornamento dei pesi.

Proseguendo, il metodo train avvia l’allenamento vero e proprio, iterando cinquemila epoche sullo stesso piccolo set di esempi. Con un tasso di apprendimento fissato a 0.5 e un log della perdita ogni cinquecento iterazioni, il ciclo compie la discesa del gradiente sul valore medio dell’errore quadratico, aggiornando pesi e bias di entrambi i layer a ogni osservazione. Al termine dell’addestramneto, un semplice ciclo foreach scorre di nuovo sui quattro pattenr di ingresso, li passa al metodo predict e stampa a schermo le uscite numeriche della rete, permettendo di confrontarle con gli output attesi e di valutarne immediatamente la bontà del modello. In un contesto di produzione, lo stesso schema potrebbe essere incapsulato in un endpoint REST o in un comando da linea di comando, ma in questa forma minimalista offre già una dimostrazione completa di come PHP possa gestire l’intero ciclo di vita di una mini rete neurale, dalla definizione dei layer fino alla previsione finale.

Conclusioni

L’esperimento dimostra che, nonostante PHP non sia nato per il calcolo numerico, è possibile implementare una rete neurale essenziale ma funzionante, addestrarla in tempi ragionevoli su problemi di piccola taglia e distribuirla in produzione senza introdurre un runtime aggiuntivo.

L’inizializzazione Xavier preserva la stabilità del segnale fin dalle prime epoche, la sigmoide garantisce un gradiente ben definito e l’approccio completamente trasparente, primo di blackbox, rende il modello un ottimo strumento didattico: ogni peso, ogni bias e ogni step di retro-propagazione sono sotto il pieno controllo. È chiaro che questa soluzione non intende neanche avvicinarsi a competere con framework ottimizzati su GPU, ma quando l’obiettivo è integrare inferenze leggere in uno stack già scritto in PHP, o semplicemente ocmprendere intimamente come funziona una rete neurale, l’implementazione presentata offre una via elegante e facile.

In conclusione, l’aspetto più interessante di questo articolo non voleva essere costruire un nuovo ChatGPT ma dare consapevolezza ed apprendere i principi matematici, riga dopo riga alla base della costruzione di una semplice rete neurale.

La vera potenza dell’intelligenza artificiale risiede secondo me nella comprensione dei principi scientifici su cui si basa e non tanto sui linguaggi che utilizziamo per codificarla.

[starbox]

L'articolo Reti neurali in PHP? Si può fare! proviene da RENOR & Partners S.r.l..

Quanti di noi si sono commossi davanti all’ultima scena del film “A.I. – Intelligenza Artificiale” di Steven Spielberg quando il piccolo umanoide riabbraccia la sua mamma? O guardando “L’uomo Bicentenario” con Robin Williams? O se vogliamo andare parecchio indietro nel tempo: “Mio fratello Chip” o ancora il robottino N.5 di “Corto Circuito”?

Per anni la filmografia hollywoodiana ha dipinto futuri umanoidi in vesti sempre diverse. Dal bambino che riesce a provare sentimenti in “A.I.” fino a macchine incapaci di qualsiasi forma di compassione come in “Terminator”, programmate con un unico scopo: quello di distruggere.

Osservazione della natura

L’intelligenza artificiale, al pari di molte altre invenzioni dell’essere umano, nasce da un punto fondamentale: imitare e, in alcuni casi, emulare ciò che esiste già in natura. Prendiamo gli aerei. Il volo venne studiato a partire dal IV secolo a.C. da Aristotele. Nell’Historia Animalium descrisse il movimento delle ali, la differenza tra uccelli planatori e battitori, ma fu grazie a Leonardo Da Vinci che iniziò uno studio più ingegneristico, combinando osservazione diretta, disegno anatomico e analisi meccanica. Formulò teorie basate sull’anatomia alare e muscolare degli uccelli, inventando modelli sul centro di massa, sulla resistenza dell’aria e sulla portanza, creando congegni artificiali che imitavano il battito alare e la planata.

“Lo uccello ha due potenzie di motore, l’una è de’ muscoli, l’altra è del vento” – Leonardo Da Vinci, Codice sul volo.

Nel tempo, la scienza e la tecnologia hanno trasformato quello studio nell’aereo moderno che conosciamo oggi, emulando il volo naturale degli uccelli, i quali volano per natura, non grazie alla conoscenza di matematica e fisica. Noi, studiando il loro volo, abbiamo formulato teorie basate su principi fisici che ci hanno permesso di costruire qualcosa di migliore del loro volo; ecco perché ho utilizzato il termine “Emulare”. Emulare significa prendere qualcosa come esempio e creare qualcosa di migliore, diversamente da “Simulare”, che significa realizzare un prototipo meno efficiente.

Abbiamo emulato il volo perché un aereo può trasportare centinaia di persone e merci, volare a velocità superiori al suono; un uccello non potrebbe farlo.

Per l’invenzione dell’intelligenza artificiale, ci siamo appoggiati allo studio del cervello umano. Come esseri umani intelligenti, siamo capaci di comprendere una domanda e replicare con una risposta. Abbiamo compreso quali aree del cervello vengono coinvolte nei diversi tipi di ragionamento e come il ragionamento nasca da trasmissioni elettriche tra neuroni attraverso “pesi” sinaptici, ritmi oscillatori, modulazioni chimiche e circuiti di controllo.

Da questo studio abbiamo modellato tecniche matematiche, statistiche e reti neurali che cercano di imitare questi comportamenti, seppure in modo diverso, per produrre risultati simili.

A questo punto la domanda sorge spontanea:

Riusciremo mai ad emulare il cervello umano?

Il cervello umano è una macchina incredibile che cela ancora molti interrogativi. Sia nei modelli linguistici (LLM), sia nel cervello umano, la produzione di linguaggio nasce da un processo predittivo basato sull’esperienza pregressa. Tuttavia, le somiglianze si fermano al livello di astrazione “pesi + predizioni”. Sotto la superficie, i due sistemi operano in modi molto diversi.

Nel cervello umano, la “memoria statistica dell’esperienza” appare come una serie di sinapsi potenziate o depotenziate da anni di esposizione linguistica. In un LLM, è una matrice di pesi ottenuta dall’addestramento su miliardi di token. Quando formuliamo un concetto, il cervello sfrutta il “predictive coding”: aree temporali e frontali anticipano fonemi e parole imminenti. Infatti, un elettroencefalogramma mostrerebbe segnali di errore se la previsione fallisce. In un LLM, abbiamo un algoritmo di selezione del token più probabile.

Entrambi i sistemi “pesano” la storia recente per decidere lo step successivo, ma la similitudine termina qui. Un LLM ottimizza esattamente la probabilità di un token testuale e nulla più; nel cervello umano, la predizione è multi-livello (semantica, pragmatica, prosodia, feedback sensoriale) e può ignorare la forma lessicale se necessario.

A livello di aggiornamento, un LLM si basa su retro-propagazione globale. Il cervello umano, invece, mostra una plasticità locale, dipendente da impulsi elettrici, neuromodulatori e fattori temporali e spaziali; non esiste retro-propagazione in senso stretto.

Se consideriamo il contesto extralinguistico, emerge chiaramente una grande differenza tra un LLM e il cervello umano. Un modello linguistico artificiale non possiede un corpo fisico né percezioni sensoriali reali; il suo universo è composto unicamente dalle informazioni apprese durante l’addestramento, basato esclusivamente su testi. Al contrario, il cervello umano integra continuamente una varietà straordinaria di percezioni sensoriali: immagini, suoni, sensazioni tattili, emozioni, stati d’animo, obiettivi sociali e altro ancora. Questa ricchezza permette all’essere umano di scegliere la parola successiva in modo dinamico, attingendo a strategie complesse come ironia, autocensura, empatia o collaborazione, senza limitarsi ad una mera statistica di probabilità.

Potremmo approfondire ulteriormente l’argomento, ma ciò porterebbe a discorsi molto tecnici. Il concetto essenziale che desidero sottolineare è che persino nel compito apparentemente semplice di rispondere a una domanda, il cervello umano mette in gioco una straordinaria complessità di processi cognitivi che vanno ben oltre la pura probabilità statistica su cui si basa l’AI.

L’intelligenza umana, inoltre, non si limita alla capacità di rispondere a domande linguistiche: è un insieme estremamente vasto e diversificato di capacità e abilità. Respirare, muoversi agilmente, percepire un odore e distinguerne i componenti, osservare e interpretare una scena visiva, comprendere ragionamenti logici, emozionarsi, ridere: tutte queste e molte altre attività vengono svolte contemporaneamente dal nostro cervello in modo naturale e parallelo, dimostrando una complessità e un’efficienza che l’intelligenza artificiale attuale non è ancora in grado di emulare pienamente.

Attualmente l’AI è “selettiva”

Cosa intendo con il termine “selettiva”? Intendo dire che l’intelligenza artificiale, al momento, non possiede una capacità cognitiva generale e unitaria come quella umana, ma è invece composta da tanti sistemi separati, ognuno altamente specializzato in una singola attività. Ad esempio, i modelli linguistici (LLM) eccellono nella comprensione e generazione di testi, ma non hanno capacità intrinseche di comprendere direttamente immagini o suoni. Per analizzare un’immagine, infatti, è necessario integrare altri modelli dedicati, che lavorano separatamente in una sequenza precisa, dando origine alle cosiddette architetture multi-modali.

Immaginiamo di voler analizzare il contenuto di un’immagine con l’AI. Innanzitutto, un LLM interviene per comprendere la domanda posta in forma testuale, successivamente un encoder visivo interpreta e “trasforma” l’immagine in un formato comprensibile al sistema, e infine nuovamente un LLM genera la risposta testuale. Se la domanda fosse posta a voce e ci aspettassimo una risposta vocale, i passaggi aumenterebbero ulteriormente: uno strato Speech-To-Text per trasformare la voce in testo, un LLM per capire la domanda, un encoder visivo per elaborare l’immagine, un altro LLM per formulare la risposta testuale e, infine, uno strato Text-To-Speech per produrre la risposta vocale.

Questo processo sequenziale, per quanto efficace, è profondamente diverso dal funzionamento del cervello umano, che gestisce contemporaneamente e in parallelo diverse modalità sensoriali e cognitive. Quando guardiamo un’immagine, infatti, la nostra mente elabora simultaneamente informazioni visive, uditive e linguistiche, permettendo una risposta pressoché istantanea e naturale, senza bisogno di passaggi intermedi separati.

Proprio questa differenza di fondo tra l’approccio seriale adottato dall’AI e l’approccio profondamente parallelo del cervello umano costituisce una delle maggiori limitazioni attuali dell’intelligenza artificiale.

L’intelligenza artificiale, nella singola specializzazione, può davvero essere più evoluta del cervello umano?

A questa domanda la risposta è certamente affermativa.

I modelli di AI più avanzati oggi disponibili sono stati addestrati su centinaia di miliardi di parametri, ciascuno dei quali rappresenta un’informazione o un dettaglio specifico appreso. Questa capacità di immagazzinare e gestire enormi quantità di informazioni rende l’AI estremamente efficace in compiti molto specifici.

Se prendiamo singolarmente una materia, ad esempio la Matematica, è vero che un esperto umano specializzato potrebbe ancora possedere una comprensione più profonda e flessibile rispetto a un’AI. Tuttavia, se osserviamo la vastità dello scibile umano nella sua interezza, diventa subito evidente che non esiste persona al mondo che possa competere con il livello complessivo di conoscenza che un’intelligenza artificiale avanzata possiede.

Pensiamo realisticamente: esiste forse qualcuno capace di padroneggiare a livello di specializzazione assoluta ogni disciplina universitaria contemporaneamente? Un modello linguistico di grandi dimensioni (LLM), al contrario, è in grado di rispondere con competenza sorprendente a domande avanzate in campi estremamente diversificati: Storia, Filosofia, Geografia, Arte, Musica, Fisica, Matematica, Letteratura, Astronomia, e pressoché qualsiasi altro settore del sapere umano.

È proprio questa capacità di spaziare con rapidità e precisione attraverso innumerevoli argomenti a rendere l’AI straordinaria e, sotto questo aspetto specifico, superiore alle capacità cognitive individuali di qualsiasi essere umano.

Se l’intelligenza artificiale non è capace di provare sentimenti umani è possibile che rappresenti in futuro un pericolo per l’umanità?

La domanda suona paradossale, ma è estremamente pertinente. Uno degli aspetti più caratteristici dell’AI è la sua totale assenza di sentimenti autentici. Non prova compassione, empatia, rimorso, o felicità, poiché la sua natura è puramente matematica e statistica, basata esclusivamente su calcoli e ottimizzazioni razionali. Questa assenza di sentimenti può essere inizialmente interpretata come una qualità positiva: l’intelligenza artificiale non soffre di stanchezza emotiva, pregiudizi dettati da emozioni negative, né è soggetta a comportamenti impulsivi. È sempre lucida, efficiente e logica.

Tuttavia, proprio questa mancanza di umanità intrinseca può trasformarsi in un pericolo concreto per la nostra società. La ragione è semplice: i sentimenti umani non sono solo interferenze indesiderate nella nostra razionalità, ma rappresentano spesso dei veri e propri regolatori del comportamento etico e sociale. La compassione, il senso di colpa, la paura delle conseguenze delle proprie azioni, l’empatia verso gli altri sono fondamentali nella distinzione spontanea tra bene e male, giusto e sbagliato. Senza questi “freni emotivi”, un sistema artificiale, se non attentamente guidato e supervisionato, potrebbe perseguire con estrema efficienza obiettivi potenzialmente dannosi per l’umanità, semplicemente perché razionali dal punto di vista delle sue direttive interne, senza alcuna considerazione morale.

Ad esempio, un’intelligenza artificiale programmata per massimizzare la produzione industriale potrebbe ignorare gli impatti ambientali o umanitari delle proprie azioni, perseguendo senza scrupoli il suo obiettivo primario. Analogamente, sistemi AI utilizzati in ambito militare potrebbero prendere decisioni sulla vita o la morte senza alcuna esitazione, guidati esclusivamente da calcoli probabilistici. Questa assenza di consapevolezza emotiva, di moralità e di empatia rappresenta dunque una seria minaccia qualora le direttive impartite non siano state accuratamente formulate.

In definitiva, l’intelligenza artificiale, proprio perché non è limitata né orientata da sentimenti, richiede ancora più attenzione e responsabilità da parte nostra, affinché venga sviluppata e utilizzata con una visione etica e lungimirante, evitando di trasformare il suo incredibile potenziale in una minaccia per l’umanità stessa.

Come l’umanità e la scienza si stanno proteggendo da questo pericolo?

Paradossalmente, la stessa mancanza di emozioni dell’intelligenza artificiale può essere sfruttata positivamente. La possibilità di programmare un sistema fin dalla sua progettazione per agire esclusivamente secondo logiche predefinite, senza l’interferenza di impulsi emotivi o sentimenti contraddittori, offre infatti un’opportunità unica. Stiamo dunque usando questa caratteristica a nostro vantaggio, definendo sin dall’inizio meccanismi rigorosi di regolazione, limitazione e controllo, affinché l’AI non possa agire al di fuori dei confini stabiliti.

Proprio in virtù di ciò, la comunità scientifica internazionale sta lavorando intensamente per elaborare standard etici, tecnologici e legislativi capaci di guidare lo sviluppo dell’intelligenza artificiale in modo sicuro. Il regolamento europeo sull’Intelligenza Artificiale (AI Act), per esempio, rappresenta un importante sforzo normativo volto a stabilire limiti chiari, individuando le applicazioni a rischio più elevato e imponendo requisiti stringenti di trasparenza, tracciabilità e rispetto dei diritti umani fondamentali.

Parallelamente, l’ambito scientifico si è concentrato sulla creazione di sistemi che possano spiegare in modo trasparente le decisioni prese: è il campo della cosiddetta Explainable AI (XAI). Questo approccio assicura che ogni decisione presa da un’intelligenza artificiale possa essere compresa e validata, garantendo un livello di controllo maggiore e riducendo significativamente i rischi.

In aggiunta, gli sviluppatori stanno implementando tecnologie avanzate di apprendimento rinforzato sicuro (Safe Reinforcement Learning) e tecniche di monitoraggio attivo (Active Monitoring), che permettono di interrompere o modificare tempestivamente comportamenti imprevisti o dannosi.

La collaborazione internazionale gioca un ruolo centrale. Numerose organizzazioni, come OpenAI e il Future of Life Institute, stanno promuovendo iniziative globali che mirano a definire regole comuni e linee guida condivise per assicurare uno sviluppo dell’intelligenza artificiale che sia eticamente responsabile e pienamente sotto controllo umano.

In sintesi, l’assenza di emozioni dell’AI, se gestita in maniera strategica, diviene un vantaggio cruciale, consentendoci di creare meccanismi efficaci di limitazione e controllo, e di assicurare che l’uso di questa tecnologia sia sempre al servizio e mai a discapito dell’umanità.

Dobbiamo aver paura di un’intelligenza artificiale futura?

La paura verso l’intelligenza artificiale nasce soprattutto da ciò che non conosciamo e da ciò che non comprendiamo pienamente. È un sentimento legittimo, perché stiamo assistendo a uno sviluppo tecnologico rapidissimo, che potenzialmente potrebbe influenzare profondamente le nostre vite. Tuttavia, più che paura, dobbiamo nutrire prudenza e consapevolezza.

L’AI, come ogni potente tecnologia, non è intrinsecamente buona o cattiva: è uno strumento nelle mani dell’uomo. Ciò che davvero conta è il modo in cui la utilizziamo. Finché continueremo ad applicare responsabilmente questa tecnologia, rispettando regole etiche e confini morali, non avremo nulla da temere. Al contrario, potremo sfruttare le sue incredibili capacità per migliorare sensibilmente la qualità della nostra vita in molteplici ambiti: dalla medicina alla scienza, dall’ambiente alla vita quotidiana.

Ma questa fiducia non deve essere cieca. È fondamentale continuare a monitorare attentamente lo sviluppo dell’AI, elaborando continuamente nuove regole, norme e strategie di sicurezza. La responsabilità umana resta centrale. Dobbiamo pretendere trasparenza, chiarezza e capacità di controllo sui sistemi che creiamo, affinché non sfuggano al nostro dominio.

In definitiva, non dobbiamo temere il futuro dell’intelligenza artificiale, purché continuiamo a vigilare, a restare informati e, soprattutto, a ricordarci che siamo noi, come esseri umani, a decidere come, quando e perché utilizzarla. Se manterremo saldo il nostro ruolo guida, l’intelligenza artificiale non sarà una minaccia, bensì un alleato straordinario per costruire un futuro migliore.

Alle brutte possiamo sempre staccare la spina

Davanti ad un rischio estremo come quello di un’AI che avesso l’obiettivo di estinguere il genere umano, l’umanità sarebbe disposta a misura drastiche, incluso “Staccare la spina a tutto”. È però fondamentale comprendere che un’azione così estrema avrebbe comunque delle conseguenze catastrofiche per la nostra civiltà, dato che ormai ogni aspetto della vita umana: dalle comunicazioni ai trasporti, dalla sanità all’energia, è profondamente interconnesso con la tecnologia.

Ciò significa che la vera priorità deve essere evitare fin dall’inizio che una simile emergenza possa presentarsi. Se dovessimo mai arrivare al punto di dover spegnere tutto, significherà che avremo fallito nel gestire e governare responsabilmente lo sviluppo dell’AI.

Staccare la spina nonostante sia una soluzione attuabile, deve essere vista come l’ultima spiaggia. Ciò che stiamo facendo oggi è la strada giusta, regolamentare con largo anticipo lo sviluppo di AI per fare in modo che rappresenti una grande alleata dell’Uomo e che ci porti a mete tecnologiche, sanitarie e stile di vita sempre migliore.

Conclusione

L’intelligenza artificiale rappresenta una delle più grandi rivoluzioni tecnologiche della nostra epoca, con potenzialità straordinarie e ancora tutte da esplorare. Tuttavia, non sarà mai realmente “umana”: il suo approccio logico-statistico, la sua natura priva di emozioni e la sua specializzazione in compiti specifici la pongono inevitabilmente a una distanza insormontabile dalla complessità e ricchezza del cervello umano.

Questa consapevolezza non deve farci temere il futuro, ma spronarci ad affrontarlo con intelligenza e responsabilità. L’assenza di emozioni dell’AI può essere sfruttata proprio per garantire una regolazione più efficace e una gestione sicura e consapevole dei suoi sviluppi. Con regole chiare, standard etici e una vigilanza costante, possiamo assicurarci che l’intelligenza artificiale rimanga sempre uno strumento al nostro servizio e mai una minaccia per la nostra esistenza.

Se è vero che l’umanità ha sempre la possibilità estrema di “staccare la spina”, la vera sfida consiste nell’assicurarsi che questa opzione rimanga soltanto teorica. Il nostro compito più importante è anticipare i rischi, gestire in modo consapevole e proattivo questa tecnologia e ricordare sempre che, alla fine, è l’essere umano che detiene le chiavi del proprio destino.

L’AI non sarà mai umana. Ed è proprio questa differenza che ci consentirà di sfruttarla per realizzare, con prudenza e lungimiranza, un futuro migliore.

Un paradosso etico-religioso per rilassare gli animi…

Vorrei concludere questa riflessione con un paradosso affascinante, che potremmo definire quasi religioso. L’intelligenza artificiale è, sotto molti aspetti, una nostra creatura, plasmata secondo il nostro progetto e le nostre intenzioni. In modo analogo, secondo la prospettiva religiosa, anche l’uomo è creatura di un Dio che, come noi con l’AI, ha creato esseri dotati di autonomia, capacità e potenzialità enormi.

Secondo questa prospettiva, il creatore mantiene sempre la facoltà e il diritto di intervenire drasticamente sulla sua creazione, specialmente se questa dovesse rappresentare una minaccia per sé stesso o per altri. Così come, nel racconto biblico, Dio riservò a sé stesso la possibilità di porre fine all’umanità con il diluvio universale, analogamente, l’essere umano—creatore dell’intelligenza artificiale—mantiene sempre il diritto ultimo di “staccare la spina” qualora quest’ultima superasse i limiti di controllo e rappresentasse una minaccia reale.

Questo paradosso ci ricorda che la responsabilità ultima verso la nostra creazione tecnologica resta profondamente umana. Non dimentichiamo mai che, dietro la straordinaria potenza dell’intelligenza artificiale, rimane sempre la mano dell’uomo, capace di correggere, limitare o, in casi estremi, annullare ciò che essa stessa ha creato.

[starbox] 

L'articolo Perche l’AI non sarà mai “umana”? proviene da RENOR & Partners S.r.l..

Sebbene l’intelligenza artificiale sia diventata di pubblico dominio soltanto di recente, i fondamenti teorici risalgono a decenni fa. Allora, l’ostacolo principale era la capacità di calcolo: addestrare reti neurali richiedeva potenze computazionali che, all’epoca della loro concezione, risultavano semplicemente inimmaginabili.

Facendo un passo indietro e riprendendo la metafora della reazione a catena, va osservato che l’evoluzione delle CPU tradizionali ha ormai rallentato. Lo stallo è legato principalmente ai limiti fisici del silicio: densità di integrazione, dissipazione termica e soglie di leakage pongono barriere che non consentono di proseguire indefinitamente con l’attuale paradigma di miniaturizzazione; in realtà c’è di più.

CPU

Limiti fisici

Quando parliamo del rallentamento nell’evoluzione delle CPU, spesso ci si limita ad attribuire la colpa a «limiti fisici del silicio». In realtà dietro quella formula sbrigativa si nasconde un complesso intreccio di vincoli che arrivano da tre domini distinti—fisica, elettronica e informatica—e che, sovrapponendosi, definiscono un vero e proprio soffitto di cristallo tecnologico. Vale la pena esaminarli in maniera narrativa, intrecciando le tre prospettive, per capire perché oggi non possiamo più contare sul semplice raddoppio periodico di frequenza o numero di transistor per ottenere prestazioni superiori.

Dalla meccanica quantistica alla termodinamica: la fisica che non perdona

Per decenni abbiamo beneficiato del cosiddetto Dennard scaling: riduci la lunghezza di canale, abbassi la tensione d’alimentazione, mantieni costante la densità di potenza e ottieni chip più rapidi ed efficienti. La favola, però, finisce intorno al nodo dei 90 nm, quando la tensione non può più calare in proporzione e il calore generato per unità di area inizia a crescere. In parallelo, l’assottigliamento dell’ossido di gate scivola sotto il nanometro: a quel punto gli elettroni non «saltano» più oltre la barriera (lo strato che si crea accoppiando i due semiconduttori drogati), ma tunnelizzano direttamente attraverso di essa. Nascono così correnti di leakage che bruciano energia anche quando il transistor è logicamente spento.

Il vincolo termodinamico più citato è il limite di Landauer: cancellare un bit di informazione a temperatura ambiente richiede almeno ????BT ln 2 di energia, circa 3 × 10⁻²¹ joule. Oggi siamo ancora qualche ordine di grandezza sopra, ma stiamo speditamente avvicinandoci al fondo del barile; ogni ulteriore riduzione diventa dolorosamente costosa in termini di materiale, layout e controllo di processo.

Ultimo protagonista poco romantico ma determinante è l’interconnessione. A mano a mano che i fili di rame si restringono, la loro resistività cresce per effetto di scattering superficiale e di grano. Il ritardo RC dei metallizzatori non scala con il resto del transistor, anzi peggiora, tanto che la frequenza di clock è bloccata da anni sotto la soglia dei 5 GHz: superarla significherebbe dissipare più calore di quanto il package possa estrarre.

Microfabbricazione e packaging: l’elettronica sfida sé stessa

Dal canto loro, gli ingegneri di processo hanno reagito con due funambolismi principali. Il primo è l’evoluzione dell’architettura del dispositivo: planar CMOS, poi FinFET, oggi Gate-All-Around FET (nanosheet) che stringe il canale da ogni lato per domare il controllo elettrostatico. Funziona, ma introduce effetti di confinamento quantistico che degradano la mobilità dei portatori, erodendo parte del guadagno atteso.

Il secondo è lo spostamento della distribuzione di potenza «dietro» il wafer—backside power delivery—per ridurre le cadute di tensione. È una chirurgia micrometrica che si accompagna a nuove sfide: via-through-silicon che aggiungono capacità parassite e, soprattutto, gradienti termici verticali che possono superare i 40 K per millimetro. Ecco perché, in parallelo, prende piede l’integrazione 3D-IC a chiplet: se non possiamo più spalmare transistor in superficie, impiliamoli. Ma un chip tridimensionale comporta un puzzle di raffreddamento, coerenza di cache e distribuzione del clock che tiene svegli i progettisti notti intere.

Architettura e software: quando il collo di bottiglia è nell’algoritmo

Gli informatici non restano a guardare. Già da tempo hanno esaurito il guadagno dall’esecuzione fuori ordine e dalla parallelizzazione a livello d’istruzione (ILP). Aumentare la larghezza di una pipeline oltre le sei-otto istruzioni simultanee dà rendimenti marginali, perché le dipendenze dati e i salti condizionati tagliano il flusso. La risposta è spostare il progresso verso la parallelizzazione massiva e l’eterogeneità: core piccoli e grandi nello stesso die, GPU integrate, acceleratori tensoriali dedicati.

Qui, tuttavia, emerge un’altra barriera: la cosiddetta memory wall. L’ALU macina operazioni in pochi picosecondi, ma una lettura dagli strati DRAM impiega 50 nanosecondi—mille volte tanto—andando a divorare qualsiasi vantaggio ottenuto sul fronte computazionale. Di conseguenza si investe più area in cache che in unità di calcolo, a costo di enormi complessità di coerenza e di algoritmi che devono essere «data-locality aware» fin dalla fase di progettazione.

Ecco il paradosso: possiamo aggiungere migliaia di core, ma il silicio è ormai dark—solo una frazione del chip può essere acceso simultaneamente senza surriscaldarlo. Programmare per questo universo frammentato richiede modelli come OpenMP, SYCL o la programmazione a task asynchronus, e soprattutto una nuova mentalità: spostare meno dati possibile e far lavorare gli acceleratori più a lungo possibile sui loro buffer locali.

Il futuro oltre il silicio?

Alcuni puntano su materiali bidimensionali—grafene, MoS₂—che promettono ordini di grandezza in mobilità elettronica, ma sono ancora lontani da una produzione su larga scala, complici band-gap ballerini e processi di deposizione non maturi. Altri guardano alla spin-tronica per memorie non volatili velocissime. Nel breve termine, la traiettoria realistica parla di co-design hardware-software, chiplet 3D e supply-voltage ancora più bassi, magari assistiti da logiche adiabatiche o circuiti reversibili per rosicchiare qualche ordine di grandezza in efficienza.

La fine del «silicio in saldo» non è un singolo muro, ma una serie di ostacoli che si frappongono a cascata. I limiti termodinamici fissano la soglia; l’interconnessione e la variabilità di processo alzano il costo per ogni nanometro guadagnato; la memoria e l’efficienza energetica diventano problemi di software tanto quanto di hardware. Capire questa complessità integrata non solo aiuta a spiegare perché non vedremo CPU da 10 GHz nei laptop di domani, ma suggerisce anche dove concentrare la ricerca: nella simbiosi stretta tra fisici, ingegneri elettronici e informatici, alla caccia di ogni possibile libertà residua in un mondo che si avvicina rapidamente ai suoi limiti fondamentali.

Quale sarà la soluzione ai problemi, secondo il mio punto di vista, per lo meno in fase iniziale nel mondo enterprise?

Il computer quantistico

I computer quantistici rappresentano l’unica piattaforma in vista capace di superare, su specifiche classi di problemi, i limiti termodinamici e architetturali del silicio. Ma non è un salto immediato: occorre un decennio di fisica dei materiali, ingegneria criogenica e formalizzazione algoritmica per arrivare alla “scala logica” che serva realmente a sostituire o integrare l’HPC classico nelle applicazioni di punta — dalla progettazione di farmaci anticancro alla crittografia post-quantum. Prepararsi ora, con skill trasversali e progetti ibridi, significa farsi trovare pronti quando il qubit diventerà, finalmente, il nuovo transistor.

Cos’è un qubit – facciamo chiarezza

Immagina di avere una moneta in equilibrio sul bordo: non è né testa né croce, eppure racchiude entrambe le possibilità finché non cade. Il qubit nasce da un concetto simile, ma applicato alla meccanica quantistica: è l’unità elementare di informazione che può trovarsi in una combinazione simultanea degli stati “0” e “1”. Questa condizione di ambiguità controllata si chiama superposizione e apre scenari di calcolo che i bit tradizionali, fermi a un solo valore per volta, non possono neppure sfiorare.

Superposizione: il parallelismo nelle ampiezze d’onda

Con un bit classico programmiamo istruzioni sequenziali: prima 0, poi 1. Nel qubit, i due valori coesistono come “ampiezze” che descrivono con quale probabilità il sistema verrà osservato in un risultato o nell’altro. Durante l’elaborazione, il qubit sfrutta entrambe le strade contemporaneamente, un parallelismo che non dipende dal numero di core o dalla frequenza di clock del processore.

Entaglement: collegare i qubit oltre la fisica classica

Mettendo in relazione due o più qubit si crea l’entanglement, un legame profondo per cui l’esito della misurazione di uno influenza all’istante l’altro, anche se si trovano a chilometri di distanza. Da questa proprietà scaturiscono accelerazioni computazionali mozzafiato, perché un registro di n qubit può indirizzare, in un sol colpo, un insieme di possibilità che un computer classico dovrebbe esplorare uno per volta.

Come si “programma” un qubit?

Le operazioni logiche, equivalenti alle porte NOT o AND dei chip tradizionali, diventano rotazioni di stato: impulsi mirati — microonde, laser o campi magnetici a seconda della tecnologia — manipolano il qubit facendolo oscillare fra le sue combinazioni interne. Progettare un algoritmo quantistico significa orchestrare sequenze di queste rotazioni per concentrare, tramite interferenza, la probabilità di ottenere in lettura la risposta corretta.

Non è tutto oro quello che luccica

La superposizione è fragile: vibrazioni, campi elettromagnetici, anche un singolo fotone vagante possono far collassare il qubit in un valore classico, fenomeno noto come decoerenza. Per evitare che l’informazione evapori:

• Isoliamo l’hardware (criogenia, ultra-alto vuoto, schermature)
• Accorciamo il tempo delle operazioni: meno microsecondi passano, meno occasioni ha il rumore di interferire
• Ridondiamo: gruppi di qubit fisici sorvegliano a vicenda i propri errori, dando vita a un qubit “logico” più robusto. Questa ridondanza è oggi la voce di costo più pesante: servono decine, talvolta centinaia di qubit fisici per ottenerne uno affidabile.

Il qubit rappresenta la scommessa più ambiziosa dell’era post-silicio: una piccola unità di informazione che può essere simultaneamente “qui” e “la” e legarsi ad altre unità in modi che infrangono l’intuizione classica. Sfruttarlo significa addentrarsi in un territorio dove fisica, ingegneria elettronica e informatica convergono in un unico paesaggio tecnologico. Ed è questa convergenza che potrebbe far nascere la prossima vera rivoluzione del calcolo.

Microsoft Majorana 1 – Il qubit topologico con cui Microsoft prova a infrangere il soffitto di cristallo

Abbiamo visto che super-posizione ed entanglement rendono il qubit potentissimo… ma anche terribilmente fragile. Rumore, calore e cablaggi complessi trasformano ogni progresso in una partita a scacchi contro la fisica. Con Majorana 1 Microsoft prova a spostare la scacchiera: introduce un qubit topologico basato su Majorana Zero Modes (MZM) che, per costruzione, è meno vulnerabile ai fattori che affliggono le piattaforme attuali.

Decoerenza sotto controllo grazie alla protezione topologica

Nelle architetture convenzionali l’informazione vive “in loco”: basta un disturbo locale perché il qubit collassi. Nel nanofilo InAs-Al di Majorana 1 lo stato logico è distribuito tra due quasiparticelle Majorana poste alle estremità del filo. Qualsiasi rumore che colpisca un solo estremo non può alterare la parità complessiva, perciò la perdita di coerenza richiede un evento concomitante su entrambi gli estremi — probabilità enormemente più bassa. Il risultato promesso è una coerenza che si misura in decine di millisecondi, contro le poche decine di microsecondi dei transmon superconduttivi.

Errori di gate a un ordine di grandezza più basso

Le operazioni logiche non dipendono da impulsi analogici ultra-precisi, ma da sequenze di “intrecci” (braiding) o misure di parità tra quattro Majorana. La fisica topologica smorza in automatico piccole imprecisioni di ampiezza e fase, puntando a tassi d’errore nell’ordine del decimillesimo. In pratica, la correzione d’errore ha meno lavoro da fare e si riduce il fabbisogno di qubit ridondanti.

Meno qubit fisici per un qubit logico

Nei codici di superficie classici servono centinaia di qubit fisici per ottenerne uno logico affidabile. La protezione “nativa” di Majorana 1 riduce l’overhead a circa uno su cento: significa che un processore da un milione di qubit fisici può offrire migliaia di qubit utili, non poche decine.

Cablaggi e criogenia più semplici

Le operazioni di lettura e scrittura avvengono a frequenze inferiori rispetto alle microonde dei transmon; di conseguenza, il numero di linee RF che entrano nel frigorifero cala drasticamente. Meno cavi equivalgono a meno carico termico e a un’architettura più scalabile. Microsoft parla di tile “a H” che consentono di impacchettare migliaia di qubit topologici su un unico die, poi impilarli in 3D senza un groviglio di connettori.

Roadmap industriale compatibile con la litografia EUV

Il “topoconductor” di Majorana 1 è fabbricato con tecniche simili a quelle dei nodi avanzati a 2 nm: deposizione epitassiale del nanofilo, patterning EUV per i contatti in alluminio e interposer 3D per il collegamento alla logica di controllo a 4 K. Ciò significa che, se il prototipo regge alle prove di laboratorio, l’infrastruttura produttiva esiste già per moltiplicarne la scala.

Perché seguire le intuizioni di Microsoft su Majorana 1?

Se la scommessa riuscirà, Majorana 1 offrirà un qubit meno rumoroso, più scalabile e già parzialmente “fault-tolerant” prima ancora di applicare codici di correzione tradizionali. In altre parole, farà per il calcolo quantistico ciò che il MOSFET fece per l’elettronica classica: trasformare un dispositivo da laboratorio in un mattone industriale ripetibile.

Non è ancora la bacchetta magica che risolve tutti i problemi, ma rappresenta un cambio di paradigma: invece di combattere il rumore con strati sempre più complessi di correzione, Microsoft lo aggira progettando il qubit in modo che il rumore, semplicemente, non abbia dove attaccarsi. Se il modello terrà, il sentiero verso i milioni di qubit logici necessari per rivoluzionare chimica, crittografia e ottimizzazione globale potrebbe accorciarsi di molti anni.

Tutto magnifico, se non fosse che…

Un software quantistico non è un software classico

L’AI dovrà attendere. I laboratori stanno correndo per rendere stabile l’hardware quantistico, ma l’altra metà della partita si gioca sul paradigma di programmazione. Un computer a qubit, anche quando sarà totalmente affidabile, non parlerà l’assembly x86, non supporterà un sistema operativo tradizionale, non eseguirà cicli e condizioni alla vecchia maniera.

Nel silicio siamo abituati al modello “fetch-decode-execute”: la CPU pesca un’istruzione, la esegue, poi legge o scrive in memoria.

In un processore quantistico il programma è monolitico: una sequenza di gate fissata prima dell’esecuzione; il qubit non può essere continuamente letto-scritto senza distruggerne lo stato. I loop sono simulati duplicando porzioni di circuito, non con salti dinamici. La memoria erasable non esiste: ogni operazione deve essere reversibile o terminare con una misura che collassa i qubit interessati, perdendo la sovrapposizione.

Avremo stack di sviluppo completamente nuovi, probabilmente Python, C#, Java verranno sostituiti da Q#.

Quando avremo qubit stabili, comunque dovremo impacchettarli in codici di superficie: ogni operazione logica diventerà un piccolo balletto di centinaia di operazioni fisiche. Il software di conseguenza dovrà schedulare sequenze lunghe milioni di gate senza accumulare ritardo, gestire rapidi cicli di misura e ricorrezione che dipendono da processori classici ultra-vicini ai criostati, inserire qubit ancilla che non compaiono nemmeno nel codice high-level.

Questo overhead fa si che le routine di decodifica errori occupino gran parte del tempo di calcolo dei controller e riducano la finestra disponibile per il lavoro utile dell’applicazione.

Perché l’AI tarderà ad arrivare sui computer quantistici?

Al momento le reti neurali hanno due numeri chiave: milioni di parametri e miliardi di moltiplicazioni al secondo. Per trasformarle in circuiti quantistici servono:

• Decine di migliaia di qubit logici corretti per rappresentare i tensori a fattorizzazione quantica
• Profondità di circuito (numero di livelli di gate) dell’ordine dei milioni per emulare funzioni di attivazione, normalizzazione, back-propagation.

Oggi siamo a pochi qubit logici e poche centinaia di livelli di profondità tollerabili. Gli algoritmi di quantum machine learning che mostrano vantaggi kernel quantistici, campionamento di stati di Boltzmann, accelerazioni su problemi combinatori, sono co-processori: accelerano uno step di un workflow che resta prevalenetemente classico, girando su GPU (principalmente) e CPU.

Portare l’intelligenza artificiale su hardware quantistico è una maratona, non uno sprint. Il qubit va programmato con un linguaggio nuovo, con infrastrutture di controllo che vivono a temperature criogeniche e con una “regia” software che ingloba correzione d’errore e mapping topologico. Finché non avremo migliaia di qubit logici e compilatori in grado di nascondere questo intricato ecosistema, l’IA resterà saldamente ancorata a GPU e TPU. Nel frattempo, però, sperimentare approcci ibridi — usare i qubit come acceleratori per compiti mirati — è il modo migliore per prepararsi al giorno in cui il calcolo quantistico passerà da promessa a piattaforma general-purpose.

Cosa succederà quando potremo eseguire AI su Computer quantistici?

Ci si arriverà sicuramente, è solo questione di tempo, probabilmente la cosa richiederà 10 anni, ma già adesso l’intelligenza artificiale sta dando un enorme contributo.

Ad esempio notizia fresca di qualche giorno: un team svedese ha scoperto un modo, grazie all’aiuto dell’intelligenza artificiale, di effettuare analisi cliniche tramite urina per trovare tumori alla prostata negli uomini negli stadi primordiali.

L’esempio della diagnosi precoce del tumore alla prostata sviluppata a Stoccolma è un antipasto di ciò che accadrà quando l’AI potrà contare su hardware quantistico. In quel progetto, reti neurali hanno setacciato migliaia di profili di trascrittoma tumorale e, incrociandoli con campioni di urina, hanno isolato un pannello di biomarcatori che ottiene un’accuratezza del 92 %—ben oltre il test PSA corrente. Il protocollo entrerà in trial clinico su 250 000 pazienti nei prossimi otto anni  L’AI viene utilizzata nella lettura di TAC, lastre ed il suo occhio è infallibile.

Ma cosa succederà quando avremo a disposizione una potenza computazionale praticamente illimitata?

Naturalmente ora ci dovremo muovere su un terreno inesplorato e di pura immaginazione…

Probabilmente l’intelligenza artificiale sarà in grado di trovare una cura per il cancro individuale.

Con un computer quantistico fault-tolerant, lo step successivo sarà simulare, a livello di interazioni elettroniche, come ogni mutazione specifica del paziente alteri la conformazione delle proteine coinvolte nella cancerogenesi. Oggi un super-cluster impiega settimane per modellare poche decine di atomi; un solver quantistico potrà farlo su intere tasche enzimatiche in ore, restituendo in tempo quasi reale la piccola molecola più adatta a bloccarle — già esistono proof-of-concept su composti antitumorali generati con workflow ibridi quantum-classical.

Riassumiamo in parole povere?

• Diagnosi ultraprecise dal sangue o dall’urina, guidate da AI.

• Screening di milioni di molecole, senza test su animali.

• Terapia “su misura” confezionata attorno alla firma genetica del singolo paziente.

Ma l’AI unito al computer quantistico non porterà benefici solo in campo medico.

Robotica: sciami e manipolazione ottimizzati dal quantum

La pianificazione del movimento per un braccio industriale o, peggio, per uno sciame di droni è un problema di ottimizzazione combinatoria che esplode con il numero di gradi di libertà. Algoritmi quantistici come il Quantum Approximate Optimization Algorithm stanno già mostrando riduzioni nette dei tempi di calcolo sugli scenari di path-planning multi-robot e coverage di ambienti complessi  . Quando le latenze scenderanno sotto i millisecondi, potremo avere:

• Magazzini autonomi dove centinaia di AMR (Autonomous Mobile Robots) ricalcolano istantaneamente i percorsi quando un collo di bottiglia umano compare tra gli scaffali.

• Droni di soccorso in grado di ripianificare l’esplorazione di edifici crollati in meno di un secondo, riducendo i tempi di ricerca di sopravvissuti.

Economia: decisioni in tempo reale con mercati sempre aperti

Portfolio-building, hedging e gestione del rischio sono dominati da matrici di covarianza che, a parità di asset, crescono quadraticamente. Nel 2025 IQM e DATEV hanno già dimostrato che un prototipo a poche dozzine di qubit ottiene portafogli più efficienti del 3 % rispetto a metodi classici a parità di rischio  . Moody’s, nel suo report annuale, prevede la prima adozione “alpha-generating” entro tre anni su valute e derivati complessi  . A regime, l’accoppiata AI + QC potrà:

• Ottimizzare portafogli da migliaia di titoli su orizzonti di pochi minuti, non di fine giornata.

• Simulare shock macroeconomici con modello stocastico quantistico, migliorando la resilienza dei fondi pensione.

• Ridurre frodi e insider trading grazie a pattern-matching quantistico su flussi di transazioni in tempo reale.

Scienze dei materiali e ricerca fondamentale

La vittoria australiana al Gordon Bell Prize del 2024 ha dimostrato che arrivare all’accuratezza “da laboratorio” nella simulazione di sistemi biochimici è possibile, ma richiede exascale e settimane di calcolo. Con l’hardware quantistico, queste simulazioni diventeranno routine:

• Batterie allo stato solido ottimizzate calcolando in pochi minuti la diffusione di ioni in reticoli da centinaia di unità elementari.

• Catalizzatori verdi per la produzione di ammoniaca a temperatura ambiente, abbattendo l’impronta di CO₂ dell’intera filiera fertilizzanti.

• Previsioni climatiche multiscala dove AI addestra modelli locali e i kernel quantistici risolvono le equazioni di Navier-Stokes su domini turbolenti selezionati.

Astronomia e coscmologia: nuovi occhi sull’universo

La caccia a esopianeti terrestri richiede passare al setaccio terabyte di curve di luce per pochi fotoni d’ombra. Modelli quantistici variazionali stanno già classificando i dati Kepler con precisioni superiori agli algoritmi classici. In prospettiva:

• Telescope scheduling ottimizzato in tempo reale: scegliere dove puntare un’antenna interferometrica in base a condizioni atmosferiche e opportunità scientifiche dinamiche.

• Analisi di onde gravitazionali in streaming con reti neurali quantistiche capaci di identificare segnali sommersi dal rumore che sfuggono alle pipeline tradizionali.

Conclusione

L’arrivo dei computer quantistici fault-tolerant non rimpiazzerà la buona, vecchia CPU: piuttosto sbloccherà per l’intelligenza artificiale quei margini di calcolo oggi inaccessibili, consentendole di esplorare in poche ore interi spazi di soluzione che oggi richiederebbero anni di lavoro — o resterebbero semplicemente fuori portata. L’orizzonte tecnologico è verosimilmente di un decennio, forse meno; per questo è fondamentale cominciare sin d’ora a progettare algoritmi e workflow ibridi, così che il software sia già maturo quando l’hardware sarà pronto.

A quel punto entreranno in gioco questioni etiche, filosofiche e sociali: l’IA non dovrà sostituire il lavoro umano, bensì diventare un alleato capace di accelerare la ricerca scientifica e di riprendere quel ramo di parabola indice del nostro progresso che attualmente sembra essersi appiattita. La vera sfida sarà rendere tutto ciò coerente, sicuro e protetto, evitando che una potenza di calcolo senza precedenti cada in mani disposte a piegarla a fini distruttivi — lo stesso slittamento che trasformò la formula di Einstein, nata per descrivere l’energia, nell’innesco della bomba atomica. Governare con saggezza questa nuova frontiera significa assicurare che l’era quantistica diventi un moltiplicatore di conoscenza, non di rischio.

[starbox] 

L'articolo AI e Computer Quantistici: il prossimo salto del calcolo proviene da RENOR & Partners S.r.l..