Firmware 2.21

Firmware2.
0 EDITORIALE
Intelligenza Artificiale: alla ricerca di
nuove skills
C
ari lettori,
il nuovo numero di Firmware 2.0 è dedicato al settore “AI/ML-Big Data Analytics”. Si prevede che il segmento
emergente dell’IA registrerà una crescita molto interessante entro il 2025, accelerando la sua diffusione nei
prossimi mesi e contaminando diversi settori industriali.
Ma a che punto siamo con l’Intelligenza Artificiale? L’IA è diventata una delle nuove competenze digitali richieste dal
mercato del lavoro.
Nonostante l’iniziale timore tipico dei grandi cambiamenti tecnologici, la pandemia ha senza dubbio accelerato
i grandi investimenti nelle tecnologie dell’Intelligenza Artificiale da parte di molte realtà aziendali focalizzate su
nuove modalità di lavoro e sul garantire la continuità produttiva anche in assenza dell’intervento umano. Il risultato
che tutti ci aspettiamo dall’implementazione di soluzioni IA a tutti i livelli è la semplificazione di attività, una maggiore
automatizzazione dei processi, l’aumento dell’efficienza produttiva, ma anche una maggiore sicurezza nella gestione di
dati e informazioni.
A questo sono chiamati a concorrere, garantendo tecnologie sicure e all’avanguardia, sia le software house sia i
produttori di chip e dispositivi hardware in grado di elaborare le grandi quantità di dati raccolti. Nel lavoro futuro non
esisterà professione che possa fare a meno dell’IA, un contesto che porterà inevitabilmente i lavoratori ad aggiornare le
proprie competenze sviluppando sia nuove soft skills tecnologicamente innovative per differenziarsi e stare al passo con
i tempi, sia nuovi approcci e nuove professionalità.
Sarà necessario anche ripensare nuove modalità per gestire le implicazioni di questa tecnologia emergente sull’intera
società. Possiamo avere un’idea di quello che sarà l’impatto potenziale dell’IA nel mercato del lavoro e nell’ecosistema
produttivo in generale.
Gli investimenti economici dovranno focalizzarsi sul reperire competenze tecnico specialistiche al fine di sviluppare
concretamente applicazioni innovative, minimizzando al contempo il rischio da parte delle aziende più all’avanguardia di
delocalizzare risorse in Paesi dotati di un approccio all’IA più solido e strutturato.
Buona lettura!
Giordana Francesca Brescia
2 - Firmware 2.0
Firmware2.0 SOMMARIO
AI/ML
Big Data Analytics
EDITORIALE COME UTILIZZARE

Founder&Editor INTELLIGENZA ARTIFICIALE: 2 HADOOP E PERCHÉ È 50
Emanuele Bonanni ALLA RICERCA DI FONDAMENTALE PER I
NUOVE SKILLS BIG DATA
TEMPI DI
CFO TINYML: 5 ELABORAZIONE 55
Lidia Balica L’APPRENDIMENTO DEI BIG DATA
AUTOMATICO SU
MICROCONTROLLORE QUALI SONO
Editorial Assistant SONO ORA DISPONIBILI
LE PREVISIONI 59
10 TECNOLOGICHE PER
Maria Pisani LE SCHEDE INDUSTRIALI IL 2022? L’ANALISI DI
BICS5 3D TLC CON VICOR CORPORATION
112 LAYER DI APACER
Maker in Chief OTTIMIZZATE PER SMART IOT E COME TRASFERIRE
Giordana Francesca Brescia
RICONOSCIMENTO UNO STILE PITTORICO 62
FACCIALE AI SU UNA FOTOGRAFIA
CON PYTHON
STREAMING DI
Advertising & Marketing TEMPERATURA 12 L’APPRENDIMENTO
Cristian Balica E UMIDITÀ CON AUTOMATICO 68
L’ECOSISTEMA APPLICATO
cristian@contangosl.com BIG DATA – PARTE 1 ALL’ASTRONOMIA
STREAMING DI AVNET ABACUS
Graphic Designer TEMPERATURA 16 RICEVE IL PREMIO 73
Marilde Mirra E UMIDITÀ CON HARWIN “EUROPEAN
L’ECOSISTEMA BIG DISTRIBUTOR OF THE
DATA – PARTE 2 YEAR 2021”
Circulation ARDUINO UNO MINI RILEVAMENTO DELLE
LIMITED EDITION: 28 INTRUSIONI SU RETE 74
Users - 144.449 L’EVOLUZIONE CAN-BUS CON TINYML
Social Network - 130.363 MINIATURIZZATA DELLA
STORICA SCHEDA A COME DISCRIMINARE
MICROCONTROLLORE GLI ASINTOMATICI 79
© Copyright COVID DA UN COLPO
CHE COS’È IL DI TOSSE
Tutti i diritti di riproduzione o di traduzione TRANSFER LEARNING 34
degli articoli pubblicati sono riservati. E COME UTILIZZARLO TENSORFLOW:
Manoscritti e disegni sono di proprietà di RICONOSCIMENTO 84
INTELLIGENZA AUTOMATICO DI
Contango SL. ARTIFICIALE CON 41 CARATTERI SCRITTI
E’ vietata la riproduzione anche ARDUINO A MANO
parziale degli articoli salvo espressa
SFIDE E SOLUZIONI
autorizzazione scritta dell’editore. I
PER LO SVILUPPO DI 45 REALIZZIAMO UNA
TELA VIRTUALE CON 89
contenuti pubblicitari sono riportati senza APPLICAZIONI DI EDGE
responsabilità, a puro titolo informativo. MACHINE LEARNING OPENCV PER PYTHON
Firmware 2.0 - 3
Nuovi FPGA e SoC PolarFire® Low-Density
Metà della Potenza Statica delle Alternative e
con Impatto Termico Minimo
I sistemi di Edge computing necessitano di dispositivi programmabili compatti con un basso consumo
energetico e un impatto termico ridotto così da eliminare la ventilazione ed altri sistemi di riduzione del
calore, ma allo stesso tempo devono fornire una solida potenza di calcolo. Gli FPGA e SoC PolarFire® di
Microchip hanno risolto questa sfida riducendo il consumo di potenza statica del 50%.
I miglioramenti effettuati su FPGA PolarFire e SoC PolarFire superano tutti i valori di prestazioni/potenza
di qualsiasi alternativa FPGA o FPGA SoC a bassa densità presenti sul mercato, con una struttura FPGA
veloce, capacità di elaborazione del segnale, transceiver più capaci e l’unico processore basato su
architettura RISC V® application-class rinforzato oggi disponibile con 2 megabyte (MB) di cache L2 e
supporto di memoria Low Power DDR4 (LPDDR4).
Superano ogni confronto in termini di potenza, dimensioni del sistema, costi e sicurezza in svariate
applicazioni, tra cui smart embedded vision e sistemi automotive, automazione industriale,
comunicazioni, difesa e IoT aventi vincoli termici, in cui né la potenza né le prestazioni possono essere
oggetto di compromessi.
Aspetti salienti
• Famiglie di prodotti da 25k LE per System On Chip (SoC) e 50k LE per FPGA
• Fattore di forma più piccolo, con package di 11x11 mm
• Transceiver da 12.7G, supporto multiprotocollo 10 Gb
• Potenza statica inferiore, attiva all’accensione
• Maggiore margine termico per una maggiore capacità di elaborazione
• Sicurezza e affidabilità migliori della categoria
Il nome e logo Microchip, il logo Microchip e PolarFire

sono marchi registrati di Microchip Technology
Incorporated negli U.S.A. e in altri Stati.
Tutti gli altri marchi appartengono ai rispettivi titolari.
© 2022 Microchip Technology Inc. Tutti i diritti riservati.
DS00004279A. MEC2405A-ITA-02-22
microchip.com/lowpowerFPGAs
TINYML:
L’APPRENDIMENTO
AUTOMATICO SU
MICROCONTROLLORE di Andrea Garrapa
Negli ultimi dieci anni abbiamo assistito ad una crescita esponenziale delle dimensioni degli algoritmi di
apprendimento automatico a causa dei miglioramenti nella velocità dei processori e dell'avvento dei Big
Data. Sebbene questi risultati siano lodevoli, ciò ha anche contribuito a stimolare l'interesse all'interno della
comunità che si occupa di AI verso un computing più efficiente dal punto di vista energetico. Da tale interes-
se nasce quello che oggi conosciamo come tiny Machine Learning (tinyML). In questo articolo faremo una
panoramica su questa disciplina emergente che si pone come punto di intersezione tra Machine Learning e
dispositivi IoT (Internet of Things) integrati.
INTRODUZIONE comunicazione wireless, che su questa scala è di gran
T
radizionalmente il Machine Learning viene visto, lunga superiore a quello del calcolo. Inoltre, l'efficienza di
dagli specialisti IoT, come una tecnologia lato TinyML consente una classe di applicazioni intelligenti,
server. In particolare, i sensori sul dispositivo ac- alimentate a batteria e sempre attive, che può rivoluzio-
quisiscono i dati e li inviano al cloud, dove i modelli di nare la raccolta e l'elaborazione in tempo reale dei dati.
Machine Learning (ML) su macchine performanti li ela-
borano. Questo rende necessaria una connessione di rete CASI D'USO
ed una certa latenza, per non parlare dei costi di hosting. Benché la tecnologia sia ancora in fase di maturazione,
La soluzione a questi vincoli risiede nel distribuire i mo- esistono una serie di casi d'uso ben consolidati. Tutti noi
delli ML sugli stessi dispositivi IoT. Avvicinando l'ap- conosciamo le parole di attivazione audio come "Hey Go-
prendimento macchina ai sensori, è possibile rimuovere ogle" per gli smartphone Android o "Hey Siri" su iPhone.
la dipendenza da una connessione di rete ed ottenere una Esse rappresentano un esempio di inferenza ML sempre
latenza molto più bassa con il server. Inoltre, un minore attiva. Eseguire queste attività attraverso l'unità di ela-
utilizzo della rete si traduce in un minore consumo ener- borazione centrale (CPU) principale di uno smartphone
getico ed una maggiore sicurezza in termini di privacy. Per esaurirebbe la batteria in poche ore. Ma, distribuendo un
tutti questi motivi, negli ultimi anni, è aumentato l'interesse modello tinyML su un hardware specializzato con consumi
da parte di università e industria, per portare l'apprendi- inferiori ad 1 mW permetterebbe a questi circuiti di essere
mento automatico su dispositivi di classe microcon- sempre attivi per 1 anno alimentandoli solo con una bat-
trollore. L'obiettivo di "TinyML" è quindi quello di portare teria a moneta. Quelli che oggi vengono considerati casi
l'inferenza ML su dispositivi a bassissima potenza, tipi- d'uso ML tradizionali possono essere considerati come at-
camente sotto un milliWatt, e rompere così la tradizionale tività TinyML in futuro. Con il miglioramento dell'hardware
barriera posta dall'alimentazione, primo degli impedimenti di inferenza a bassissima potenza, la soglia di redditività
alla realizzazione dell'Intelligenza Artificiale ampiamen- relativa all'uso di TinyML si espanderà. Inoltre, TinyML
te distribuita. Eseguendo l'inferenza sul dispositivo vici- avrà un ruolo significativo da svolgere per le tecnologie
no ai sensori, TinyML consente una maggiore reattività del futuro. Ad esempio, molte delle caratteristiche fonda-
e privacy evitando il costo energetico associato alla mentali degli occhiali di realtà aumentata (AR) richiedono
Firmware 2.0 - 5
TINYML: L’APPRENDIMENTO AUTOMATICO SU MICROCONTROLLORE
Tabella 1: Modelli di rete neurale per tipologia di input e casi d'uso del tinyML
un'alimentazione a batteria, la necessità di essere sem- a 32 bit a basso consumo ed economici ha rivoluziona-
pre accesi e l'impossibilità di usufruire di collegamenti con to la capacità di calcolo periferica (edge). Piattaforme
latenza a causa di stretti vincoli di tempo reale. Natural- basate su Cortex-M ora eseguono regolarmente attività
mente, queste non sono le uniche applicazioni possibili che in precedenza non erano fattibili a questa scala. La
di TinyML. In un mondo in cui i dati stanno diventando matematica vettoriale veloce supporta NN e implementa-
sempre più importanti, la capacità di distribuire risorse di zioni SVM altamente efficienti. Sebbene gli MCU generici
apprendimento automatico a dispositivi con memoria limi- offrano flessibilità, la massima efficienza delle prestazioni
tata ed in località remote potrebbe avere enormi vantaggi di TinyML proviene da hardware specializzati.
in settori ad alta intensità di dati.
DEEP COMPRESSION
MODELLI Gli algoritmi TinyML funzionano in modo molto simile ai
L'utilizzo delle reti neurali (NN) risulta predominante nel tradizionali modelli di Machine Learning. In genere, i mo-
panorama dei modelli per ML tradizionale. Per alcuni casi delli vengono addestrati come al solito su un computer o
d'uso TinyML, invece, è soluzione comune utilizzare altre nel cloud. Quindi il vero lavoro di tinyML avviene in seguito
tipologie di modelli con più bassi requisiti di calcolo e me- quando il modello è pronto. Per raggiungere l'obiettivo di
moria, come ad esempio gli alberi decisionali. Tuttavia, ridurre la memoria e l'energia necessarie per eseguire l'in-
l'apprendimento automatico sui dispositivi di classe MCU ferenza viene utilizzata la tecnica nota come Deep Com-
è diventato fattibile solo di recente, quindi non esistono pression (compressione profonda). Si tratta di una pipe-
modelli ampiamente accettati come per i dispositivi mobili. line a tre stadi (Figura 1) in grado di ridurre la memoria
Nella Tabella 1 vengono riassunti i modelli più utilizzati a richiesta dalla rete neurale cercando anche di preservare
seconda del tipo di input. l'accuratezza originale.
L'hardware TinyML è definito dal suo bassissimo consu- 1. Nel primo stadio detto pruning, avviene la pota-
mo energetico, che è spesso nella gamma di 1 mWatt e tura della rete per rimuovere le connessioni ridon-
inferiore. Nella parte superiore di questa gamma ci sono danti, mantenendo solo le connessioni più infor-
efficienti MCU a 32 bit, come quelli basati sui processori mative
Arm Cortex-M7, e in fondo ci sono nuovi motori di inferen- 2. Successivamente, nel secondo stadio, i pesi ven-
za a bassissima potenza. Anche i più grandi dispositivi gono quantizzati in modo che più connessioni con-
TinyML consumano drasticamente meno potenza rispetto dividano lo stesso peso. In questo modo sarà suf-
ai più piccoli dispositivi ML tradizionali. L'avvento di MCU ficiente memorizzare solo i pesi effettivi e gli indici
6 - Firmware 2.0
Figura 1: La pipeline di compressione a tre stadi: potatura, quantizzazione e codifica Huffman. Potatura riduce il numero
di pesi di 10 volte, mentre la quantizzazione migliora il tasso di compressione tra 27 e 31. La codifica di Huffman offre una
maggiore compressione tra 35 e 49. Lo schema di compressione non subisce alcuna perdita di precisione
Infine, la rete viene riaddestrata per apprendere i pesi fi-

nali per i rimanenti collegamenti sparsi. L'operazione di
potatura riduce il numero dei parametri da 9 fino a 13 volte
quello della rete originale.
La struttura sparsa che risulta dalla potatura viene me-
morizzata utilizzando il formato CSR o formato CSC, che
richiede 2a + n + 1 numeri, dove a è il numero di elementi
diversi da zero e n è il numero di righe o colonne. Per
aumentare ulteriormente la compressione vengono me-
morizzate le differenze di indice invece delle posizioni as-
solute e poi codificate.
QUANTIZZAZIONE
La quantizzazione della rete neurale e la condivisione
dei pesi comprimono ulteriormente la rete potata riducen-
Figura 2: Operazioni eseguite nello stadio di Pruning
do il numero di bit necessari per rappresentare ogni peso.
Per prima cosa viene ridotto il numero di pesi effettivi da
3. Infine, nel terzo stadio, viene applicata la codifica memorizzare facendo in modo che più connessioni con-
di Huffman per sfruttare la distribuzione distorta dividano lo stesso peso, quindi vengono ottimizzati i pesi
dei pesi effettivi. condivisi.
Analizzando nel dettaglio lo schema di Figura 3, suppo-
L'intuizione principale di questa tecnica è che la potatura niamo di avere uno strato con 4 neuroni di input e 4 neu-
e la quantizzazione sono in grado di comprimere la rete roni in uscita. La matrice dei pesi avrà allora dimensione
senza interferire a vicenda, portando così a un tasso di 4x4. Valutiamo anche la matrice gradiente, anch'essa 4x4.
compressione sorprendentemente alto. Rendendo la me- 1. I pesi vengono raggruppati intorno a 4 valori ini-
moria richiesta molto piccola (pochi megabyte), tutti i pesi ziali
possono essere memorizzati nella cache invece di andare 2. Usando il clustering k-means con k=4 vengono
su DRAM con un notevole risparmio di energia. Vediamo identificati i pesi condivisi
nel dettaglio i tre stadi. 3. Tutti i pesi appartenenti allo stesso gruppo condi-
videranno lo stesso peso condiviso
POTATURA (PRUNING) 4. Durante l'aggiornamento, i valori della matrice gra-
In Figura 2 vengono rappresentate nel dettaglio le ope- diente vengono raggruppati, sommati, e sottratti
razioni all'interno della potatura (pruning). Per prima dai centroidi condivisi (il vettore dei pesi condivi-
cosa avviene lo studio della connettività tramite il normale si) dell'ultima iterazione. Si ritorna quindi al punto
addestramento della rete. Successivamente, vengono po- 3.
tate le connessioni di piccolo peso. Tutte le connessioni
con pesi inferiori a una soglia vengono rimosse dalla rete. Ricapitolando, originariamente ci sono 4x4 = 16 pesi ma
Firmware 2.0 - 7
Figura 4: Nello stadio relativo alla codifica di Huffman ven-

gono codificati sia i pesi condivisi che gli indici
tatura e quantizzazione utilizzati singolarmente o insieme.

Operando individualmente, l'accuratezza della rete potata
inizia a diminuire in modo significativo quando viene com-
Figura 3: Operazioni all'interno dello stadio di quantizzazione pressa al di sotto dell'8% della sua dimensione originale;
anche l'accuratezza della rete solo quantizzata inizia a di-
soltanto 4 pesi condivisi. Simili pesi vengono raggruppati minuire in modo significativo quando viene compressa al
insieme per condividere lo stesso peso condiviso. Quindi, di sotto dell'8% dell'originale. Ma, se combinate insieme
invece di memorizzare 16 pesi a 32 bit ciascuno, si devo- le due tecniche, la rete può essere compressa fino al 3%
no memorizzare 4 pesi condivisi a 32 bit ciascuno ed in della dimensione originale senza perdita di precisione. In
più 16 elementi a 2 bit ciascuno relativi agli indici. Facen- sostanza, l'utilizzo contemporaneo delle tecniche di pota-
do il calcolo del numero di bit necessari per memorizzare tura e quantizzazione non porta ad effetti collaterali dell'u-
pesi e indici si passa dagli iniziali [16 x 32 = 512 bit] ai [(4 na sull'altra, ed è per questo che combinandole insieme
x 32) + (2 x 16) = 160 bit], con un fattore di compressione si riesce ad ottenere un maggiore tasso di compressione
[512/160 = 3,2]. senza perdita di accuratezza.
CODIFICA DI HUFFMAN COMPILAZIONE

La codifica di Huffman viene comunemente usata per Al termine della riduzione di dimensioni del modello occor-
la compressione dei dati senza perdita. Utilizza parole di re convertirlo in un formato che possa essere interpretato
codice di lunghezza variabile per codificare i simboli di ori- da un qualche interprete di reti neurali leggere. I più popo-
gine. La probabilità di occorrenza per ogni simbolo, ne de- lari sono probabilmente TF Lite (per modelli di dimensioni
termina la lunghezza del codice. I simboli più comuni sono fino a 500 KB) e TF Lite Micro (per modelli di dimensione
rappresentati con meno bit. Come mostrato in Figura 4 la fino a 20 KB). Il modello viene quindi compilato in codice
codifica viene applicata sia ai pesi condivisi che agli indici. C o C++ ed eseguito dall'interprete sul dispositivo.
Queste tecniche portano ad una riduzione delle dimen- TensorFlow Lite per microcontrollori è scritto in C++ 11
sioni della rete originale. Nasce spontanea la domanda e richiede una piattaforma a 32 bit. È stato ampiamente
di come non vi sia una perdita nell'accuratezza della rete. testato con molti processori basati sull'architettura della
Una analisi delle tecniche descritte ha evidenziato i valori serie Arm Cortex-M ed è stato portato su altre architetture,
di accuratezza a differenti tassi di compressione per po- incluso ESP32. Il framework è disponibile come libreria
8 - Firmware 2.0
Arduino. Può anche generare progetti per ambienti di svi-

luppo come Mbed. È open source e può essere incluso in
qualsiasi progetto C++ 11. TensorFlow Lite per micro-
controllori supporta le seguenti schede di sviluppo:
• Arduino Nano 33 BLE Sense
• SparkFun Edge
• Kit Discovery STM32F746
• Adafruit EdgeBadge
• Kit Adafruit TensorFlow Lite per microcontrollori
• Adafruit Circuit Playground Bluefruit
• Espressif ESP32-DevKitC
• Espressif ESP-EYE
CONCLUSIONI
In questo articolo abbiamo offerto al lettore una panora-
mica su una disciplina emergente denominata TinyML.
TinyML si traduce nel fare in modo che l'Intelligenza Ar-
tificiale (Machine Learning) possa essere eseguita su
dispositivi a bassissimo consumo energetico, come i
microcontrollori. Eliminare le connessioni dei dispositivi
periferici con le unità centrali di elaborazione dei dati, rap-
presenta per il mondo IoT una grande possibilità in termi-
ne di efficientamento energetico e riduzione dei costi. Inol-
tre, la capacità di eseguire modelli di Machine Learning su
dispositivi con risorse limitate aprirà sicuramente le porte
a molte nuove possibilità. Impegnarsi nell'approfondimen-
to di queste tematiche può risultare un investimento pro-
fittevole data la carenza di esperti in un settore nascente
ma in forte crescita.
RIFERIMENTI
• "Tiny Machine Learning: The Next AI Revolution",
Matthew Stewart, towardsdatascience.com
• "Deep compression: Compressing deep neural
networks with pruning, trained quantization and
Huffman coding", Song Han, Huizi Mao, William
J. Dally, Published as a conference paper at ICLR
2016
• "Benchmarking TINYML systems: challenges and
direction", Colby R. Banbury, Vijay Janapa Reddi,
Max Lam
L’autore è a disposizione nei commenti per eventuali

approfondimenti sul tema dell’Articolo. Di seguito il link per accedere
direttamente all’articolo sul Blog e partecipare alla discussione:
https://it.emcelettronica.com/tinyml-lapprendimento-
automatico-su-microcontrollore
Firmware 2.0 - 9
SONO ORA DISPONIBILI
LE SCHEDE INDUSTRIALI
BICS5 3D TLC CON
112 LAYER DI APACER
OTTIMIZZATE PER SMART
IOT E RICONOSCIMENTO
FACCIALE AI di Apacer
Secondo una ricerca di Mordor Intelligence, il mercato del riconoscimento facciale è stato valutato a 3,72
miliardi di dollari nel 2020 e si prevede che sarà valutato a 11,62 miliardi di dollari entro il 2026, registrando
un CAGR di circa il 21,71% nel periodo di previsione.
L
a tecnologia di riconoscimento facciale sta finalmen-
te prendendo piede. È andata ben oltre l'utilizzo de-
gli agenti di polizia in cerca di un sospettato su una
telecamera di sorveglianza.
Ora, la tecnologia smart del riconoscimento facciale ba-
sato sull'Intelligenza Artificiale è comune nelle applicazio-
ni smart retail, finanza, trasporti e persino nell'assistenza
sanitaria.
Ma, con il diffondersi della sua adozione, i dispositivi di
riconoscimento facciale sono chiamati a funzionare in
luoghi e ambienti sempre più difficili. Tenendo presente
tutti questi sviluppi, Apacer ha sviluppato e ha rilasciato la Neanche gli ambienti compromessi rallenteranno queste
serie CH120 di schede industriali alimentate dalla più schede: il loro ampio intervallo di temperatura implica che
recente tecnologia BiCS5 3D TLC NAND a 112 layer, otti- funzionano senza problemi a temperature comprese tra
mizzata sia per il riconoscimento facciale AI sia per appli- -40 e 85 °C. La serie CH120 di schede industriali è inoltre
cazioni IoT intelligenti. BiCS5 promette vantaggi concreti dotata di over-provisioning a valore aggiunto e tecnologia
e misurabili per gli SSD, poiché migliora notevolmente la SLC-liteX. Il primo riduce drasticamente l'amplificazione
capacità mantenendo la latenza di trasmissione estrema- in scrittura, estendendo la durata operativa di un SSD,
mente bassa. Infatti, la serie CH120 di grado A2 di Apacer mentre il secondo consente a un SSD di aumentare la
offre 4.000/2.000 IOPS per prestazioni di lettura/scrittura sua resistenza fino a 30.000 cicli P/E. È 10 volte superio-
di immagini 4K. re rispetto ai 3D TLC SSD standard. La serie CH120 di
10 - Firmware 2.0
SONO ORA DISPONIBILI LE SCHEDE INDUSTRIALI BICS5 3D TLC CON 112 LAYER
DI APACER OTTIMIZZATE PER SMART IOT E RICONOSCIMENTO FACCIALE AI
schede industriali è solo l'ultimo esempio di come Apacer

stia rispettando lo spirito del suo brand di "Adding Value,
Enhancing Collaboration".
le nostre promesse, ci impegniamo per il miglioramento

costante e sviluppiamo soluzioni reciprocamente vantag-
Si trovano in una vasta gamma di prodotti BiCS5 3D TLC giose per noi e per i nostri clienti. Creiamo continuamente
che include i drive ST250 da 2,5 pollici e gli SSD indu- soluzioni di storage innovative e diversificate e servizi di
striali M.2 2280. Ulteriori upgrade in termini di capaci- integrazione hardware/software per vari settori. Ci impe-
tà (fino a 2TB), latenza e affidabilità arriveranno mentre gniamo nel diventare un partner migliore nell'ecosistema
Apacer guarda al 2022, offrendo vantaggi interessanti per industriale e nell'offrire vantaggi sostanziali a tutti gli sta-
il 5G, lo smart IoT, l'edge computing, la sorveglianza si- keholders.
cura, l'assistenza sanitaria intelligente e le applicazioni di
Deep Learning. Per informazioni su Apacer visitare la web page:
https://industrial.apacer.com/en-ww
INFORMAZIONI SU APACER
Fondata nel 1997, Apacer (TWSE: 8271) è un marchio
globale leader nello storage digitale, con potenzialità com-
plete di ricerca e sviluppo, progettazione, produzione e
marketing. Con anni di esperienza nella tecnologia brevet-
tata dell'archiviazione digitale e una profonda esperienza
di successo in ricerca e sviluppo, Apacer offre una gamma
competitiva di prodotti e servizi personalizzati. Le nostre L’autore è a disposizione nei commenti per eventuali
linee di prodotti sono diversificate e coprono soluzioni per approfondimenti sul tema dell’Articolo. Di seguito il link per accedere
moduli di memoria, SSD industriali, prodotti di consumo direttamente all’articolo sul Blog e partecipare alla discussione:
per lo storage digitale e applicazioni integrate Internet of https://it.emcelettronica.com/sono-ora-disponibili-le-

Things. Apacer si impegna a implementare il nostro valore schede-industriali-bics5-3d-tlc-con-112-layer-di-apacer-
fondamentale "Becoming Better Partners:" manteniamo ottimizzate-per-smart-iot-e-riconoscimento-facciale-ai
Firmware 2.0 - 11
STREAMING DI
TEMPERATURA E UMIDITÀ
CON L’ECOSISTEMA BIG
DATA – PARTE 1 di Fulvio De Santis
In questo articolo viene presentato un progetto dimostrativo del processo di implementazione di una sem-
plice architettura per l'elaborazione in tempo reale e in batch delle letture di temperatura e umidità rilevate
da un sensore DHT11, elaborate dalla scheda Arduino e pubblicate sul web mediante l’impiego del modulo
Wi-Fi ESP8266 e mediante l'ausilio di tecnologie open source dell'ecosistema Big Data. Lo scopo del progetto
è di semplificare il flusso in streaming di dati attraverso i diversi strumenti hardware e software utilizzati,
dall’acquisizione dei dati alla loro trasformazione. In questa prima parte del progetto faremo una descrizio-
ne dell’architettura del sistema, dell’hardware e del software utilizzato.
INTRODUZIONE come servizi per memorizzare e interrogare la persistenza
I
n questo progetto viene utilizzata la scheda Arduino, un degli argomenti. Per questo, è possibile utilizzare Apache
sensore di temperatura e umidità DHT11 della famiglia Kafka per reindirizzare i messaggi. Apache Kafka è un
di sensori DHT, un modulo Wi-Fi ESP8266, Internet e progetto open source sviluppato dalla fondazione Apache
alcune librerie e programmi software. I sensori DHT sono Software. Kafka implementa un modello di pubblicazione e
piuttosto lenti e semplici ma vanno bene per questo pro- sottoscrizione per l'intermediazione di messaggi attraver-
getto. Sono costituiti da due componenti principali: un so canali o argomenti, offrendo più opzioni a livello di sicu-
sensore di umidità capacitivo e un termistore. Sono anche rezza, archiviazione e manipolazione dei messaggi. Per
in grado di effettuare conversioni da analogico a digita- reindirizzare i messaggi tra un servizio di pubblicazione
le dei valori di temperatura e umidità. L’ESP8266 viene e l'altro, è possibile utilizzare lo strumento Apache NiFi,
utilizzato per la gestione e l'invio dei dati su Internet. I di- che consente di costruire flussi di dati chiamati modelli,
spositivi della famiglia ESP2866 sono alternative a basso che sono costituiti da blocchi di istruzioni (relativamente
costo che supportano il protocollo TCP/IP e dispongono di di basso livello) chiamati processori, che consentono di
una piccola unità di memoria che consente di caricare le acquisire e manipolare i dati in tempo reale, trasformarli e
istruzioni nel chip, e di un proprio microcontrollore. Posso- reindirizzarli ad altri servizi come file in HDFS, database
no essere numerosi i client in grado di ricevere o consul- ed altri servizi di persistenza (persistenza è la particolari-
tare le informazioni generate da una scheda Arduino. Una tà dei dati di un programma di sopravvivere all'esecuzio-
delle opzioni più utilizzate dalle community di sviluppo è ne del programma stesso che li ha creati). Va notato che
Mosquitto. Mosquitto è un'implementazione open source è vantaggioso inviare le informazioni ad un supporto di
abbastanza leggera di un broker basato sul protocollo persistenza che consente l'elaborazione batch delle infor-
MQTT (Message Queuing Telemetry Transport, un proto- mazioni in modo più tradizionale. Allo stesso modo degli
collo di rete di pubblicazione-sottoscrizione operante su strumenti open source, Apache Hive si presenta come
TCP/IP che trasporta i messaggi tra i dispositivi). Mosquit- un'opzione interessante. Hive è un Data WareHouse rela-
to include librerie scritte in C e C++. zionale (Data WareHouse è una raccolta di dati strutturati
Tuttavia, Mosquitto non dispone di molte funzioni che pos- originati da fonti interne ed esterne al sistema informati-
sono essere di grande rilevanza per un progetto specifico, vo). Questi tipi di elaborazioni richiedono scansioni mode-
12 - Firmware 2.0
STREAMING DI TEMPERATURA E UMIDITÀ CON L’ECOSISTEMA BIG DATA – PARTE 1
Figura 1: Flusso dei dati di temperatura e umidità
ratamente semplici, interattive e veloci da implementare. La pubblicazione viene effettuata su un argomento speci-
Per questo motivo, viene utilizzata la console interattiva fico e riferita ad un nome utente e una password predefi-
Apache Zeppelin. niti. Il server MQTT dispone di un elenco di autorizzazioni
con cui definisce quali utenti possono pubblicare informa-
IL PROGETTO zioni su argomenti esistenti.
Analizziamo il flusso dei dati di temperatura e umidità ge-
nerati dal sensore DHT11 seguendo le varie fasi indicate 3, 4 e 5) Acquisizione dati dal server MQTT in tempo
dalla numerazione riportata sullo schema funzionale di reale
Figura 1. Il servizio Apache NiFi ha un set organizzato di istruzioni
che gestiscono il flusso di dati durante l'acquisizione, ov-
1) Acquisizione dei dati di temperatura e umidità dal vero:
sensore DHT11 NiFi si connette o si iscrive all'argomento Mosquitto e cat-
Il sensore DHT11 invia i dati di temperatura e umidità alla tura i messaggi che arrivano in tempo reale; NiFi integra
piattaforma Arduino. ESP8266 acquisisce le letture ogni il messaggio ricevuto (la stringa JSON) definendo nuovi
3 secondi calcolando la percentuale di umidità e la tem- campi esterni alla stringa relativi agli aspetti tecnici del
peratura in gradi Celsius (° C) e in gradi Fahrenheit (° F) messaggio e del server MQTT; NiFi inserisce la stringa
nell'ambiente. Viene inoltre calcolato l'indice di percezio- JSON e i nuovi campi nel datastore Hive; NiFi pubblica il
ne del calore in gradi Celsius e Fahrenheit, che determi- messaggio originale su Kafka; Hive e Kafka salvano i dati
na come le persone percepiscono la temperatura in base in modo persistente; Hive consente di eseguire l'elabora-
all'umidità dell'ambiente. Successivamente, mediante zione in batch dei dati storici memorizzati; Kafka consente
l’ESP8266, viene effettuato l’invio di una richiesta ad un l'elaborazione in tempo reale dei dati inviati dalla piattafor-
servizio Web esterno per determinare l'ora di lettura dei ma Arduino-ESP8266.
dati in base ad un fuso orario predefinito.
6 e 7) Trattamento dei dati
2) Pubblicazione dei dati sul server MQTT Zeppelin esegue blocchi di codice (in Scala e SQL): ese-
Il messaggio che verrà inviato al server MQTT è costruito gue una query sui dati nel data WareHouse; si iscrive in
nel formato JSON. Contiene i dati acquisiti dal sensore, tempo reale a Kafka per monitorare ed elaborare i dati
le informazioni calcolate, la data e l’ora della lettura, il nu- ricevuti in tempo reale in diverse finestre temporali; il codi-
mero di microsecondi dall'accensione della piattaforma ce viene eseguito sul motore di elaborazione Spark; i dati
Arduino e un identificatore univoco per il client emittente. ottenuti in ogni finestra temporale vengono trasformati e
Vengono eseguiti i controlli della connessione Internet e archiviati in tabelle in Hive; le temperature misurate in gra-
della connessione al server MQTT su cui viene pubblicato di Fahrenheit vengono mediate nelle finestre temporali e
il payload. memorizzate in Hive.
Firmware 2.0 - 13
Figura 2: Schema di assemblaggio
INSTALLAZIONE DELL’IDE DI ARDUINO E DEL- do su Sketch -> #Include libreria -> Aggiungi libreria
LA SCHEDA ESP8266 da file .ZIP; oppure da Sketch -> #Include libreria ->
Il software dell’IDE di Arduino per Windows, Linux e Gestione librerie, nel Gestore Librerie cercare le librerie
Mac, necessario per caricare il codice sulla scheda Ar- e installarle. Le librerie aggiuntive da installare e utilizzare
duino, può essere scaricato dal sito ufficiale di Arduino in questo progetto sono:
www.arduino.cc. Per utilizzare il modulo Wi-Fi ESP8266, • DHT sensor library by Adafruit
è necessario installare componenti aggiuntivi nell'IDE. Ciò • Adafruit Unified Sensor
consentirà di configurare le opzioni di compilazione del • PubSubClient 2.6.0
codice che verrà inviato al componente e utilizzare i me- • Ora 1.5.0
todi e le librerie per le connessioni. L'installazione può es- • Client NTPC 3.1.0
sere eseguita utilizzando il gestore schede dell’IDE di Ar-
duino: aprire l'IDE Arduino, poi con File -> Impostazione REALIZZAZIONE PRATICA
nel campo in basso “URL aggiuntive per il Gestore delle In Figura 2 è riportato lo schema elettrico di collegamento
Schede” immettere l’indirizzo http://arduino.esp8266.com/ dei componenti, e in Figura 3 la piedinatura dei compo-
stable/package_esp8266com_index.json. nenti DHT11 e ESP8266. Su una breadboard sperimen-
tale, utilizzando dei jumper, realizzate i collegamenti dei
INSTALLAZIONE DELLE LIBRERIE componenti come indicato dallo schema di Figura 2.
Per gestire il sensore DHT11, eseguire i processi di pub- La scheda Arduino è alimentata tramite collegamento al
blicazione dei dati e altre funzioni, è necessario instal- computer con un cavo USB. Il modulo ESP8266 è alimen-
lare alcune librerie aggiuntive. Per installare una libreria tato da una tensione di 3,3 V della scheda Arduino e uti-
aggiuntiva è possibile utilizzare il Gestore delle Librerie lizza un resistore da 10k fra la 3,3V e i pin VCC e CH_PD.
dell'IDE Arduino, se si dispone dei file .ZIP relativi, andan- Il sensore di temperatura DHT11 funziona con una tensio-
14 - Firmware 2.0
Figura 3: Piedinatura dei componenti
ne di alimentazione di 5V e un resistore di pull-up da 1k è predefinita, la maggior parte dei modelli funziona con una
collegato fra il pin 2 Data e la 5V. velocità di 115200.
CONFIGURAZIONE DELL’ESP8266 Per caricare le istruzioni sul modulo Wi-Fi è necessario

Poiché il caricamento delle istruzioni non sarà diretto alla che all'avvio l’ESP8266 entri in Flash Mode (modalità di
scheda Arduino ma all’ESP8266, in quanto è questo mo- programmazione), che si ottiene attraverso la configura-
dulo che invierà i dati e che si occuperà di gestirli e condi- zione dei pin come sarà descritto nella fase di program-
zionarli, occorre selezionare la scheda ESP8266 nell’IDE mazione che vedremo nella seconda parte del progetto.
e configurare le opzioni di compilazione. Per fare ciò, se-
lezioniamo la scheda ESP8266 da Strumenti -> Scheda CONCLUSIONI
-> Generic ESP8266 Module. In questo articolo è stata presentata la prima parte di un
Nella scheda Strumenti appariranno nuove opzioni che progetto/tutorial per l'elaborazione in tempo reale e la pub-
dovranno essere configurate come segue: blicazione sul web delle letture di temperatura e umidità
Flash Mode: "DIO" rilevate da un sensore della famiglia DHT, elaborate dalla
Flash Size: "512K (64 SPIFFS)" scheda Arduino e inviate e gestite in rete mediante il mo-
Debug port: "Disabled" dulo Wi-Fi ESP8266 e alcune tecnologie software open
Debug level: "Ninguno" source Big Data. Nella seconda parte del tutorial comple-
Reset Method: "ck" teremo la realizzazione pratica del progetto stesso.
Crystal Frequency: "26 MHz"
Flash Frequency: "40 MHz"
CPU Frequency: "80 MHz"
Upload Speed: "115200" (1)
Programador: "AVRISP mkII"
(1): A seconda del modello di ESP8266 utilizzato, potreb- https://it.emcelettronica.com/streaming-di-temperatura-e-
be essere necessario modificare il parametro velocità di umidita-con-lecosistema-big-data-parte-1
caricamento ad un baud rate di 9600. Per impostazione
Firmware 2.0 - 15
STREAMING DI
TEMPERATURA E UMIDITÀ
CON L’ECOSISTEMA BIG
DATA – PARTE 2 di Fulvio De Santis
In questo articolo tratteremo la seconda parte di un progetto dimostrativo per l'elaborazione in tempo reale
e la pubblicazione sul web delle letture di temperatura e umidità rilevate da un sensore della famiglia DHT,
elaborate e inviate in rete mediante la piattaforma Arduino-ESP8266 e trasformate in streaming con l’ausilio
di alcune tecnologie software open source Big Data. Completeremo la realizzazione pratica del progetto ini-
ziando con la creazione di uno sketch contenente il codice del programma, lo caricheremo nel modulo Wi-Fi
ESP8266 mediante l’IDE di Arduino, infine, eseguiremo il test e ne vedremo i risultati.
CREAZIONE DELLO SKETCH
D
opo aver aperto l’IDE di Arduino, in un nuovo sketch inseriamo il seguente codice:
#include <Arduino.h>
#include <PubSubClient.h> /* MQTT Broker Library */
#include <ESP8266WiFi.h> /* WiFi Shield ESP8266 ESP-12f Library */
#include <DHT.h> /* Temperature sensor DHT Library */
#include <time.h> /* Time setting library */
#define DHTPIN 2 /* Arduino pin for DHT sensorn */

#define DHTTYPE DHT11 /* DHT sensor model */
const char* ssid = "TUOSSID"; /* Network's name */

const char* password = "TUAPASSWORD"; /* Network's password */
char* topic = "mosquitto_main_topic"; /* MQTT Broker topic */

char* server = "ec2-107-21-12-161.compute-1.amazonaws.com"; /* MQTT broker host */
const char mqtt_user[] = "mosquitto"; /* MQTT broker username */

const char mqtt_password[] = "mosquitto"; /* MQTT broker user password */
const int timezone = -5; /* Timezone (Colombia) */

String clientName = "esp8266"; /* Publisher device identifier */
16 - Firmware 2.0
/* Structure to store DHT sensor data */

struct Metrics {
float humidity;
float celsius;
float fahrenheit;
float heatIndexCels;
float heatIndexFahr;
};
void callback(char* topic, byte* payload, unsigned int length) {

// handle message arrived
}
DHT dht(DHTPIN, DHTTYPE); /* DHT sensor client */

WiFiClient wifiClient; /* WiFi Shield client */
PubSubClient client(server, 1883, callback, wifiClient); /* MQTT Broker client */
/*
* Method: setup
* ----------------------------
* Initial setup of clients and connections.
*
* Initialize:
* Serial port.
* WiFi connection.
* Time client.
* Client name.
* MQTT Broker connection.
*/
void setup() {
Serial.begin(115200);
dht.begin();
delay(10);
wifiConnect();
configureTime();
defineClientName();
connectMQTT();
}
/*
* Method: loop
* ----------------------------
* Non-stoping method that reads and publish sensor data.
* If DHT sensor lectures are invalid, stops iterations and initiates a new one.
*
* Gets date/time information.
* Reads sensor data.
* Creates payload.
Firmware 2.0 - 17
* Prints results.
* Verifies MQTT Broker connection.
* Sends payload
*/
void loop() {
String payload;
time_t now = time(nullptr);
String datetime = buildDateTime(now);
struct Metrics *metric = readSensor();
if(metric == NULL) return;
payload = createPayload(datetime, now, metric);
printResults(datetime, metric);
if(WiFi.status() != WL_CONNECTED){
Serial.println();
Serial.println("Disconnected from WiFi.");
wifiConnect();
}
if(!client.connected()){
Serial.println();
Serial.println("Disconnected from MQTT Broker.");
connectMQTT();
}
publishMQTT(payload);
Serial.println();
delay(3000);
}
/*
* Function: defineClientName
* ----------------------------
* Builds the name of the client and gets the MAC address.
*
*/
void defineClientName()
{
String macStr;
uint8_t mac[6];
WiFi.macAddress(mac);
18 - Firmware 2.0
for (int i = 0; i < 6; ++i) {

macStr += String(mac[i], 16);
if (i < 5)
macStr += ':';
}
clientName += "-";
clientName += macStr;
clientName += "-";
clientName += String(micros() & 0xff, 16);
/*
* Method: connectMQTT
* ----------------------------
* Establish connection with MQTT broker.
* Doesn't finish until conection is stablished.
*
*/
void connectMQTT(){
while(!client.connected()){
Serial.print("Connecting to MQTT Broker: ");
Serial.print(server);
Serial.print(" as ");
Serial.println(clientName);
if (client.connect((char*) clientName.c_str(), mqtt_user, mqtt_password)) {
Serial.println("Connected to MQTT broker");
Serial.print("Topic is: ");
Serial.println(topic);
/*
if (client.publish(topic, "Conection from ESP8266 established")) {
Serial.println("Publish ok");
}
else {
Serial.println("Publish failed");
}
*/
}
else {
Serial.println("MQTT connect failed");
Serial.println("Will reset and try again...");
delay(500);
}
}
Serial.println("");
Firmware 2.0 - 19
/*
* Method: configureTime
* ----------------------------
* Gets date/time info for an specific timezone.
*
*/
void configureTime(){
configTime(timezone * 3600, 0, "pool.ntp.org", "time.nist.gov");
Serial.print("\nWaiting for time");
while (!time(nullptr)) {
Serial.print(".");
delay(500);
}
Serial.println("");
Serial.println("Time configured.");
Serial.println("");
/*
* Method: wifiConnect
* ----------------------------
* Establish WiFi connection.
* Doesn't finish until conection is stablished.
*
*/
void wifiConnect(){
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.print(ssid);
delay(500);
WiFi.mode(WIFI_AP_STA);
WiFi.begin(ssid, password);
int tries = 0;
while (WiFi.status() != WL_CONNECTED) {

delay(500);
Serial.print(".");
tries += 1;
if (tries == 30){
tries = 0;
Serial.println();
20 - Firmware 2.0
Serial.println("Failed.");
Serial.print("Trying again");
}
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
/*
* Function: buildDateTime
* ----------------------------
* Builds date/time information.
*
* now: Current date/time timestamp.
*
* returns: date/time string information in 'yyyy-MM-ddTHH:mm:ssZ' format.
*
*/
String buildDateTime(time_t now){
struct tm * timeinfo;
timeinfo = localtime(&now);
String c_year = (String) (timeinfo->tm_year + 1900);
String c_month = (String) (timeinfo->tm_mon + 1);
String c_day = (String) (timeinfo->tm_mday);
String c_hour = (String) (timeinfo->tm_hour);
String c_min = (String) (timeinfo->tm_min);
String c_sec = (String) (timeinfo->tm_sec);
String datetime = c_year + "-" + c_month + "-" + c_day + "T" + c_hour + ":" + c_min + ":" + c_sec;
if (timezone < 0){

datetime += "-0" + (String)(timezone * -100);
}else{
datetime += "0" + (String)(timezone * 100);
}
return datetime;
}
/*
* Function: readSensor
* ----------------------------
* Reads data from DHT sensor.
*
* returns: DHT data of temperatures and heat indexes.
*
Firmware 2.0 - 21
*/
struct Metrics * readSensor(){
struct Metrics *metric = (Metrics*)malloc(sizeof(struct Metrics));
metric->humidity = dht.readHumidity();
metric->celsius = dht.readTemperature();
metric->fahrenheit = dht.readTemperature(true);
if (isnan(metric->humidity) || isnan(metric->celsius) || isnan(metric->fahrenheit)) {

Serial.println("Failed to read from DHT sensor!");
delay(1000);
return NULL;
}
metric->heatIndexFahr = dht.computeHeatIndex(metric->fahrenheit, metric->humidity);

metric->heatIndexCels = dht.computeHeatIndex(metric->celsius, metric->humidity, false);
return metric;
/*
* Function: createPayload
* ----------------------------
* Creates payload to send.
*
* datetime: String with date/time information.
* now: Current date/time timestamp.
* metric: DHT sensor data.
*
* returns: payload in JSON format.
*
*/
String createPayload(String datetime, time_t now, Metrics* metric){
String payload = "{\"cliente\":";

payload += "\"" + clientName + "\"";
payload += ",\"microsegundos\":";
payload += "\"" + (String)micros() + "\"";
payload += ",\"fecha\":";
payload += "\"" + datetime + "\"";
payload += ",\"timestamp\":";
payload += "\"" + (String)now + "\"";
payload += ",\"celcius\":";
payload += "\"" + (String)metric->celsius + "\"";
payload += ",\"fahrenheit\":";
payload += "\"" + (String)metric->fahrenheit + "\"";
22 - Firmware 2.0
payload += ",\"humedad\":";
payload += "\"" + (String)metric->humidity + "\"";
payload += ",\"ind_cal_cel\":";
payload += "\"" + (String)metric->heatIndexCels + "\"";
payload += ",\"ind_cal_far\":";
payload += "\"" + (String)metric->heatIndexFahr + "\"";
payload += "}";
return payload;
/*
* Method: printResults
* ----------------------------
* Print collected data.
*
*/
void printResults(String datetime, Metrics* metric){
Serial.println("Lecture: "+ (String)datetime);
Serial.println("Humidity: " + (String)metric->humidity);
Serial.println("Temperature: " + (String)metric->celsius + " *C " + (String)metric->fahrenheit +" *F\t");
Serial.println("Heat index: " + (String)metric->heatIndexCels + " *C " + (String)metric->heatIndexFahr + " *F");
}
/*
* Method: publishMQTT
* ----------------------------
* Sends payload to MQTT Broker.
*
*/
void publishMQTT(String payload){
Serial.print("Sending payload: ");

Serial.println(payload);
if (client.publish(topic, (char*) payload.c_str())) {
Serial.println("Publish ok");
}
else {
Serial.println("Publish failed");
}
}
Firmware 2.0 - 23
Figura 1: Schema elettrico dei collegamenti dei componenti
All'interno dello sketch (righe 11 e 12) è necessario modifi- sull’ESP8266 cliccando sul pulsante “Verifica” sull'inter-
care le costanti dichiarate all'inizio con i dati delle creden- faccia IDE di Arduino. Compilato con successo il codice,
ziali di accesso alla rete Wi-Fi: per caricare il codice nel modulo ESP8266 è necessario
collegare la scheda Arduino al computer tramite la porta
const char* ssid = "ILTUOSSID"; /* Network's name */ USB. In questo modo sarà possibile definire la porta di
const char* password = "LATUAPASSWORD"; /* Networ- comunicazione cliccando su Strumenti -> Porta, dove
k's password */ selezioneremo la porta disponibile. A questo punto, pos-
siamo aprire il monitor seriale dell'IDE Arduino che sarà
Il codice si occuperà di: utilizzato per verificare l'esecuzione del codice al termine
• Inizializzare il monitor seriale dell’IDE Arduino, at- del caricamento e all’avvio del programma. Si consigliano
traverso il quale possiamo visualizzare gli output le seguenti opzioni del monitor per visualizzare le informa-
del programma e monitorare lo stato di esecuzione zioni corrette:
• Inizializzare il sensore di temperatura • Scorrimento automatico
• Stabilire una connessione con la rete Wi-Fi definita • Entrambi NL & CR
• Consultare la data e l’ora su un server esterno in • 115200 baud rate
base al fuso orario definito
• Definire il nome del dispositivo che trasmette dati Prima di caricare il codice occorre predisporre l’ESP8266
(il modulo Wi-Fi ESP8266 nel nostro caso) in modalità di programmazione collegando il pin GPIO0
• Stabilire la connessione al server MQTT (jumper bianco, nello schema di Figura 1, GPIO0 è invece
• Prendere le letture del sensore di temperatura e collegato alla 3,3V) a massa, dove è collegato anche il pin
umidità GND (jumper nero) della scheda Arduino e dell’ESP8266.
• Strutturare il payload nel formato JSON Una volta alimentato, il modulo ESP8266 entrerà in moda-
• Inviare il payload al server MQTT lità Flash e sarà possibile caricare le istruzioni dello sketch
• Eseguire letture e controlli di connessione nell’ESP8266 cliccando sul pulsante “Carica” dell’IDE.
• Visualizzare messaggi di controllo e le informazio- Dopo che le istruzioni sono state caricate, bisogna colle-
ni sul monitor seriale alla velocità di trasmissione gare il pin GPIO0 (jumper bianco) del modulo ESP8266
definita (nel nostro caso, 115200) nuovamente alla tensione di 3,3V, come mostrato in Fi-
gura 1. In questo modo, il modulo ESP8266 non entrerà
PROGRAMMAZIONE DELL’ESP8266 in modalità Flash al successivo avvio della piattaforma
È consigliabile compilare il codice prima di caricarlo Arduino, consentendogli di eseguire il codice caricato non
24 - Firmware 2.0
Figura 2: Dati pubblicati di temperatura e umidità
appena riceve alimentazione. Inoltre, il pin Data del sen- destra).

sore DHT11 trasferisce i segnali digitali di temperatura e Consultando periodicamente la tabella Hive, si noterà che
umidità al modulo Wi-Fi ESP8266 tramite il pin GPIO2 il numero di record aumenta in base ai messaggi che ven-
(jumper blu). Nel monitor seriale possiamo osservare il gono catturati da NiFi, come mostrato in Figura 5.
processo di connessione, acquisizione e pubblicazione
dei messaggi di temperatura e umidità, come mostrato in ELABORAZIONE IN STREAMING
Figura 2. Nel sito https://github.com/Gersaibot/mosquit- Il notebook sviluppato con Scala si trova nella cartella no-
to-kafka-integration è possibile avere informazioni su di- tebooks in formato JSON e può essere importato in Zep-
stribuzione, configurazione, sottoscrizione e pubblicazio- pelin.
ne su Mosquitto e Kafka e sull'integrazione tra questi due Le tabelle create e utilizzate sono le seguenti:
servizi. Iscrivendosi al topic Mosquitto è possibile vedere
in tempo reale come vengono pubblicati i messaggi dalla mqtt_message_temp: tabella temporanea che memoriz-
piattaforma Arduino-ESP8266. Nella cartella dei modelli zerà i messaggi ottenuti in una finestra;
si trova il modello NiFi utilizzato per acquisire i dati di Mo-
squitto e inviarli sia a Kafka che a Hive. Va notato che è kafka_message: tabella che conterrà tutti i dati ottenuti da
necessario modificare i parametri di connessione in cia- ciascuna delle finestre di query eseguite;
scuno di questi servizi, ossia, indirizzi, argomenti, nomi
di tabelle. In Figura 3 è riportato un esempio di messaggi mean_fahrenheit_temp: tabella temporanea che memo-
IoT su Mosquitto. I messaggi acquisiti vengono pubblica- rizzerà le medie calcolate delle temperature in °F ottenute
ti esattamente allo stesso modo su Kafka e Hive in cui in una finestra;
vengono registrati campi aggiuntivi nella tabella, relativi
al server MQTT da cui vengono catturate le informazioni. kafka_means_fahrenheit: tabella che conterrà tutte le me-
Una volta avviato il template, se ci si iscrive all'argomento die calcolate di ciascuna delle finestre di query eseguite;
Kafka a cui si reindirizzano i messaggi, è possibile vedere
come vengono pubblicati i messaggi praticamente nell'i- gen_test_data: tabella contenente dati generati casual-
stante in cui vengono ricevuti in Mosquitto. Nell'immagine mente per testare il modello di classificazione Kmeans;
di Figura 4 si può vedere la ricezione di messaggi sull'ar-
gomento Mosquitto (a sinistra) e sull'argomento Kafka (a I dati possono essere trovati nella cartella “data / test_
Firmware 2.0 - 25
Figura 3: Dashboard Mosquitto con messaggi IoT
Figura 4: Ricezione di messaggi su Mosquitto e Kafka
data”. I dati sono stati generati secondo le seguenti spe- paragrafi.

cifiche: Definizione dell’intervallo di secondi per StreamingCon-
text (batchIntervalSeconds).
id: intero autoincrementale (unità) dal valore 1 Definizione della durata delle finestre di interrogazione
data: Stringa in aaaa-MM-gg (windowIntervalSeconds).
timestamp: stringa di timestamp in formato Unix da Definizione dei parametri di configurazione per la connes-
1478965467 a 1541592359 sione con Kafka sotto la sua vecchia API (kafkaConf).
fahrenheit: stringa numerica casuale tra 15 e 125
umidità: Stringa numerica casuale tra 25 e 85 Raccolta dati
Verifiche su contesti creati e/o creazione di nuovi contesti.
Il notebook contiene i seguenti paragrafi: Instaurazione del collegamento con Kafka.
Esecuzione della finestra di interrogazione di Kafka.
Setup Calcolo della media delle temperature in °F ricevute nella
Importazione di pacchetti e librerie utilizzati nel resto dei finestra.
26 - Firmware 2.0
Figura 5: Messaggi catturati da NiFi
Associazione delle medie Tracciamento dei dati

Associazione delle medie timestamp alle medie notebo- Visualizzazione dell'evoluzione dell'umidità e della tempe-
ok di prova unificando il calcolo delle medie nello stesso ratura in °C e in °F nel tempo sui dati storici delle finestre.
paragrafo.
Associazione della media calcolata con il timestamp di ge- CONCLUSIONI
nerazione dei dati. Con questo articolo si conclude il progetto del processo
di streaming della temperatura e umidità realizzato con le
Creazione e training del modello Kmedias tecnologie dell’ecosistema Big Data.
Trasformazione dei dati storici della finestra come input All'interno dell'architettura descritta in questo progetto, i
al modello. servizi di pubblicazione, trasferimento e archiviazione dei
Addestramento del modello KMean basato su temperatu- dati sono indipendenti dal formato in cui i dati vengono
ra in °F e umidità. inviati dalla piattaforma Arduino-ESP8266.
Archiviazione del modello in HDFS. Questa caratteristica conduce all'idea di costruire un ser-
Calcolo della somma dei quadrati all'interno di ciascun vizio di distribuzione di messaggi centralizzato, prove-
cluster. niente da diversi dispositivi verso client o servizi in grado
di utilizzare questi dati.
Classificazione Premesso ciò, le possibilità di applicabilità di questa ar-
Caricamento del modello precedentemente addestrato e chitettura sono direttamente proporzionali alla creatività di
archiviato in HDFS. implementare dispositivi generatori di informazioni.
Classificazione dei punti ottenuti nell'ultima finestra con-
sultata.
Visualizzazione dei risultati.
Classificazione - Dati casuali

Caricamento del modello precedentemente addestrato e
archiviato in HDFS. direttamente all’articolo sul Blog e partecipare alla discussione:
Classificazione di punti generati casualmente in intervalli https://it.emcelettronica.com/streaming-di-temperatura-e-
specifici. umidita-con-lecosistema-big-data-parte-2
Visualizzazione dei risultati.
Firmware 2.0 - 27
ARDUINO UNO MINI
LIMITED EDITION:
L’EVOLUZIONE
MINIATURIZZATA DELLA
STORICA SCHEDA A
MICROCONTROLLORE di Giordana Francesca Brescia
La scheda di sviluppo preferita dalle community di makers, dai progettisti e dagli hobbisti di tutto il mondo,
è diventata di formato mini. Arduino UNO Mini Limited Edition è un piccolo gioiello dell'elettronica, ideato
per celebrare la grande community Arduino e i tantissimi progetti innovativi che sono stati realizzati in tutti
questi anni.
UNA LIMITED EDITION PER COLLEZIONISTI, creato a partire dal lontano 2005. La scheda UNO Mini LE
MAKERS E PROGETTISTI funziona allo stesso modo della classica Arduino UNO, ne
P
er tutti i progettisti elettronici, gli hobbisti, condivide le caratteristiche, le prestazioni e la potenza di
i makers e gli appassionati della storica scheda elaborazione. Ciò significa che può essere utilizzata mol-
blu a microcontrollore, la scheda Arduino UNO to facilmente in qualsiasi progetto realizzato con Arduino
Mini Limited Edition è un vero e proprio oggetto da colle- UNO. L'hardware è completamente open source.
zione, un must have che non può assolutamente mancare Il principale target dei settori applicativi per i quali la
nel proprio laboratorio. Il team dei fondatori di Arduino era
da tempo concentrato su un nuovo prodotto che potes-
se suggellare il successo pluridecennale del dispositivo
elettronico più apprezzato nel mondo makers. Arduino
UNO Mini LE nasce proprio da questo intento. Con oltre
10 milioni di schede Arduino utilizzate in tutto il mondo per
realizzare i progetti elettronici più innovativi, Arduino UNO
è stata la scelta preferita da makers, ingegneri elettronici
e appassionati di Do-It-Yourself, per più di quindici anni.
Milioni di progetti realizzati con Arduino UNO hanno
contribuito a scrivere la più bella pagina della storia dell'e-
lettronica dell'ultimo ventennio. La pietra miliare della cre-
atività nei progetti elettronici diventa ora mini ed ha un
aspetto decisamente cool. Questa edizione limitata cele-
bra la board elettronica più iconica del mondo makers Figura 1: La scheda Arduino UNO Mini Limited Edition
e tutti i fantastici progetti che la community Arduino ha (Fonte: TME Electronic Components)
28 - Firmware 2.0
ARDUINO UNO MINI LIMITED EDITION: L’EVOLUZIONE MINIATURIZZATA
DELLA STORICA SCHEDA A MICROCONTROLLORE
Tabella 1: Specifiche tecniche dei processori ATMega328P e ATMega16U2
scheda è pensata è sicuramente l'hobby-making, oltre al prendimento delle basi dell'elettronica e della program-
design elettronico, l'automazione industriale, i PLC e la mazione. Arduino UNO Mini LE è infatti rivolta anche a
robotica, ma anche i progetti scientifici e didattici per l'ap- studenti che, attraverso lo studio delle discipline STEM,
acquisiscono competenze digitali innovative. Tutto ciò at-
tribuisce ad Arduino UNO Mini LE versatilità e poliedricità.
Questa scheda dal design unico e irripetibile non solo è
dotata di performance elevate, ma è caratterizzata an-
che da un tocco di eleganza che non passa inosservato:
colori nero e oro, finiture ricercate, design e packaging
di qualità, il tutto realizzato secondo i più alti standard
di livello industriale. Ogni pezzo è unico e numerato sul
PCB e include una stampa con una scritta firmata a mano
dai fondatori. Trattandosi di un'edizione limitata, è con-
sigliabile acquistarla finché è disponibile, prima che
le scorte a magazzino siano irrimediabilmente termi-
nate. L'innovativa scheda di sviluppo Arduino UNO Mini
Limited Edition è disponibile a catalogo sul sito web
Figura 2: Retro di Arduino UNO Mini LE della TME Electronic Components: ARDUINO UNO
Firmware 2.0 - 29
Tabella 2: Specifiche tecniche della scheda Arduino UNO Mini Limited Edition
MINI LE ARDUINO - Arduino | 5VDC; ATMEGA16U2,AT- re ATMega16U2.

MEGA328P; ADC,GPIO,I2C,PWM,SPI,UART; ABX00062 La scheda di sviluppo copre un range di temperature ope-
| TME - Componenti elettronici rative comprese tra -40 °C e 85 °Ce dispone di 14 ingres-
si/uscite digitali, sei delle quali possono essere utilizzate
SPECIFICHE TECNICHE DI LIVELLO come uscite PWM, sei ingressi analogici, un connettore
INDUSTRIALE USB-C e un pulsante di ripristino. La tensione di alimen-
Arduino UNO Mini LE, proprio come la sua sorella mag- tazione è 5VDC. La board contiene tutto il necessario per
giore, è basata sul chip ATMega328P, il noto microcon- supportare il microcontrollore. Per cominciare a realizzare
trollore della famiglia AVR caratterizzato da alte presta- i nostri progetti creativi è sufficiente collegare la scheda a
zioni ed al contempo consumi ridotti, ideale quindi per la un computer con il cavo USB-C, utilizzare un adattatore di
vasta gamma di applicazioni low power. Il microcontrollore alimentazione o collegare una batteria.
ATMega328P dispone di 2 kB di SRAM, 32 kB di FLA- Una delle features che sicuramente balza subito all'oc-
SH e anche di 1 kB di memoria EEPROM, che non viene chio è il fattore di forma estremamente ridotto. L'UNO
cancellata allo spegnimento della scheda. Oltre all'ATMe- Mini Limited Edition è un quarto delle dimensioni dell'in-
ga328P, la scheda è equipaggiata anche con il processo- gombro della versione originale UNO e misura solo 34,2
30 - Firmware 2.0
Figura 3: Dimensioni di Arduino UNO Mini LE
l'alimentazione della scheda, e pin disponibili

per il collegamento di fonti esterne di alimen-
tazione. Un aggiornamento che sicuramen-
te molti di noi apprezzeranno, considerando
anche che abbiamo un pò tutti a disposizione
diversi cavi USB-C di riserva. Come la sche-
da UNO, viene fornita con il set standard di
connettori pin femmina, un LED integrato,
il pulsante di ripristino (pulsante di reset) e
tutto ciò che caratterizza lo standard dell'ar-
chitettura di Arduino UNO, mantenendo inal-
terate la maggior parte delle funzionalità e
delle specifiche tecniche (processore, pinout,
prestazioni, etc.) eccezion fatta per qualche
piccolo upgrade migliorativo.
“Arduino UNO Mini Limited Edition (LE) è

a tutti gli effetti una versione in miniatura
Figura 4: L'elegante confezione della scheda Arduino UNO Mini Limited
della famosissima scheda Arduino UNO
Edition
Anche il passo tra i pin header è ridotto, ap-

mm x 26,7 mm x 8 mm. Le dimensioni della scheda sono pena 0,05" (1,27 mm), la metà della distanza rispetto al
notevolmente compatte, l'area di Arduino UNO Mini LE classico UNO di dimensioni regolari (0,1", che equivalgo-
è infatti equivalente al 25% della dimensione dell'area no a 2,54 mm).
della classica scheda Arduino UNO R3, ma la scheda è La scheda può essere programmata con diversi strumenti
anche altrettanto performante. software, sia online che offline: l'ambiente di sviluppo Ar-
La board è inserita in una elegante custodia e in dotazio- duino IDE da installare sul nostro computer se preferiamo
ne viene fornito anche un connettore USB-C che sosti- programmare offline, oppure Arduino CLI e Web Editor, ed
tuisce il precedente USB, utile per la programmazione e è supportata dalla piattaforma Arduino IoT Cloud. Anche
Firmware 2.0 - 31
Figura 5: Diagramma pinout di Arduino UNO Mini Limited Edition
Arduino UNO Mini LE, infatti, è un dispositivo abilitato per esempi di sketch e molto altro. In questa guida introdut-
l'IoT, per cui possiamo analizzare i dati acquisiti dai senso- tiva sono disponibili tutte le istruzioni e le informazioni
ri, avviare e programmare gli eventi o automatizzare attivi- tecniche necessarie per configurare la scheda, utilizzare il
tà tramite la dashboard di IoT Cloud. Trattandosi, come da software Arduino IDE e iniziare a prendere confidenza con
tradizione storica, di hardware e software completamente la codifica e l'elettronica di Arduino: UNO Mini Limited Edi-
open source, Arduino mette a disposizione risorse online, tion | Arduino Documentation | Arduino Documentation.
documentazione tecnica, datasheet, disegno del PCB, Una serie di semplici sketch di esempio sono reperibili nel
schemi elettrici di collegamento, librerie, sorgenti, modelli menu "Examples" dell'ambiente di sviluppo Arduino IDE o
3D, diagrammi pinout, file Fritzing, file CAD, downloads, nella Documentazione del sito web Arduino Pro.
32 - Firmware 2.0
CONCLUSIONI Open Source potrai condividere i tuoi primi progetti

L'iconico brand Arduino torna a stupirci con una nuova con la scheda Arduino UNO Mini LE, le tue idee sul
scheda dal design elegante e unico, ma allo stesso tempo dispositivo e le tue impressioni.
fedele al design della versione originale, icona intramon-
tabile e indiscussa del mondo makers. La scheda è acqui-
stabile sul catalogo della TME Electronic Components ad
un prezzo estremamente economico: una singola scheda
è acquistabile a soli 32.50 €. La crisi nella catena di for-
nitura dei chip in tutto il mondo sta mettendo a dura pro-
va l'approvvigionamento e la distribuzione dei dispositivi
elettronici, non riuscendo a coprire la domanda globale.
Inoltre, poiché questa scheda è in edizione limitata, non ci
sono tantissimi esemplari disponibili sul mercato, per cui
è consigliabile affrettarsi nelle ordinazioni per poter garan-
tirsi di avere tra le mani questo prezioso pezzo della storia
dell'elettronica makers. Sta a noi esplorare le infinite pos- approfondimenti sul tema dell’Articolo. Di seguito il link per accedere
sibilità applicative di questo piccolo gioiello in miniatura, direttamente all’articolo sul Blog e partecipare alla discussione:
sia sulla base della nostra esperienza in campo elettroni- https://it.emcelettronica.com/arduino-uno-mini-limited-
co sia con un pizzico di sana creatività e immaginazione. edition-levoluzione-miniaturizzata-della-storica-scheda-a-
Inoltre, last but not least, ricorda che su Elettronica microcontrollore
Firmware 2.0 - 33
CHE COS’È IL
TRANSFER LEARNING
E COME UTILIZZARLO di Andrea Garrapa
I modelli di reti neurali profonde (Deep Neural Network) possono richiedere giorni o addirittura settimane
per l'addestramento su un set di dati di grandi dimensioni. Per non parlare delle difficoltà nell'avere un set
di dati etichettati e di grandi dimensioni. Un modo per abbreviare questo processo consiste nel riutilizzare i
pesi di un modello pre-addestrato. I modelli più performanti possono essere scaricati e utilizzati direttamen-
te o integrati in un nuovo modello per cercare di risolvere i propri problemi di classificazione. Tale approccio
prende il nome di Transfer Learning è sarà l'oggetto di discussione di questo articolo. Dopo un'introduzione
generale all'argomento, affronteremo un esempio pratico nell'ambito dello sviluppo di reti neurali per appli-
cazioni di visione artificiale.
INTRODUZIONE zazione (overfitting).
T
ransfer Learning è un concetto che si può tra-
durre come apprendere un determinato compito BENEFICI DEL TRANSFER LEARNING
partendo da una conoscenza pregressa. Questa Problemi molto specifici richiedono un volume elevato
conoscenza precedente viene trasferita dall'attività di ori- di dati per essere affrontati con successo. Trovare i dati
gine alla nuova. Avviene cioè un riuso di ciò che è stato per l'addestramento non è facile. Inoltre, anche avendo
appreso in un contesto per migliorare la generalizzazione dei dati in numero elevato non è così semplice né rapi-
in un altro contesto. Il Transfer Learning ha il vantaggio di do mettere a punto un modello performante. La Figura 1
ridurre il tempo di addestramento per un modello di rete descrive un tipico sistema di apprendimento automati-
neurale e può comportare un minore errore di generaliz- co. Per una particolare attività in un determinato dominio,
Figura 1: Con un approccio Machine Learning per risolvere i compiti A e B è necessario sviluppare due modelli partendo da zero
34 - Firmware 2.0
CHE COS’È IL TRANSFER LEARNING E COME UTILIZZARLO
Figura 2: Nel Transfer Learning la conoscenza "generale" acquisita dall'attività A viene applicata all'attività B simile, rispar-
miando tempi e costi nello sviluppo e addestramento del modello
il modello di apprendimento automatico è in grado di im- problema non risolvibile con i pochi dati a disposizione o
parare e generalizzare bene. Tuttavia, se c'è una nuova semplicemente per cercare di ottenere prestazioni miglio-
attività, deve costruire un modello completamente nuovo, ri. La Figura 2 illustra un esempio di Transfer Learning.
per poter generalizzare per quell'attività.
Fortunatamente, la community di Intelligenza Artificiale è QUANDO USARE IL TRANSFER LEARNING
così grande e ci sono così tanti lavori messi a disposi- Prima di tutto, per utilizzare il Transfer Learning, le featu-
zione al pubblico, tra set di dati e modelli pre-addestrati, res dei dati devono essere generali, nel senso che devono
che rende non conveniente costruire tutto da zero. Detto essere adatte sia all'attività di origine che a quella di desti-
questo, i due motivi principali per cui dovremmo usare il nazione. Se le caratteristiche non sono comuni a entrambi
Transfer Learning sono: i problemi, il trasferimento diventa, se possibile, molto più
1. L'addestramento di alcuni modelli di apprendi- complesso. In secondo luogo, il Transfer Learning ha
mento automatico, in particolare le reti neurali ar- senso solo quando abbiamo molti dati per l'attività di
tificiali che funzionano con immagini o testo, può origine e pochissimi dati per l'attività di destinazione.
richiedere molto tempo ed essere molto costoso Terzo ed ultimo, le features di basso livello dell'attività d'o-
dal punto di vista computazionale. Il Transfer Le- rigine devono essere utili per l'apprendimento dell'attività
arning può alleggerire questo carico dandoci una di destinazione. Se si provasse ad imparare a classificare
rete già addestrata e che necessita solo di una fine le immagini di animali utilizzando l'apprendimento tramite
regolazione. trasferimento da un set di dati di nuvole, i risultati potreb-
2. I set di dati per determinate attività sono molto co- bero non essere eccezionali.
stosi da ottenere. Il Transfer Learning ci consente In breve, se si dispone di un'attività di origine A e di un'at-
di ottenere ottimi risultati in queste attività partico- tività di destinazione B si può prendere in considerazione
lari con un set di dati molto più piccolo rispetto a l'utilizzo del Transfer Learning quando:
quello di cui avremmo bisogno se affrontassimo il 1. Le attività A e B hanno lo stesso input x
problema senza di esso. 2. I dati per l'attività A sono molti di più di quelli per
l'attività B
Il Transfer Learning è in sostanza una scorciatoia 3. Le features di basso livello dell'attività A sono utili
per risparmiare tempo sull'addestramento, e risolvere un per l'apprendimento dell'attività B
Firmware 2.0 - 35
COME USARE IL TRANSFER LEARNING destrato:

Ci sono molti modelli pre-addestrati disponibili online, • Classificatore - il modello pre-addestrato viene
quindi c'è un'alta probabilità che ce ne sia uno adatto al utilizzato direttamente per classificare nuove im-
problema specifico che si vuole risolvere. Una volta tro- magini;
vato il modello adatto, sarà comunque necessaria una • Estrattore di features autonomo - il modello
seconda fase di addestramento con i dati per il problema pre-addestrato, o una parte di esso, viene utiliz-
specifico in modo da adattare il modello di origine al par- zato per pre-elaborare le immagini ed estrarre le
ticolare compito da eseguire. La successione delle ope- features pertinenti;
razioni per applicare il Transfer Learning nel contesto del • Estrattore di features integrato - il modello
Deep Learning si può riassumere con i seguenti passi: pre-addestrato, o una parte di esso, è integrato in
1. Prendere i livelli (layer) dal modello d'origine ad- un nuovo modello, ma i livelli del modello pre-ad-
destrato destrato vengono congelati durante l'addestra-
2. Congelare i livelli, in modo da evitare di distrugge- mento;
re le informazioni che contengono durante le futu- • Inizializzazione dei pesi - il modello pre-addestra-
re fasi di addestramento to, o una parte di esso, viene integrato in un nuovo
3. Aggiungere alcuni nuovi strati addestrabili sopra modello e gli strati del modello pre-addestrato ven-
gli strati congelati gono addestrati insieme al nuovo modello.
4. Addestrare i nuovi strati con il set di dati per lo
specifico problema Ogni approccio può essere efficace e far risparmiare tem-
po significativo nello sviluppo e nell'addestramento di un
Un ultimo passaggio facoltativo è il fine tuning, che con- modello di rete neurale profonda. Potrebbe non essere
siste nello sbloccare l'intero modello ottenuto (o parte di chiaro quale utilizzo del modello pre-addestrato possa
esso) e ri-addestrarlo sui nuovi dati con un tasso di ap- produrre i migliori risultati nella nuova attività di visione
prendimento molto basso. Ciò può potenzialmente far artificiale, pertanto potrebbero essere necessari alcuni
ottenere miglioramenti significativi, adattando in modo in- esperimenti.
crementale le features pre-addestrate ai nuovi dati.
MODELLO
ESEMPIO Keras è un'API di Deep Learning scritta in Python,
Un'ampia gamma di modelli ad alte prestazioni è stata in esecuzione sulla piattaforma di Machine Learning
sviluppata negli anni per la classificazione delle immagini. TensorFlow. È stata sviluppata con l'obiettivo di consenti-
Questi modelli possono essere utilizzati come base nelle re una rapida sperimentazione. Keras fornisce l'accesso a
applicazioni di visione artificiale. In particolare, i modelli una serie di modelli pre-addestrati ad alte prestazioni che
sviluppati per la sfida annuale denominata ImageNet, ri- sono stati sviluppati per attività di riconoscimento delle
sultano molto attraenti poiché: immagini. Tali modelli sono disponibili tramite l'API appli-
• hanno imparato a rilevare caratteristiche generi- cations e includono funzioni per caricare un modello con o
che dalle immagini, essendo stati addestrati su più senza i pesi pre-addestrati e preparare i dati nel modo in
di 1.000.000 di immagini per 1.000 classi; cui un dato modello li accetta in input (ridimensionamento
• presentano prestazioni all'avanguardia e facilità delle dimensioni e dei valori dei pixel). Per il nostro esem-
d'accesso, essendo i pesi dei modelli forniti come pio andremo ad usare il modello Xception, pre-addestrato
file scaricabili gratuitamente e molte librerie forni- sul set di immagini ImageNet. Xception è una rete neura-
scono API convenienti per scaricare e utilizzare le convoluzionale profonda con 71 strati. La rete è stata
direttamente i modelli. addestrata su più di un milione di immagini dal database
ImageNet. La rete pre-addestrata può classificare le im-
I pesi del modello d'origine possono essere scaricati e uti- magini in 1000 categorie (classi) di oggetti, come tastiera,
lizzati nella stessa architettura del modello di destinazione mouse, matita e molti animali. Di conseguenza, la rete ha
utilizzando una gamma di diverse librerie per il Deep Le- appreso rappresentazioni ricche di features per un'ampia
arning, inclusa Keras. Un modello può essere scaricato e gamma di immagini.
utilizzato così com'è o per altri scopi. Possiamo riassume- Il nostro codice in Python come al solito inizia con l'impor-
re alcune delle modalità di utilizzo di un modello pre-ad- tazione dei moduli e delle API da utilizzare:
36 - Firmware 2.0
e 1. Lo faremo utilizzando un livello di normalizzazione

come parte del modello stesso.
import tensorflow as tf
import tensorflow_datasets as tfds
from tensorflow import keras size = (150, 150)
from tensorflow.keras import layers train_ds = train_ds.map(lambda x, y: (tf.image.resize(x,
import matplotlib.pyplot as plt size), y))
import numpy as np validation_ds = validation_ds.map(lambda x, y: (tf.ima-

ge.resize(x, size), y))
test_ds = test_ds.map(lambda x, y: (tf.image.resize(x,
Si passa quindi a scaricare il dataset che verrà utilizzato
size), y))
per la nuova applicazione:
train_ds, validation_ds, test_ds = tfds.load( batch_size = 32

"cats_vs_dogs", train_ds = train_ds.cache().batch(batch_size).pre-
# Riserva il 10% per la validazione e il 10% per il test fetch(buffer_size=10)
split=["train[:40%]", "train[40%:50%]", validation_ds = validation_ds.cache().batch(batch_size).
"train[50%:60%]"], prefetch(buffer_size=10)
as_supervised=True, # Includi le etichette delle classi test_ds = test_ds.cache().batch(batch_size).pre-
) fetch(buffer_size=10)
Per prima cosa, recuperiamo il set di dati "cats vs dogs" Nel primo pezzo di codice rendiamo standard (150x1510)
utilizzando TFDS. Per mantenere il nostro set di dati pic- le dimensioni delle immagini di addestramento, validazio-
colo, utilizzeremo solo il 40% dei dati di addestramento ne e test. Il ridimensionamento avviene tramite (tf.image.
originali per l'addestramento, il 10% per la convalida e il resize(x, size), y ), mentre map e lambda servono per ite-
10% per i test. rare su ogni immagine del set (un artificio Python per fare
Visualizziamo nove immagini del dataset di addestra- le cose con una sola linea di codice). Nel secondo pezzo,
mento (train_ds): definiamo la dimensione del batch (cioè il lotto di immagini
che verranno inviate in ingresso) e utilizziamo il caching
plt.figure(figsize=(10, 10)) (cache) e il pre-caricamento (prefetch) per ottimizzare la
for i, (image, label) in enumerate(train_ds.take(9)): velocità di caricamento. Quando non si dispone di un set
di dati di immagini di grandi dimensioni, è buona norma
ax = plt.subplot(3, 3, i + 1)
introdurre artificialmente della diversità nel campio-
plt.imshow(image)
ne.
plt.title(int(label))
plt.axis("off")
data_augmentation = keras.Sequential(
Osservando la Figura 3, queste prime 9 immagini nel set [

di addestramento sono tutte di dimensioni diverse. layers.experimental.preprocessing.RandomFli-
Possiamo anche vedere che l'etichetta (numero) presente p("horizontal"),
al di sopra di ogni immagine si riferisce ad 1 per la classe layers.experimental.preprocessing.RandomRota-
"cane" e 0 per la classe "gatto". Le immagini nel dataset tion(0.1),
presentano dimensioni variabili. Inoltre, ogni pixel è com-
]
posto da 3 valori interi (RGB) compresi tra 0 e 255. Oc-
)
corre che tutte le immagini abbiano una dimensione
standard, ad esempio 150x150 pixel. Ed inoltre i valori
dei pixel devono essere normalizzati nell'intervallo -1 Applicando trasformazioni casuali ma realistiche alle im-
Firmware 2.0 - 37
Figura 3: 9 immagini tratte dal set di addestramento. Su ogni immagine è presente l'etichetta 1 nel caso di un cane, 0 nel
caso di un gatto
magini di addestramento, come il capovolgimento oriz-

zontale o piccole rotazioni casuali, consente di esporre
il modello a diversi aspetti dei dati di addestramento ridu- base_model = keras.applications.Xception(
cendo anche l'overfitting. Ora, possiamo passare alla cre- weights="imagenet", # Carica i pesi pre-addestrati
azione del modello. Occorre notare che rispetto a quanto
su ImageNet.
descritto nel paragrafo "Come usare il Transfer Learning",
stiamo aggiungendo un livello di normalizzazione per sca- input_shape=(150, 150, 3),
lare i valori di input (inizialmente nell'intervallo [0, 255]) include_top=False,
nell'intervallo [-1, 1]. Inoltre, l'introduzione di un livello di
) # Non includere il classificatore finale ImageNet.
Dropout prima del livello di classificazione, permetterà di
combattere meglio l'overfitting.
38 - Firmware 2.0
Figura 4: Riassunto degli strati del modello. Notare che il numero di parametri addestrabili è inferiore al totale
x = base_model(x, training=False) #Inseriamo il model-

# Congela il modello di base in modo che non sia adde-
lo di base
strabile x = keras.layers.GlobalAveragePooling2D()(x) #Applica
base_model.trainable = False il pooling per ridurre dimensioni
x = keras.layers.Dropout(0.2)(x) # Applica regolarizza-
zione
# Crea nuovo modello alla fine del modello base outputs = keras.layers.Dense(1)(x) #Lo strato di uscita
inputs = keras.Input(shape=(150, 150, 3)) model = keras.Model(inputs, outputs)
x = data_augmentation(inputs) # Applica aumento dei model.summary()
dati L'immagine in Figura 4 riporta il riassunto degli strati del
# Lo strato di normalizzazione fornisce in uscita modello e il numero dei parametri.
# outputs = (inputs - mean) / sqrt(var) Ora non resta che addestrare il layer finale che abbiamo
norm_layer = keras.layers.experimental.preprocessing. introdotto nel modello:
Normalization()
mean = np.array([127.5] * 3) model.compile(
var = mean ** 2 optimizer=keras.optimizers.Adam(),
# Scala l'ingresso tra [-1, +1] loss=keras.losses.BinaryCrossentropy(from_logit-
x = norm_layer(x) s=True),
norm_layer.set_weights([mean, var]) metrics=[keras.metrics.BinaryAccuracy()],
)
Firmware 2.0 - 39
Tabella 1: Parametri di performance del modello per i dati di addestramento e validazione
modello che riesce a classificare con il 96% di accuratez-

za tra due tipologie di animali ritratti in foto, ottenuto con
uno sforzo minimo in termini di tempo, costi computazio-
epochs = 1
nali e progettazione.
model.fit(train_ds, epochs=epochs, validation_data=va-
CONCLUSIONE
lidation_ds)
In questo articolo abbiamo affrontato la possibilità di utiliz-
zare il Transfer Learning per accelerare l'addestramento e
migliorare le prestazioni di un modello di Deep Learning.
Con compile() configuriamo i parametri utilizzati nell'adde- Oltre ad una panoramica generale sul Transfer Learning,
stramento, mentre con fit() diamo inizio all'addestramento. abbiamo anche delineato le motivazioni che possono
Dopo una sola epoca di addestramento otteniamo i para- spingere a preferire questo tipo di approccio rispetto al
metri di performance riportati nella Tabella 1. tradizionale Machine Learning.
La rete sembra comportarsi bene. Infatti, non solo non è Utilizzando l'API Keras è stato presentato un esempio di
affetta da overfitting, ma l'accuratezza della previsione su implementazione della tecnica rispetto ad un problema di
dati mai visti (validazione) è superiore a quella sui dati di visione artificiale.
addestramento. Il 97% è inoltre un ottimo valore di accu-
ratezza.
RIFERIMENTI
L'ultimo passo è quello di testare il modello sui dati di
test: "A Gentle Introduction to Transfer Learning for Deep Le-
arning"
"A Comprehensive Hands-on Guide to Transfer Learning

model.evaluate(test_ds)
with Real-World Applications in Deep Learning"
"Transfer Learning & fine-tuning"
Sui dati di test il modello fornisce una misura della perdita

di 0.085 ed un'accuratezza di 0.9638.

Anche se le prestazioni del modello sui dati di test sono
leggermente inferiori rispetto a quelle per i dati di valida- direttamente all’articolo sul Blog e partecipare alla discussione:
zione, il risultato ottenuto è soddisfacente. https://it.emcelettronica.com/che-cose-il-transfer-
learning-e-come-utilizzarlo
In particolare, risulta evidente il vantaggio di creare un
40 - Firmware 2.0
INTELLIGENZA
ARTIFICIALE CON
ARDUINO di Daniele Valanzuolo
L'attività di apprendimento automatico all'interno del campo della robotica è la tematica che maggiormen-
te stimola la ricerca al fine di ottenere “circuiti” in grado di replicare il comportamento umano. Le difficoltà
sono innumerevoli, tra cui sicuramente la potenza di calcolo richiesta che deve essere notevole al fine di po-
ter gestire contemporaneamente sia l’acquisizione da diversi sensori che l’elaborazione delle informazioni,
con la produzione di un risultato finale (output) elaborato in autonomia dall’Intelligenza Artificiale. In que-
sto articolo affronteremo la tematica calata all'interno dell'ecosistema Arduino, valutando i progressi degli
ultimi anni ed i limiti di questa tecnologia a basso costo.
INTRODUZIONE di estrazione delle informazioni a partire dai dati acqui-
T
utti ormai ci siamo cimentati almeno una volta nel siti. Elemento fondamentale dell’apprendimento diviene
realizzare uno sketch o un progetto più complesso l’esperienza nel produrre risultati validi. La definizione
hardware/firmware con il mondo Arduino. Nono- contemporanea di Machine Learning (apprendimento del-
stante negli ultimi anni siano state rilasciate versioni più le macchine) è stata fornita da Tom M. Mitchell:
performanti con processori Arm, le schede Arduino sono
conosciute per le loro limitate potenze di calcolo. Questo “Machine Learning is the study of computer algorithms
forte limite in realtà consente di avere a disposizione del- that allow computer programs to automatically
le schede di sviluppo dal costo contenuto ed accessibile improve through experience.
a chiunque voglia cimentarsi nel mondo dei Makers, ma
di conseguenza limita le possibili applicazioni. Di fatto, la L’apprendimento automatico prevede diverse tipologie
maggior parte dei progetti sono relativi ad applicazioni di di tecniche e/o algoritmi, classificabili nelle seguenti ma-
IoT o capaci di automatizzare funzioni molto semplici quali cro-categorie:
acquisizione dati, visualizzazione informazioni su display • tecniche di apprendimento supervisionato: ven-
e trasferimento attraverso interfacce di comunicazione wi- gono forniti degli esempi di connessione tra input
red o wireless. e output in modo da formare la macchina a preve-
dere nuovi output in futuro. In particolare, la mac-
IL MACHINE LEARNING china sarà in grado di definire una relazione tra
Nel mondo della robotica e dei processi industriali, da anni ingressi e uscite fornite e imparerà ad utilizzarla in
si parla del concetto di Intelligenza Artificiale, ossia l’evo- seguito per casi simili agli ingressi ottenuti;
luzione dell’elettronica che diviene abile nell'elaborazione • tecniche di apprendimento non-supervisiona-
di informazioni a prescindere da modelli o equazioni spe- to: la macchina deve individuare modelli nascosti
cifiche, come farebbe l’essere umano durante l'apprendi- all’interno dei dati di input già strutturati. L’assenza
mento sul campo. Dunque nell’ambiente dell’Intelligenza di output associati agli ingressi consente di trovare
Artificiale viene prestata attenzione in modo particolare ad modelli nascosti a partire dal set dei dati di ingres-
un sottoinsieme applicativo dell’AI che comprende le tec- so;
niche e gli algoritmi di Machine Learning. Le metodologie • tecniche di Deep Learning: il Deep Learning è de-
di Machine Learning, ossia di apprendimento automatico, finito come un sottoinsieme di tecniche di Machine
sono basate in linea di principio su metodi computazionali Learning (come rappresentato in Figura 1) basato
Firmware 2.0 - 41
INTELLIGENZA ARTIFICIALE CON ARDUINO
necessitano di un ridimensionamento e dell’introduzio-

ne di nuove tecniche adeguate alle limitate risorse quali
potenza e memoria a disposizione. Una delle principali
modifiche apportate dal team alla versione Lite è quella
dell’abolizione dei numeri in virgola mobile attraverso l’u-
tilizzo di interi a 8 bit.
E’ disponibile anche il progetto TensorFlow Lite che con-
sente l’estensione delle funzionalità di Machine Learning
e reti neurali a sistemi basati su microcontrollori. La diffe-
renza sostanziale tra le due librerie è che TensorFlow è
basata su reti neurali che richiedono comunque una
maggiore complessità di calcolo. Il Machine Learning
non è necessariamente reti neurali, e la libreria TinyML
Figura 1: Dall'Intelligenza Artificiale fino al Deep Learning fornisce una valida alternativa di tecniche di appren-
dimento applicabili anche a microcontrollori a 8 bit e con
una quantità di RAM esigua.
su reti neurali stratificate in grado di processare A partire da questi due progetti di Machine Learning e
elevate quantità di dati. le relative librerie, sono stati sviluppati all’interno della
Community Arduino diversi esempi applicativi sfruttando
In realtà, a partire da queste 3 macro-categorie esistono le capacità di una delle schede Arduino di ultima gene-
molte sotto-categorie che, sfruttando le peculiarità delle razione, ossia la scheda Arduino Nano 33 BLE Sense.
varie tecniche di apprendimento, realizzano ulteriori algo- Questa tipologia di scheda (dotata di un processore ARM
ritmi e tecniche che di fatto trovano la vera applicazione Cortex-M4) è stata scelta per la presenza anche di diversi
nei sistemi dotati di Machine Learning. Tra le tecniche più sensori interessanti (IMU, microfono, modulo BLE, sen-
conosciute ed adoperate troviamo gli alberi decisionali, sori ambientali) su una superficie dell’oggetto veramente
il clustering per la classificazione degli oggetti nei metodi ridotta. Gli esempi prodotti dalla combinazione delle libre-
non supervisionati, algoritmi basati su calcoli probabili- rie di Machine Learning e questa fantastica scheda sono:
stici, stratificazione dell’elaborazione (con l’utilizzo di reti • Riconoscimento vocale grazie all’utilizzo di un mi-
neurali) e tanto altro. crofono integrato sulla scheda
• Riconoscimento gestuale adoperando i dati acqui-
TINYML E TENSORFLOW APPLICATI AD siti dal modulo inerziale IMU
ARDUINO
Il progetto TinyML nasce con l’esigenza di sviluppare tec- MACHINE VISION APPLICATA AD ARDUINO
niche di apprendimento semplici da applicare a sistemi a La Machine Vision, detta anche visione artificiale, è un
basso consumo con l’obiettivo di supportare lo sviluppo di aspetto molto importante nel settore industriale in quanto
una varietà di oggetti adatti o adattabili a molteplici casi è possibile realizzare sistemi automatici per monitorare i
d'uso, garantendo una semplicità di utilizzo e una larga processi industriali ed ottenere maggiori livelli di qualità
diffusione del concetto di Machine Learning. In questa ed efficienza nella produzione. Le tecniche e le tecnologie
evoluzione, e grazie al trend Makers in atto da diversi utili alla realizzazione di sistemi di Machine Vision sono in-
anni, il team di Tiny si è prefissato di realizzare anche numerevoli e presentano molte peculiarità che dipendono
una versione compatibile con i microcontrollori meno dall’obiettivo prestazionale finale. Inoltre, la combinazio-
prestanti come quelli adoperati sulle board Arduino, e ne di queste informazioni con la possibilità di controllare
dunque oggetti che dispongono di una potenza di calcolo dei sistemi di attuazione (o veri e propri robot industriali)
ancora più limitata. L’idea di base è poter avere a dispo- consente di realizzare sistemi complessi molto avanzati.
sizione oggetti economici e piccoli in grado di poter L’introduzione delle tecniche di Machine Learning com-
eseguire operazioni di Machine Learning in maniera binate a dati forniti dall’acquisizione di immagini video,
localizzata. Ovviamente, la strada del successo è lunga fornisce una combinazione per ottenere sistemi dotati di
in quanto gli algoritmi di apprendimento automatico appli- Intelligenza Artificiale evoluta, che trovano larga applica-
cabili su piattaforme ad elevata potenza computazionale zione non solo nel settore industriale ma anche in quello
42 - Firmware 2.0
Figura 2: Modulo OV7670 accoppiato a ELEGOO UNO R3 Figura 3: Modulo camera OV7670
della sicurezza nazionale in luoghi sensibili (stadi durante • Gamma dinamica: 52 dB

eventi importanti, aeroporti, luoghi di culto, etc.). Come in-
trodotto precedentemente, le forti limitazioni prestazionali C’è da precisare che con questo modulo non stiamo par-
di Arduino non consentono la realizzazione di veri e propri lando di camere FULLHD o 4K e va sottolineato che il
progetti di Machine Vision, ma esiste comunque una so- sistema di focus è completamente meccanico. Nono-
luzione valida per dotare la nostra fidata scheda del dono stante queste forti limitazioni, il costo davvero irrisorio del
della vista (Figura 2). modulo (circa 5€) rende l’oggetto accessibile ed utile per
L’oggetto che voglio mostrarvi è il modulo OV7670 (vedi realizzare innumerevoli progetti dotandoli delle funziona-
Figura 3) distribuito da AZ delivery. Questo è un modulo lità di Machine Vision per elaborare semplici informazioni
di espansione a 18 pin dotato di sensore di immagine (ap- (presenza di movimento, luce, identificazione di oggetti
punto il sensore OV7670 prodotto dalla OmniVision Te- colorati o da particolari forme) o per il trasferimento delle
chnologies Inc.) che consente di acquisire immagini con immagini acquisite verso un’unità di elaborazione più po-
le seguenti risoluzioni: VGA (640x480) (valore di default), tente ed applicare algoritmi di image processing e Intelli-
QVGA (320x240), CIF (352x240) e QCIF (176x144). genza Artificiale evoluti.
L’interfacciamento con Arduino avviene attraverso un bus Il Pinout del modulo OV7670 è il seguente:
dati parallelo a 8 linee e secondo uno standard configu-
rabile quale: YCbCr422 (protocollo di default), RGB565,
RGB555 e RGB444. Le ulteriori caratteristiche del modulo
sono le seguenti:
• Risoluzione massima: 640 x 480
• Frequenza fotogrammi massima: 30 FPS
• Area pixel: area pixel 3,6 μm x 3,6 μm
• Intervallo di temperatura massimo: da -30 °C a 70 °C
• Uscita: YUV/YCbCr4: 2: 2 RGB565/555/444
GRB4: 2: 2 Raw RGB Data
• Rapporto segnale/rumore: 46 dB
• Corrente di buio: 12 mV/s a 60 °C
• Voltaggio: 2,5 - 3VDC
• Potenza: 60 mW @ 15 FPS
• Angolo di visione: 25 °
• Intervallo di temperatura consigliato: da 0 °C a 50 °C
• Dimensione ottica: 1/6 "
• Sensibilità 1,3 V/(Lux-sec)
Firmware 2.0 - 43
La coppia di pin SIOC e SIOD è utilizzata per interfacciare torni. A questo possono essere aggiunti algoritmi
il modulo con i pin della periferica I2C di Arduino in modo di identificazione delle forme
da poter configurare il device nella fase di startup. Il proto- • Scanner di QCODE o Codici a barre
collo utilizzato è SCCB (acronimo di Serial Camera Con- • Rilevamento del colore
trol Bus) sviluppato dalla OmniVision Technologies Inc. • Inseguimenti di oggetti combinando gli algoritmi
per l’interfacciamento con i propri dispositivi CameraChip. precedenti con un sistema di movimentazione
Il protocollo nasce come bus seriale a 3 fili e solo succes- • Rilevamento dei gesti
sivamente è stata introdotta la modalità di funzionamento
a 2 fili per l’interfacciamento di moduli con un numero di Questi esempi sono tutti molto semplici e richiedono ridot-
pin ridotto. ta complessità computazionale.
Attraverso il protocollo SCCB è possibile configurare Nei casi di Machine Vision più evoluta (individuazione e
molti parametri di acquisizione e image processing riconoscimento volti, algoritmi di image processing com-
del chip OV7670 tra i quali bilanciamento del bianco, sa- plessi, individuazione di veicoli in movimento, etc.) è pos-
turazione dei colori, esposizione e tanto altro. sibile immaginare di realizzare un sistema più complesso
Il sensore di imaging (fotografato in Figura 4) è dotato al realizzando l'acquisizione dati attraverso la combinazione
suo interno di blocchi funzionali capaci di svolgere tutte le Arduino+OV7670 e l'elaborazione delle immagini su una
funzionalità di controllo in autonomia e fornire i segnali di piattaforma più performante.
Video Timing (sincronismi verticale ed orizzontale, clock, Possibili soluzioni sono sia il pc, sia le schede Raspberry
strobe). Pi che, compatibili con Python, consentono l'utilizzo di li-
Il distributore AZ delivery fornisce un manuale dettagliato brerie di image processing già collaudate.
su come realizzare il collegamento tra il modulo e Ardu-
ino UNO e riporta anche i link a diversi sorgenti utilizza- CONCLUSIONI
bili per verificare velocemente il corretto collegamento e il In questo articolo è stato possibile osservare lo stato
funzionamento del modulo Camera. dell’arte di diversi progetti in corso che mirano ad ottenere
Il campo della Machine Vision è molto avvincente e ci funzionalità di Machine Learning o Machine Vision su
sono molte ricerche in termini di combinazioni tra Machi- schede a microcontrollore come Arduino e simili.
ne Vision e Deep Learning per realizzare robot in grado di Nonostante la limitata disponibilità di risorse computa-
apprendere ed interagire con il mondo visivo. zionali e di memoria, queste tipologie di schede risultano
Con le esigue risorse messe disponibili da Arduino e la molto interessanti per realizzare nodi economici di una
risoluzione/qualità di questo modulo non ci aspettiamo di sensor network, soprattutto grazie alla disponibilità di pro-
realizzare complessi progetti di Machine Vision o algoritmi dotti che già integrano una grande varietà di sensori ab-
di image processing, ma di seguito vi elenco un pò di idee binata a moduli di comunicazione wireless (come la sen-
che possono essere realizzate con questa combinazione: soristica e il modulo BLE disponibili a bordo della scheda
• Individuazione di oggetti a partire da algoritmi di Arduino Nano 33 BLE Sense).
image processing per la rilevazione dei bordi/con- Con l'utilizzo del modulo OmbiVision OV7670, invece, è
possibile dotare del dono della vista le schede Arduino
(anche le meno potenti Arduino UNO) avendo così la pos-
sibilità di realizzare piccoli progetti di Machine Vision.
E voi avete avuto modo di utilizzare queste schede Ardui-
no o la libreria del progetto TinyML?

https://it.emcelettronica.com/intelligenza-artificiale-con-
arduino
Figura 4: Modulo OV7670 con ottica smontata e pinout visibile
44 - Firmware 2.0
SFIDE E SOLUZIONI
PER LO SVILUPPO DI
APPLICAZIONI DI EDGE
MACHINE LEARNING di Andrea Garrapa
AI periferica, Embedded ML, Edge ML, TinyML sono tutti sinonimi dello stesso concetto: abilitare algoritmi di
Deep Learning su dispositivi embedded a bassissima potenza, aprendo la strada all'analisi e all'elaborazio-
ne periferica dei dati. In questo articolo, discutiamo le principali sfide e gli abilitatori tecnologici che dirigono
l'espansione di questo campo. TinyML aprirà le porte a nuovi tipi di servizi e applicazioni edge non più basati
su elaborazione cloud ma su inferenza periferica distribuita e autonomia decisionale.
INTRODUZIONE sviluppo di reti neurali profonde, che ha continuato a cre-
E
mersa negli ultimi anni come una nuova tecnolo- scere nel tempo in termini di complessità e risorse. Oggi il
gia all'intersezione tra apprendimento automati- cloud computing elabora i modelli AI più grandi con milioni
co, piattaforme embedded e software, TinyML si di parametri che richiedono gigabyte di memoria ed elabo-
concentra sulla distribuzione di modelli di Machine Lear- razione ultraveloce. Questi modelli di reti neurali di grandi
ning e di reti neurali profonde su dispositivi con risorse dimensioni si concentrano principalmente su precisione e
limitate (MCU), offrendo così soluzioni per applicazioni velocità, poiché hanno accesso a risorse di calcolo e me-
con vincoli di bassa latenza e limitata larghezza di ban- moria illimitate o quasi (Tabella 1).
da. Diversi framework, che forniscono software per creare L'emergere di dispositivi mobili come laptop, smartpho-
modelli TinyML e velocizzare la distribuzione dell'applica- ne e tablet, ha dato origine all'elaborazione su mobile.
zione, sono attualmente in fase di sviluppo. I framework Piattaforme di mobile computing hanno iniziato ad esse-
discussi in questo articolo (TensorFlow Lite, ELL, ARM- re utilizzate in molti campi che richiedono l'elaborazione
NN) si concentrano principalmente sulla distribuzione di in tempo reale, senza fare affidamento sulla potenza di
modelli di rete neurale su microcontrollori. Essi integrano calcolo fornita dalla tecnologia cloud (Tabella 1). Questo
tutti un flusso di lavoro simile, dove un modello di rete spostamento verso piattaforme mobili ha avviato lo svilup-
neurale viene prima convertito in un tipo di formato comu- po di una nuova generazione di reti neurali di dimensioni
ne e quindi ottimizzato internamente per la distribuzione più compatte e focalizzate sull'efficienza del modello, oltre
sulla specifica piattaforma hardware. Questi framework che sulla sua precisione. Parallelamente a questa espan-
vengono aggiornati regolarmente per supportare nuovi al- sione, anche il campo dell'IoT si è allargato, potenziato dai
goritmi di apprendimento automatico e nuove piattaforme progressi nella connettività e dall'abbondanza di soluzioni
hardware. disponibili. Oggi, il numero di dispositivi distribuiti basati
su microcontrollore cresce in modo esponenziale. Tutta-
DAL CLOUD ALL'EDGE via, in molti casi, i dispositivi embedded non elaborano i
Negli ultimi decenni, la produzione di dati è aumentata a dati raccolti, che vengono invece trasmessi a una posizio-
ritmi senza precedenti. Questa tendenza è stata suppor- ne remota per l'archiviazione e l'ulteriore elaborazione. In
tata anche dall'aumento delle capacità di elaborazione e alcune applicazioni, questo può causare problemi indesi-
archiviazione dei dati fornite dalle tecnologie cloud. L'au- derati di latenza, perdita e riservatezza dei dati.
mento delle risorse di calcolo ha accelerato la ricerca e lo I dispositivi embedded di solito raccolgono dati da vari sen-
Firmware 2.0 - 45
SFIDE E SOLUZIONI PER LO SVILUPPO DI APPLICAZIONI DI EDGE MACHINE LEARNING
stemi cyber-fisici distribuiti, sistemi

autonomi, sanità, elettronica di con-
sumo e nel campo generale dell'In-
telligenza Artificiale.
APPRENDIMENTO
AUTOMATICO SU MCU
Ci sono diversi vantaggi derivanti
dall'esecuzione dei modelli ML su
MCU a bassa potenza (< 1mW), tra
cui:
• Latenza: la latenza è un requi-
sito fondamentale per le applicazio-
ni critiche nel tempo. La trasmissio-
ne dei dati verso il cloud in genere
introduce una latenza più lunga ri-
spetto all'elaborazione dei dati sul
dispositivo stesso. Le applicazioni
basate sull'esperienza utente e le
applicazioni per la sicurezza auto-
mobilistica sono esempi in cui la la-
tenza non può essere tollerata.
• Riduzione dei dati trasmes-
Tabella 1: Comparazione delle caratteristiche delle tecnologie abilitanti ML si: quando la connettività di rete è
inaffidabile o addirittura inesisten-
sori (telecamere CMOS, camere IR, audio, IMU, sensori te, l'elaborazione dei dati deve avvenire obbliga-
di temperatura, sensori chimici, accelerometri, etc.). Que- toriamente sul dispositivo periferico. Spesso non
sti dispositivi sono spesso alimentati a batteria e operano è pratico eseguire lo streaming di dati da sensori
in un intervallo di bassa potenza (1 mW o meno). In molti che generano grandi quantità di dati grezzi, come
casi il microprocessore sul dispositivo rimane sottoutiliz- fotocamere, accelerometri o microfoni. Nelle ap-
zato nel tempo, poiché di solito effettua semplici compiti di plicazioni basate su eventi, l'analisi dei dati sul
elaborazione. L'uso diffuso di dispositivi embedded basati dispositivo periferico può filtrare i dati prima dell'in-
su MCU, la loro vicinanza alle fonti fisiche delle informa- vio delle informazioni.
zioni attraverso sensori, e le capacità di elaborazione sot- • Efficienza energetica: le MCU sono intrinseca-
toutilizzate li rendono altamente adatti per la distribuzione mente progettate per eseguire calcoli a potenza
di algoritmi di inferenza leggeri. Questa tendenza ha dato estremamente bassa, in modo che possano fun-
origine al Tiny Machine Learning (TinyML), un campo zionare a lungo con un budget energetico limitato.
di tecnologia embedded emergente che mira a distribuire Le MCU possono funzionare con batterie o altri tipi
algoritmi di apprendimento automatico su dispositivi con di fonti di energia, come l'energy harvesting.
risorse limitate e basati su MCU. La Figura 1 mostra l'ac- • Basso costo: l'espansione delle applicazioni IoT
curatezza di vari modelli di reti neurali profonde sviluppati in molti segmenti industriali è stata aiutata dal bas-
nel decennio passato. La precisione dei modelli aumenta so costo e dai volumi elevati dei microprocessori
in funzione della loro complessità (rappresentata dalla di- e dell'hardware embedded di supporto, e questa
mensione della sfera) e della complessità computaziona- tendenza è probabile che continui.
le. La sfida degli sviluppatori TinyML è quindi quella di tro- • Privacy: la privacy è sempre una preoccupazione
vare modi per adattare questi algoritmi di apprendimento quando vengono gestiti dati personali o altri dati
profondo per essere usati su dispositivi con risorse limita- altamente sensibili. Ciò è particolarmente vero se i
te ma con una elevata precisione dei modelli. dati vengono inviati al cloud, poiché i dati possono
TinyML consentirà innovazioni in vari campi, come i si- essere persi o rubati. Pertanto, l'elaborazione dei
46 - Firmware 2.0
Figura 1: Accuratezza di vari modelli di reti neurali. L'accuratezza aumenta con l'aumentare della complessità del modello e
del costo computazionale
dati sul dispositivo si traduce in una maggiore pri- del modello e le attivazioni dell'output.
vacy e una migliore protezione dei dati. Un'altra limitazione nell'esecuzione ML su microcon-
• Autonomia: i piccoli dispositivi embedded posso- trollore è la limitata durata della batteria. Per stimare la
no contribuire alla maggiore autonomia del siste- durata della batteria, deve essere considerata l'efficien-
ma al quale appartengono, generando decisioni za energetica del microcontrollore. In generale, l'effi-
locali indipendenti e basate sui dati, che possono cienza energetica dipende dal costo computazionale
essere condivise solo all'interno del sistema. dell'algoritmo di apprendimento automatico e dal duty
cycle dell'elaborazione. Per affrontare queste sfide, diver-
Tuttavia, l'esecuzione di Machine Learning su processori si framework sviluppati da società e istituzioni di ricerca
embedded a 32 bit comporta molte sfide tecniche. Le sfide forniscono strumenti open source per la progettazione e
più importanti nella distribuzione di reti neurali su micro- l'implementazione di algoritmi di Machine Learning su di-
controllori riguardano le ridotte dimensioni della memoria spositivi con risorse limitate. Questi framework includono
e la durata della batteria. La dimensione del modello di librerie per l'inferenza altamente efficienti e processi che
apprendimento automatico deve essere sufficientemente semplificano lo sviluppo del modello e la sua distribuzione
piccola da rientrare nei vincoli imposti dai dispositivi MCU. su dispositivi embedded.
Come illustrato nella Tabella 2, i tipici microcontrollori
sono estremamente limitati in termini di memoria su chip FRAMEWORK
SRAM (192 - 512 KB) e memoria flash (256 KB - 2 MB). A causa delle risorse limitate, i dispositivi basati su MCU
L'intero modello di rete neurale con i suoi pesi, connessio- non possono attualmente supportare l'addestramento
ni neurali e codice di supporto deve adattarsi alla piccola dei modelli. Invece, il modello viene prima addestrato nel
memoria flash. La dimensione della SRAM limita il buffer cloud o su un dispositivo più potente, per poi essere di-
di memoria temporaneo utilizzato per memorizzare l'input stribuito sul dispositivo embedded. Esistono tre modi per
Firmware 2.0 - 47
Tabella 2: Principali caratteristiche dei microcontrollori più usati nel TinyML
distribuire un modello su un sistema embedded: dono la portabilità e la comparabilità una sfida;

1. La codifica manuale consente l'ottimizzazione a 3. Infine, gli interpreti ML sono fatti per la portabilità,
basso livello per specifiche applicazioni; tuttavia, poiché forniscono la stessa struttura astratta su di-
è dispendioso in termini di tempo e poco pratico; verse piattaforme.
2. La generazione del codice produce codice ben
ottimizzato senza lo sforzo significativo della codi- Un interprete ML è solitamente una parte di un fra-
fica manuale, automatizzando le ottimizzazioni a mework che comprende un insieme di strumenti e librerie
livello di sistema. Tuttavia, ogni fornitore utilizza i software per l'implementazione di algoritmi di Machine Le-
propri strumenti e compilatori proprietari, che ren- arning su dispositivi embedded con capacità di elabora-
Figura 2: Schema a blocchi che descrive la realizzazione di un'applicazione ML con TensorFlow Lite
48 - Firmware 2.0
zione limitate, incluse le MCU. All'interno di un framework, L'input nel sistema ELL è un modello generato in vari
viene utilizzato un interprete per chiamare singoli kernel formati, come il formato OpenNeural Network Exchange
(come convoluzione, riempimento, etc.), che possono es- (ONNX), TensorFlow o il formato Microsoft Cognitive To-
sere ottimizzati individualmente per la particolare piatta- olkit (CNTK). Il sistema ELL genera un modello intermedio
forma. come file .ell. Il file .ell, del modello intermedio, viene uti-
Alcuni dei più diffusi framework TinyML vengono discussi lizzato per generare codice eseguibile. ELL è un progetto
di seguito. È interessante notare che questi framework si ambizioso che mira ad essere agnostico rispetto al forma-
concentrano solo su modelli di rete neurale. to del modello di input.
Molti altri strumenti open source includono librerie per altri Tuttavia, al momento, è supportato da un team piccolo e
algoritmi di apprendimento automatico, come classificato- non è chiaro quanto sia diffuso questo toolkit.
ri bayesiani, alberi decisionali e k-NN.
ARM-NN
TENSORFLOW LITE ARM-NN è un software Linux open source per l'inferenza
TensorFlow Lite è un framework open source per l'ap- Machine Learning su dispositivi embedded, sviluppato da
prendimento profondo sviluppato da Google per abilitare Arm. Il cuore del framework di Arm è la libreria software
l'inferenza su dispositivi embedded. CMSIS NN, che è una raccolta di efficienti kernel di reti
Questo framework è costituito da due strumenti principali, neurali sviluppati per massimizzare le prestazioni e ridurre
Converter e Interpreter. Converter trasforma il codice al minimo l'uso di memoria delle reti neurali sui core del
TensorFlow in un formato particolare, riduce la dimensio- processore Cortex-M.
ne del modello e ottimizza il codice per una perdita mini- Poiché CMSIS-NN si rivolge specificamente ai dispositivi
ma di precisione. embedded, la libreria utilizza l'aritmetica a virgola fissa,
TensorFlow Interpreter è una libreria che esegue il co- così che i parametri del modello possano essere quantiz-
dice sul dispositivo embedded. Un porting separato di zati in interi a 8 o 16 bit e quindi distribuiti sul microcontrol-
TensorFlow Lite, denominato TensorFlow Lite micro, è lore per l'inferenza.
progettato per eseguire modelli di Machine Learning in Inoltre, questo framework sfrutta le architetture di ela-
modo specifico su microcontrollori a 32 bit con pochi kB borazione della più popolare serie di microcontrollori
di memoria. Cortex-M, per migliorare i tempi di esecuzione.
È stato portato con successo su molti processori, inclu-
sa la famosa serie Arm Cortex-M e ESP32. La Figura 2 IN CONCLUSIONE
illustra i passaggi necessari per creare un'applicazione Tiny Machine Learning (TinyML) ha il potenziale per
"Wake Words" utilizzando questo framework. sbloccare una classe completamente nuova di applicazio-
Il framework è disponibile come libreria Arduino in modo ni negli spazi industriali e di consumo.
da poter essere portato su altri progetti C++ 11 come li- Questo campo è ancora in una fase iniziale di svilup-
breria open source. I limiti delle MCU sono la causa dei po, ma si evolve rapidamente. Attualmente, i framework
limiti di TensorFlow micro. Ad esempio, il framework TinyML si concentrano principalmente su applicazioni che
supporta solo un sottoinsieme delle operazioni dell'origi- coinvolgono la visione artificiale, l'elaborazione audio o gli
nale TensorFlow e non può essere utilizzato per l'adde- algoritmi NLP.
stramento del modello. Applicazioni in sanità, sistemi autonomi e sorveglianza
saranno supportati dai framework TinyML nel prossimo
EMBEDDED LEARNING LIBRARY (ELL) futuro.
Embedded Learning Library è un framework open sour-
ce embedded sviluppato da Microsoft che supporta lo svi-
luppo di modelli di Machine Learning per diverse piatta-
forme basate sulle architetture ARM Cortex-A e Cortex-M,
come Arduino, Raspberry Pi e micro: bit. ELL può essere
descritto come una toolchain cross-compilatore per mo- direttamente all’articolo sul Blog e partecipare alla discussione:
delli ML/AI. Comprime il modello e genera codice macchi- https://it.emcelettronica.com/sfide-e-soluzioni-per-lo-
na ottimizzato eseguibile su una piattaforma di destinazio- sviluppo-di-applicazioni-di-edge-machine-learning
ne embedded.
Firmware 2.0 - 49
COME UTILIZZARE
HADOOP E PERCHÉ È
FONDAMENTALE PER I
BIG DATA di Roberta Fiorucci
Mentre grandi quantità di dati non strutturati rappresentano una sfida costante per le infrastrutture IT,
ci sono tecnologie che permettono di gestire e rendere utile e visibile un numero sempre più crescente di
informazioni. In questo articolo parliamo dell'ecosistema di una di queste tecnologie, Apache Hadoop e ne
analizzeremo i vantaggi, le caratteristiche ed i limiti fino ad arrivare alle più recenti implementazioni.
INTRODUZIONE COME NASCE IL PROGETTO
O
gni giorno assistiamo ad un costante aumento di Alla fine del 2003, Google rilasciò due documenti acca-
dati provenienti da più fonti, strumenti o sistemi: demici in cui si descrivevano Google File System (GFS)
i Big Data. e MapReduce. I documenti fornivano una piattaforma
Allo stesso tempo, la loro origine è sempre più comples- per l’elaborazione dei dati sulla quale potevano essere
sa: aumentano i dati non strutturati e di conseguenza si implementate più applicazioni di elaborazione. Contem-
evidenziano i limiti della gestione di database relazionali. poraneamente, Douglas Cutting che lavorava sul crawler
Questo impone nuovi approcci, oltre che nuove professio- web open source Nutch, iniziò ad interessarsi alle imple-
nalità, in grado di gestire e semplificare le informazioni. mentazioni open source delle idee di Google e poco dopo
Tra le tecnologie in grado di soddisfare le esigenze dei Big nacque Hadoop, inizialmente come progetto derivato di
Data, c’è Apache Hadoop, riconoscibile dal suo caratteri- Lucene (API gratuita ed open source per il reperimento di
stico elefantino giallo. informazioni) e poi come progetto indipendente legato ad
Progettato come un framework per l'elaborazione di gran- Apache Software Foundation. Douglas Cutting che nel
di quantità di dati, Hadoop è open source, fa parte del 2006 è diventato prima dipendente Yahoo! per poi passa-
progetto Apache ed è scritto in Java. Viene utilizzato re a Cloudera ha continuato a guidare il progetto Hadoop
da molte aziende come British Airways, Uber, Netflix, la insieme ad un team di ingegneri implementandolo con
National Security Agency (NSA) degli Stati Uniti, da social miglioramenti ed estensioni. Famosa la sua dichiarazione
network come Twitter o Facebook per analizzare il traffico durante la conferenza Hadoop World: "Le mie aspettative
di utenti e da una società come Visa per contribuire alla erano più moderate di quelle che abbiamo visto, di sicuro".
gestione delle frodi. Il progetto legato ad Hadoop ha subi-
to negli anni diversi cambiamenti. PERCHÉ I BIG DATA?
Di base, fornisce due servizi: lo storage e il calcolo. Hadoop permette di distribuire set di dati molto grandi su
cluster di server di base e di elaborarli in parallelo, moti-
Il framework Hadoop è costituito da tre livelli principali: vo principale a renderlo uno strumento utile per gestire e
• Hadoop HDFS (Distributed File System) è l'unità analizzare molte informazioni. Inoltre, divide o partiziona
di archiviazione; i dati in blocchi e poi assegna i dati a nodi diversi per ef-
• Hadoop MapReduce è l'unità di elaborazione; fettuare l'analisi. In questo modo si ottiene un processo
• Hadoop YARN (Yet Another Resource Negotiator) separato che rende possibile la gestione di tutti i dati non
è l'unità di gestione delle risorse. strutturati come file video, audio o immagini che non pos-
50 - Firmware 2.0
COME UTILIZZARE HADOOP E PERCHÉ È FONDAMENTALE PER I BIG DATA
Figura 1: Il logo Hadoop ispirato all'elefantino giallo preferito dal figlio di Douglas Cutting
sono essere mappati tramite schemi tipici di database re- predefinita fino a un massimo di 128 MB. La dimensione
lazionali. L'elaborazione parallela dei dati, poi, permette predefinita del blocco può essere modificata in base alla
una maggiore velocità di analisi. Altra caratteristica è che velocità di elaborazione e alla distribuzione dei dati. Ha
i cluster possono essere ridimensionati per permettere di un'architettura master-slave con due componenti princi-
aggiungere altri cluster e, se un nodo si guasta, sono di- pali: NameNode e DataNode. Il primo è il nodo principale
sponibili copie aggiuntive dei dati su altri nodi. che ospita i metadati nel disco e nella RAM. Contiene in-
Possiamo riassumere le sue principali caratteristiche in 5 formazioni sui vari DataNode, la loro posizione, la dimen-
punti fondamentali: sione di ogni blocco. I DataNode conservano i blocchi di
• Veloce: gli utenti possono eseguire query com- dati effettivi e inviano report sui blocchi al NameNode ogni
plesse in pochi secondi; 10 secondi. Il DataNode memorizza e recupera i blocchi
• Conveniente: Hadoop è un framework di dati quando il NameNode lo richiede. Legge e scrive la richie-
open source; sta del client ed esegue la creazione, l'eliminazione e la
• Resiliente: i dati archiviati in un nodo vengono replica di blocchi in base alle istruzioni del NameNode.
replicati in altri nodi del cluster, garantendo tolle- C'è un solo NameNode attivo che, come detto, gestisce
ranza agli errori; i DataNode e memorizza tutti i metadati, mentre possono
• Scalabile: funziona in un ambiente distribuito e esserci più DataNode che memorizzano i dati effettivi.
permette di aggiungere facilmente più server;
• Diversità: l'HDFS di Hadoop può memorizzare di- MAPREDUCE
versi formati di dati, strutturati, semi strutturati e MapReduce è l'unità di elaborazione, un modello di pro-
non strutturati. grammazione che consente di ridimensionare i dati non
strutturati su centinaia o migliaia di server commodity in
Bisogna, però, considerare alcuni limiti. Il processo per un cluster Apache Hadoop. Un modello di programma-
eseguire una query nel file system di Hadoop, l'utilizzo di zione in grado di suddividere ogni richiesta in richieste
MapReduce con Java non è così intuitivo; inoltre, l'eco- più piccole che vengono inviate a molti piccoli server per
sistema è costituito da molti componenti e può risultare rendere possibile l'uso più scalabile della CPU. Introdot-
complessa una gestione completa. MapReduce inoltre ri- to originariamente da Google come metodo per risolvere
sulta limitato soprattutto per le attività in tempo reale. una classe di problemi di dimensioni petabyte/terabyte, è
composto da due fasi: Map Phase e Reduce Phase. La
ECOSISTEMA HADOOP prima fase è quella a cui vengono inviati i dati di input per
HADOOP DISTRIBUTED FILE SYSTEM essere mappati e produrre valori di output. Nella fase di
HDFS è il componente per l'archiviazione dei dati in modo riordino e ordinamento, l'output della fase di mappatura
distribuito. Divide i dati in più blocchi, per impostazione viene preso e raggruppato in blocchi di dati simili. Infine,
Firmware 2.0 - 51
Figura 2: Master e Slave Nodes
vengono aggregati i valori di output della fase di rimesco- • Compatibilità: le applicazioni sviluppate per Ha-
lamento. Quindi restituisce un singolo valore di output. Gli doop 1 vengono eseguite su YARN senza interru-
sviluppatori possono scrivere codici MapReduce in più zioni o problemi di disponibilità;
linguaggi come Java, C++ e Python. MapReduce offre di- • Utilizzo delle risorse: YARN consente l'allocazio-
verse funzionalità e vantaggi per aiutare a ottenere infor- ne dinamica delle risorse del cluster per migliorare
mazioni dettagliate da vasti volumi di dati. l'utilizzo delle risorse;
• Multitenancy: YARN può utilizzare motori di ac-
YARN cesso ai dati open source e proprietari, eseguire
Gestisce le risorse del cluster e gestisce le applicazioni. analisi in tempo reale e query ad hoc.
YARN, introdotto con il passaggio da Hadoop 1 alla ver- Con Hadoop 3 sono state introdotte altre funzionalità.
sione 2 alloca RAM, memoria e altre risorse a diverse ap- Per prima cosa consente di avere più name node e vie-
plicazioni. Include: ne ridotto il sovraccarico di archiviazione con la codifica
• ResourceManager (master): gestisce l'assegna- di cancellazione. Inoltre, consente l'utilizzo dell'hardware
zione di risorse come CPU, memoria e larghezza GPU all'interno del cluster, il che rappresenta un vantag-
di banda di rete; gio sostanziale per l'esecuzione di algoritmi di Deep Lear-
• ApplicationMaster (uno per applicazione); ning su un cluster Hadoop.
• NodeManager (slave): segnala l'utilizzo delle risor-
se al Resource Manager. HBASE PARTE DELL'ECOSISTEMA HADOOP
L'archiviazione e l'elaborazione di dati come, ad esempio,
L'introduzione di YARN ha risolto alcuni problemi di email, file JSON, .csv, è una sfida sempre più importante,
MapReduce apportando significativi vantaggi legati a: una possibile soluzione è rappresentata da un database
• Scalabilità: puoi avere una dimensione del cluster non distribuito, basato su colonne e non relazionale come
superiore a 10.000 nodi ed eseguire più di 100.000 Apache HBase che sfrutta l'archiviazione dati distribuita
attività simultanee; fornita da Google File System. HBase si compone di più
52 - Firmware 2.0
Figura 3: Input/output MapReduce
tabelle e queste tabelle sono costituite da molte righe di aziendali. Importa i dati da datastore esterni in HDFS,
dati con più famiglie di colonne ognuna costituita da una Hive e HBase. La macchina client raccoglie il codice, che
coppia chiave-valore. Infatti, HBase è un tipo di database verrà quindi inviato a Sqoop. Sqoop passa quindi al Task
NoSQL ed è classificato come archivio chiave-valore: il Manager che, a sua volta, si connette al Data WareHouse
valore è identificato con una chiave, sia la chiave che i aziendale, ai sistemi basati su documenti e all'RDBMS.
valori sono byte array, il che significa che i formati binari
possono essere archiviati facilmente ed i valori sono me- Flume: strumento di raccolta e inserimento dati, un servi-
morizzati in ordini di chiavi. In pratica, HBase è un da- zio distribuito per la raccolta, l'aggregazione e lo sposta-
tabase in cui le tabelle non hanno schema. Può essere mento di grandi quantità di dati. Ingerisce i dati di strea-
utilizzato quando si cercano dati di piccole dimensioni da ming online dai social media, registra i file, il server Web
set di dati di grandi dimensioni. Alcune delle aziende che in HDFS.
utilizzano HBase sono Facebook, Netflix, Yahoo, Adobe
e Twitter. Facebook, ad esempio, l'ha adottato per la ne- Mahout: si utilizza per implementare algoritmi di ap-
cessità di potenziare un sistema in grado di gestire due prendimento automatico nell'ecosistema Hadoop senza
tipi di modelli di dati: un set di dati in continua crescita con necessariamente essere integrato. Ha una libreria che
accesso sporadico e un set di dati in continua crescita e contiene algoritmi integrati per il filtraggio collaborativo, la
altamente volatile. classificazione e il clustering.
GLI STRUMENTI Impala: motore SQL open source particolarmente veloce

HDFS, MapReduce e YARN sono i componenti di Hadoop nell'elaborazione. La sintassi utilizzata da Impala è simile
a cui si aggiungono diversi strumenti Apache di raccolta e a SQL, all'interfaccia utente e al driver ODBC come Apa-
importazione dei dati: che Hive ma è in grado di superare i limiti di velocità che
invece vengono imputati ad Hive.
Hive: piattaforma in Java utilizzata come Data WareHou-
se basato su Hadoop. Si basa su linguaggio di query Hi- Spark: un framework open source progettato idealmente
veQL o HQL molto simile a query SQL ed utilizza archivia- per applicazioni batch, query interattive, elaborazione di
zione ORC, HBase e testo normale. dati in streaming e apprendimento automatico.
Questo sistema è molto conosciuto ed è stato sviluppato
proprio per avere un linguaggio simile a SQL di più fa- Pig: sviluppato per la prima volta da Yahoo per semplifi-
cile comprensione per chi è meno esperto. Apache Hive care la programmazione poiché non utilizza codice Java
ha due componenti principali attraverso i quali un utente particolarmente complesso, viene utilizzato per analizzare
invia prima le query Hive. Queste query vengono conver- grandi set di dati, è molto efficiente in termini di tempo
tite in attività MapReduce e accedono al sistema Hadoop e può essere presentato sotto forma di flusso di dati. Il
MapReduce. linguaggio di questa piattaforma è chiamato Pig Latin che
Pig Latin Compiler converte, appunto, in codice eseguibi-
Sqoop: utilizzato per trasferire dati tra Hadoop e datasto- le. Pig fornisce estrazione, trasferimento e caricamento
re esterni come database relazionali e Data WareHouse e una piattaforma per la creazione di flussi di dati. Grunt
Firmware 2.0 - 53
Shell è la shell interattiva di Pig, utilizzata per eseguire l'azione viene terminata direttamente.
tutti gli script Pig.
Zookeeper viene invece utilizzato per garantire la sincro-
Storm: sistema di calcolo in tempo reale, open source uti- nizzazione in un cluster. Oltre agli strumenti sopra men-
lizzato per lo streaming a velocità molto elevata. zionati, c'è Tableau che fornisce visualizzazioni interattive
Apache Storm è scritto in clojure ed è integrato con Ha- per dimostrare le intuizioni tratte dai dati.
doop proprio per sfruttare velocità di trasmissione più ele-
vate. CONCLUSIONI
Lo utilizzano aziende come Twitter e Spotify. Hadoop è una tecnologia ampiamente utilizzata per l'ar-
chiviazione, l'elaborazione e l'analisi di grandi set di
Kafka: è una piattaforma di streaming distribuita progetta- dati con molti utilizzi di business e non solo.
ta per archiviare ed elaborare flussi di record. Ad esempio, può essere utilizzato nella ricerca in am-
È scritto in Scala. bito sanitario per lo sviluppo di malattie croniche in cui
Crea pipeline di dati in streaming in tempo reale che ot- l'integrazione di metodi e visualizzazioni è molto impor-
tengono dati in modo affidabile tra le applicazioni e crea tante.
anche applicazioni in tempo reale che trasformano i dati Hadoop permette di ottenere e accumulare origini di dati
in flussi. Kafka utilizza un sistema di messaggistica per di natura diversa: registrazioni di chiamate, email o ses-
trasferire i dati da un'applicazione all'altra. sioni di chat spesso difficili da analizzare.
Questo apre ad un utilizzo ampio e in settori diversi a par-
ALCUNI FRAMEWORK DI SICUREZZA tire dalle telecomunicazioni per effettuare analisi da più
Ranger: framework progettato per abilitare, monitorare e fonti.
gestire la sicurezza dei dati attraverso la piattaforma Ha- Permette di effettuare analisi del sentiment, riconosci-
doop. mento di pattern tipici o di effettuare l’analisi dei dati Point
Fornisce un'amministrazione centralizzata per la gestione of Sale (PoS) o delle vendite.
di tutte le attività relative alla sicurezza. Può essere utilizzato per l'analisi dei rischi o di possibili
Ranger standardizza l'autorizzazione su tutti i componenti guasti in ambito industriale con l'analisi di dati in tempo
Hadoop e fornisce un supporto avanzato per diversi meto- reale tramite sensori per individuare anomalie separate
di di autorizzazione come il controllo degli accessi basato che possono così essere messe in relazione.
su ruoli e attributi. In Google alcuni esempi di utilizzo sono l'indicizzazione
web e le statistiche di accesso al web. Rispetto ad un da-
Knox è un gateway applicativo che interagisce con le API tabase tradizionale Hadoop ha scalabilità ed è più eco-
e le interfacce utente REST. Il gateway offre tre tipi di ser- nomico.
vizi per l'utente: Inoltre, MapReduce esegue elaborazioni parallele, che
archiviano e recuperano i dati più velocemente delle in-
Servizio di proxy per l'accesso ad Hadoop tramite il proxy formazioni che risiedono su un database tradizionale che,
della richiesta HTTP al contrario, è ottimo per gestire flussi di lavoro prevedibili
Servizio di autenticazione per l'accesso all'API REST e il e costanti.
flusso WebSSO per le interfacce utente Ci sono tuttavia ancora molti limiti. I maggiori sono legati
Servizio client per lo sviluppo del client tramite scripting alla sicurezza ed alla presenza di troppi componenti che
DSL o utilizzando le classi shell Knox gestiscono le cose in modo diverso. Questo comporta una
certa esperienza per un utilizzo ottimale.
Oozie: sistema e motore di pianificazione del flusso di la-
voro.
Consiste in Grafi Aciclici Diretti (DAG), che specificano
una sequenza di azioni da eseguire e un motore costituito
da processi del flusso di lavoro attivati dal tempo e dalla direttamente all’articolo sul Blog e partecipare alla discussione:
disponibilità dei dati. https://it.emcelettronica.com/come-utilizzare-hadoop-e-
Il processo inizia con i lavori MapReduce. Ad azione posi- perche-e-fondamentale-per-i-big-data
tiva corrisponde un avviso tramite email, in caso di errore
54 - Firmware 2.0
TEMPI DI
ELABORAZIONE
DEI BIG DATA di Daniele Valanzuolo
Qualsiasi dispositivo ormai è in grado di acquisire e trasmettere una mole consistente di informazioni che
prima o poi dovranno essere elaborate per ottenere un risultato. I tempi di elaborazione sono divenuti un
elemento fondamentale ed esistono diverse metodologie per la corretta gestione dei processi di elaborazio-
ne, in funzione dell'esigenza dei dati da elaborare per l'attuazione di processi decisionali, nonché la sem-
plificazione delle informazioni da trasmettere e inviare. A seconda del contesto applicativo, ad esempio IoT,
financial, medicale o automotive, l’elaborazione real-time dei dati deve fare i conti con le risorse computa-
zionali ed energetiche del dispositivo. In questo articolo andremo ad osservare le tecniche più diffuse per la
gestione di elaborazioni real-time con Big Data.
INTRODUZIONE CARATTERISTICHE INFORMATIVE DEI BIG
L
'avvento dei cosiddetti Big Data non ha apportato al- DATA
cuna innovazione dal punto di vista della capacità di La necessità di dare un senso a queste informazioni ac-
archiviare dati, ma sicuramente la capacità di trarre quisite e la necessità di ottenere dei risultati dall'elabora-
dei risultati e informazioni significative dalla mole di dati, zione in termini accettabili (o anche compatibili con l'ap-
garantendo processi elaborativi rapidi, flessibili e, soprat- plicazione) ha spinto il settore tecnologico e dei servizi ad
tutto, economici grazie all’automatizzazione dell’analisi. una crescita più che esponenziale di tecniche, metodolo-
Così, tutte le informazioni che sono state acquisite in for- gie, approcci e funzionalità di analisi dei Big Data.
mato digitale nei decenni precedenti all'era dei Big-Data, Seppur sembra banale, il percorso di sviluppo dell'analisi
ora possono avere uno scopo congiuntamente alla mole dei Big Data non è semplice a causa della natura com-
di dati che giorno dopo giorno, o meglio istante dopo istan- plessa dei dati.
te, viene continuamente acquisita: dalle preferenze di ac- Questi ultimi, che sono l'elemento fondamentale dell'ela-
quisto sui siti e-commerce al comportamento dei clienti borazione, sono il risultato dei processi di acquisizione da
all'interno degli store fisici, dai dati di guida degli autovei- sorgenti eterogenee, spesso senza alcuna organizzazio-
coli alla gestione del traffico sui servizi di navigazione (ad ne in struttura o quant’altro.
esempio Google Maps), e tante altre informazioni in ogni Ciò comporta la necessità di una fase di pre-processing
luogo, ogni contesto e qualsivoglia applicazione. dei dati affinché questi possano essere "formattati” o co-
La definizione di Big Data è ancora un concetto abbastan- munque adattati ai processi automatici di elaborazione ed
za astratto in quanto include differenti tipologie di dati e estrazione dei risultati.
strutture. I parametri che caratterizzano la raccolta di dati sono 3:
• volume dei dati (una quantità enorme e non pro-
Di fatto, la definizione più generale si riferisce a: cessabile con i processi standard)
• velocità (ossia quanti dati vengono acquisiti)
• varietà (tipologia dei dati)
“Una “raccolta di dati e informazioni” ottenuta in
un determinato intervallo di tempo con l’ausilio di
Proprio per la varietà della tipologia dei dati, a causa di dif-
piattaforme hardware/software che svolgono l’attività
di acquisizione, elaborazione e gestione dei dati stessi. ferenti sorgenti degli stessi, otteniamo una complicazione
nella generazione del flusso di dati da inviare come input
Firmware 2.0 - 55
TEMPI DI ELABORAZIONE DEI BIG DATA
Figura 1: Architettura esemplificativa di un Processo Real-Time con Data WareHouse
ai processi di elaborazione decisionale. in tempo reale;

Infatti, in questo caso specifico la sfida si complica in • feedback: gestione di riscontri da parte dell’utente
quanto i dati raccolti all’interno del flusso presentano ca- finale sul risultato del processo di elaborazione,
ratteristiche tra di esse eterogenee. fondamentale per intervenire tempestivamente su
Inoltre, se i dati non sono strutturati, per poter procedere divergenze dei processi di elaborazione.
all’elaborazione real-time è necessario procedere a fasi di
astrazione dei dati. La corretta gestione dei dati su larga scala attraverso i
processi di Data Abstraction porta ad un processo di eli-
Il concetto di Data Abstraction è un passo fondamentale minazione delle informazioni inutili (detto anche processo
per garantire la corretta gestione dei Big Data (e dei risul- di pulizia).
tati dei processi di elaborazione applicata ad essi). Quindi, come cogliere la correlazione tra dati e determina-
Infatti, tra questi aspetti rientra sicuramente anche la sfida re con precisione l'utilità e l'efficacia dei dati, diventa una
dell’usabilità delle informazioni, basata sui seguenti prin- seria sfida per chi è chiamato ad implementare gli algorit-
cipi basilari: mi di elaborazione ed estrazione dei dati.
• visibilità: la corretta visualizzazione dei dati che
può avvenire su larga scala o anche in tempo re- IL TEMPO COME VALORE NEI PROCESSI
ale in funzione delle esigenze dell'utilizzatore dei REAL-TIME
dati; La definizione di real-time è una delle definizioni “generi-
• mappatura: direttamente collegata alla capacità di che” che si utilizzano nel mondo tecnologico.
elaborazione dei Big Data, a maggior ragione se Quando parliamo di real-time intendiamo un’unità di tem-
56 - Firmware 2.0
po ben precisa? Un secondo, un millisecondo, un micro re i dati all’interno di strutture tipo database. Infatti, nella
secondo o cosa? Nulla di più sbagliato. Spesso tendiamo stragrande maggioranza delle applicazioni di elaborazio-
ad associare la definizione di real-time a qualcosa che ne di Big Data, il risultato è destinato alle persone.
duri un breve tempo, pochi millisecondi. Questo vuol dire che per produrre il risultato della ricerca
su Google non è necessario che questa avvenga in 10
Una definizione ben fatta è quella anglosassone riportata ms, ma anche l’ordine di un secondo è più che soddisfa-
dal COBUILD Advanced English Dictionary (link alla defi- cente come velocità di elaborazione “real-time”.
nizione): L’applicazione di algoritmi di elaborazione in real-time dei
Big Data è di fondamentale importanza laddove l’analisi
dei dati è fondamentale per garantire la sicurezza dei pro-
cessi o dei dati.
“If something is done in real time, there is no noticeable
delay between the action and its effect or consequence.
Nei sistemi real-time il tempo è un valore associato alle in-
formazioni stesse: con il passare del tempo l’elaborazione
di una data informazione può diventare inutile in quanto il
risultato non è più necessario o applicabile.
Applicando questa definizione ad un generico sistema ca- Per applicare un processo di tipo real-time è necessaria
piamo benissimo che questo è real-time quando il ritardo anche una fornitura continua degli ingressi per mantenere
tra la decisione (effetto) e l’azione (acquisizione dei dati) è il processo costante e produrre i dati di output.
praticamente trascurabile. Le modalità di trattamento dei dati comprendono princi-
palmente due tipologie:
La trascurabilità non può essere definita a priori ma sem- • Elaborazione di tipo batch: è un’elaborazione
plicemente dall’applicazione del sistema. Un esempio ad alta latenza che agisce su lotti (appunto "ba-
pratico è il seguente: tch") di informazioni già disponibili ed in un forma-
to chiaro in modo tale da garantire al processo di
tipo batch un lavoro ripetitivo. In genere è il tipo di
elaborazione che viene utilizzata per processare i
“Il sistema di bordo di un veicolo a guida autonoma Big Data su attività ripetitive, con un set di informa-
prende decisioni in real-time. Alla velocità di 100
km/h percorre circa 27,7 m/s, ossia 2,77 cm in 1 zioni omogeneo e completo. L'elaborazione batch
millisecondo. Quindi è accettabile avere un processo garantisce efficienza, semplicità ed ottimizzazione
decisionale al millisecondo, o anche 10 ms (equivalenti a discapito del tempo di elaborazione che non ga-
ad uno spostamento di 30 cm). rantisce una bassa latenza.
• Elaborazione streaming: è utilizzata per processi
a bassa latenza applicata a flussi di dati in ingres-
so (streaming) generati in maniera continua e di-
namica. L'elaborazione streaming consente la ge-
E’ ovvio che se il sistema si applica ad un razzo che rag- nerazione di risultati in real-time (in funzione della
giunge velocità di oltre 1000 km/h non è più possibile pren- complessità si hanno basse latenze comprese tra
dere decisioni con un processo a 10 ms ma bisognerà i millisecondi ed i secondi a differenza dei processi
scendere abbondantemente al di sotto dei millisecondi. batch che possono richiedere minuti o anche ore).
Si dice che il significato di real-time varia in funzione del
contesto in cui il sistema viene utilizzato. Abbiamo appena detto che nelle elaborazioni real-time
Per il contesto dei Big Data il tempo reale si trasforma in il processo di fornitura dei dati (streaming) deve essere
applicazioni abbastanza veloci per il processo decisionale costante.
richiesto.
Gli aspetti fondamentali da valutare su uno streaming di
All’interno dei sistemi di elaborazione, la denotazione di dati sono la natura dei dati, la varietà, la velocità, la volati-
real-time corrisponde di fatto ad un’architettura del siste- lità ed infine la variabilità e veridicità.
ma capace di elaborare gli input senza dover memorizza- Sono tutti concetti che sono stati introdotti in precedenza
Firmware 2.0 - 57
parlando delle caratteristiche informative dei Big Data. Grazie alla visione di sistema sui dati acquisiti ed al pro-
cesso decisionale da applicare, le DWH implementano le
E' fondamentale rimarcare tali aspetti in quanto senza metodologie ed applicazioni più adatte alla latenza richie-
un'attenta gestione di essi è impossibile creare e garantire sta, combinando tra loro i diversi algoritmi che rendono di
un flusso costante ed affidabile in ingresso ad un proces- fatto la piattaforma general purpose e adattabile diretta-
so real-time. mente dal cliente finale.
Quindi, per ottenere una gestione efficiente dei Big Data
su larga scala è necessario valutare la natura dei dati e CONCLUSIONI
dei risultati al fine di garantire anche una corretta usabilità L’evoluzione tecnologica degli ultimi decenni che ha por-
degli output in tempo reale. tato all’affermazione delle tecnologie quali l’IoT (Internet
of Things), l’Industry 4.0, la Blockchain e via dicendo, ha
Di fatto, le tecniche di elaborazione dei processi adot- portato alla creazione di “sorgenti” di moli di dati, da cui la
tano metodologie ibride in cui sui flussi di dati in ingres- necessità di costituire una disciplina scientifica dedicata
so (elaborazione streaming) vengono applicati semplicis- proprio ai Big Data ed alla loro analisi ed elaborazione.
simi algoritmi di tipo batch che garantiscono elaborazioni
cicliche semplici e veloci su prestabilite tipologie di dati al Con il progresso tecnologico sono stati sviluppati disposi-
fine di ottenere un'ottimizzazione dell'intero processo di tivi e sistemi sempre più performanti in termini di potenze
elaborazione real-time. di calcolo e consumo di calcolo, a tal punto che ormai l’e-
laborazione in tempo reale dello streaming di Big Data è
IL RUOLO DEI DATA WAREHOUSE diventata quasi un’esigenza per ogni applicazione.
Il passo fondamentale consta nella capacità di organiz-
zazione dei Big Data in modo tale da facilitare il processo Quando si parla di Big Data in tempo reale si intende
decisionale e velocizzare i tempi di esecuzione degli algo- la capacità del sistema di poter elaborare la raccolta
ritmi real-time. di dati in un tempo accettabile (real-time) per l’appli-
cazione del processo decisionale.
Ormai i dati sono diventati una risorsa fondamentale e Il tempo trascorso per prendere una decisione strategica
preziosa per la stragrande maggioranza delle aziende e può essere fatale ed in molti scenari applicativi l’analisi dei
delle applicazioni: cloud, IoT, Industry 4.0, automotive e dati in ingresso deve essere necessariamente eseguita in
via dicendo. tempo reale.
Grazie a questo successo anche la teoria sulle metodo-
logie di utilizzo dei Big Data ha riscosso un grande suc- Vista l’eterogeneità dei dati, per una corretta elaborazio-
cesso all’interno non solo dell’ambiente accademico, ma ne real-time è necessario poter garantire anche una sin-
anche come opportunità di business. cronizzazione tra le informazioni acquisite dalle diverse
sorgenti ed alimentare correttamente i processi real-time.
L’emergere di nuove tecnologie e piattaforme (cloud, edge
computing, data storage, etc.) ha portato alla possibilità di Il mondo degli sviluppatori di sorgenti e algoritmi e il mon-
accedere a servizi e piattaforme di elaborazione per poter do dei fornitori di servizi di Data WareHousing dovranno
gestire al meglio i propri Big Data, anche in real-time. affrontare continuamente innumerevoli sfide per soddisfa-
re le esigenze dei sistemisti ed utenti finali, poiché la cre-
Dunque, oltre all’elaborazione real-time da parte dei di- scita esponenziale dei Big Data è tutt'ora in corso.
spositivi, sono nate delle strutture imprenditoriali dette
Data WareHousing (DWH riportata in Figura 1) che ba-
sano il proprio business sulla fornitura di piattaforme di
elaborazione real-time di streaming di Big Data.
Ovviamente, le DWH devono superare sfide sempre più direttamente all’articolo sul Blog e partecipare alla discussione:
difficili per poter soddisfare le esigenze dei clienti e garan- https://it.emcelettronica.com/tempi-di-elaborazione-dei-
tire il “real-time” dell’elaborazione. big-data
58 - Firmware 2.0
QUALI SONO
LE PREVISIONI
TECNOLOGICHE PER
IL 2022? L’ANALISI DI
VICOR CORPORATION di Giordana Francesca Brescia
Vicor Corporation, leader nei componenti modulari di potenza e nei sistemi di alimentazione, ha pubblica-
to le sue previsioni per il 2022. Le previsioni riguardano fondamentalmente 3 aree: Automotive, Hyperscale
Computing, Aerospaziale & Difesa.
Q
uali sono le previsioni tecnologiche per il SETTORE AUTOMOTIVE
2022? Secondo l'analisi di Vicor, il 2022 vedrà I veicoli elettrici moderni utilizzano fino a tre batterie se-
una crescente innovazione nelle soluzioni di po- parate, una da 400 V o 800 V (batteria di trazione) ed
tenza in molti settori tecnologici. Dopo ben due anni di un sistema di distribuzione che funziona con batterie se-
pandemia globale, ecco le sfide ed i trend che caratteriz- condarie da 12 V e 48 V. I produttori sono impegnati nel
zeranno il 2022. cercare di ridurre il peso dei veicoli, riducendo anche la
Firmware 2.0 - 59
QUALI SONO LE PREVISIONI TECNOLOGICHE PER IL 2022?
L’ANALISI DI VICOR CORPORATION
60 - Firmware 2.0
QUALI SONO LE PREVISIONI TECNOLOGICHE PER IL 2022?
L’ANALISI DI VICOR CORPORATION
complessità del sistema di alimentazione. Nel corso del energetico adottando moduli ad alta densità di potenza,
2022, ci aspettiamo di vedere questo approccio modulare che a loro volta ridurranno al minimo il carico di raffred-
al power delivery adottato dagli OEM impegnati nell'elettri- damento ad aria. Si prevede inoltre che la supply chain
ficazione e differenziazione delle loro flotte, offrendo una continui a subire interruzioni con ulteriori difficoltà almeno
gamma più estesa e migliori prestazioni complessive. fino alla fine del 2023.
Uno slancio significativo verso l'innovazione deriverà
anche dal riutilizzo delle batterie dei veicoli elettrici, SETTORE MILITARE E AEROSPAZIALE
assicurando che possano essere riutilizzate per i carrelli L'innovazione e la richiesta di una maggiore efficienza
elevatori elettrici o come riserva di energia per le abitazio- continueranno a suscitare un crescente interesse per
ni e gli edifici. l'elettrificazione al fine di sostituire i sistemi meccanici e
Attorno ai veicoli commerciali più grandi ad elevata po- i combustibili chimici.
tenza, c'è un crescente interesse per l'utilizzo di celle a Ad esempio, i sommergibili avanzati stanno sostituendo
combustibile e idrogeno per la produzione di energia, che l'idraulica con l'energia elettrica, mentre gli aerei elettrici
genererà una maggiore domanda di conversione DC-DC stanno stabilendo nuovi record di autonomia e velocità.
ad alta efficienza. Infine, all'interno del veicolo, anche il La gestione dell'alimentazione per i droni ad azionamen-
comfort di marcia diventerà sempre più importante sia to elettrico continuerà ad essere un fattore critico, mentre
per il guidatore sia per i passeggeri. Si prevede anche il crescente interesse per le DEW (Directed Energy We-
una maggiore domanda di sospensioni attive alimen- apons) come i laser, sia per l'uso a bordo delle navi che
tate elettricamente, evidenziando ancora una volta la per i veicoli, richiederà soluzioni per gestire nuove fonti di
necessità di soluzioni di power management ad alta alimentazione come le batterie a stato solido.
efficienza. C'è inoltre una crescente domanda di tecnologie dell'e-
lettronica di potenza per conformarsi ai requisiti di stan-
SETTORE HIGH PERFORMANCE COMPUTING dard come la Sensor Open System Architecture (SOSA).
Secondo le previsioni di Vicor la crescita dei data Il rimbalzo della pandemia continua a vedere un'impen-
center continuerà ad accelerare. Nel 2022, il mercato glo- nata della domanda di elettronica nei mercati militare e
bale dell'hyperscale computing continuerà a crescere, a aerospaziale.
partire dai circa 147 miliardi di dollari dello scorso anno, Il settore spaziale europeo vedrà anche un crescente uti-
con una previsione CAGR delle entrate del +27,4% fino al lizzo della propulsione ionica elettrica per i veicoli spa-
2028. I principali fattori di crescita includeranno l'aumen- ziali, principalmente per il mantenimento delle stazioni per
to dei carichi di lavoro cloud, l'ottimizzazione dei data le nuove costellazioni di satelliti a banda larga trasportati
center, le piattaforme di social media e l'emergere di dallo spazio.
DaaS.
Il trend che caratterizzerà questo settore nel 2022 è l'au- INFORMAZIONI&RIFERIMENTI
mento della quota di energia rinnovabile “green”. L'alta
tensione DC sarà fornita da fonte di energia primaria in www.vicorpower.com
molte applicazioni, soprattutto sui dispositivi edge. Il CO-
VID-19 ha accelerato la crescita della quantità di dati Vicor Corporation su LinkedIn
generati e questa tendenza continuerà anche dopo la
pandemia. Con l'affermarsi della tecnologia 5G, l'infra- Vicor PowerBlog
struttura di rete diventerà sempre più complessa, con più
nodi di elaborazione più vicini all'utente per ridurre la la- Emergen Research
tenza e consentire un maggiore utilizzo delle applicazioni
IoT. L'IoT renderà necessaria più potenza computazionale
per migliorare la sicurezza, il che comporterà un aumento
della potenza di calcolo complessiva richiesta nelle appli-
cazioni. Per venire incontro a queste necessità, Vicor ha direttamente all’articolo sul Blog e partecipare alla discussione:
iniziato da tempo a progettare e realizzare convertitori di https://it.emcelettronica.com/quali-sono-le-previsioni-
potenza più piccoli e più densi per supportare la po- tecnologiche-per-il-2022-lanalisi-di-vicor-corporation
tenza di calcolo. I data center devono ridurre il consumo
Firmware 2.0 - 61
COME TRASFERIRE
UNO STILE PITTORICO
SU UNA FOTOGRAFIA
CON PYTHON di Andrea Garrapa
Il trasferimento di stile è un metodo per fondere due immagini distinte e crearne una nuova. Non si tratta
di una mera sovrapposizione o di un fotoritocco, ma della creazione di una nuova immagine che presenta il
contenuto di una foto utilizzando però lo stile pittorico di un'altra immagine. Una rete neurale può essere ad-
destrata per imparare uno o più stili pittorici ed in questo modo riuscire a riprodurre il contenuto di una foto
utilizzando un particolare stile. In questo articolo vedremo come implementare una rete neurale pre-adde-
strata per il trasferimento dello stile in uno script in linguaggio Python.
INTRODUZIONE articolo, useremo una rete per la stilizzazione arbitraria
P
er introdurre il problema del trasferimento dello sti- delle immagini.
le, iniziamo con un esempio. Supponiamo di fare
una fotografia al nostro cane e di voler trasferire IL MODELLO
lo stile di Van Gogh su questa fotografia (Figura 1). Allora Il modello per la stilizzazione dell'immagine presente in
indicheremo la foto del nostro cane come l'immagine del TensorFlow Hub è un modulo in grado di eseguire il trasfe-
contenuto, mentre indicheremo la foto di un qualsiasi di- rimento rapido di stili artistici, che può funzionare su stili di
pinto di Van Gogh come l'immagine dello stile. L'uscita pittura arbitrari. Questo modello è una versione ottimizza-
di un modello neurale per il trasferimento dello stile sarà ta per operare in tempo reale, del primo modello originale
un'immagine con gli oggetti presenti nell'immagine del che è stato sviluppato per il trasferimento dello stile.
contenuto ma resa in forma pittorica nello stile dell'imma-
gine di stile. Questa immagine appena creata viene spes- SEPARARE STILE E CONTENUTO
so definita immagine stilizzata. Il modello originale venne presentato nel 2015 attraverso
Per poter utilizzare questa tecnica non è necessario met- il paper "A Neural Algorithm of Artistic Style". Il modello
tersi ad addestrare una rete neurale personalmente, poi- utilizza rappresentazioni neurali per separare e ricombi-
ché esistono modelli pre-addestrati messi a disposizione nare contenuto e stile di immagini arbitrarie, fornendo un
della community. Per questo articolo, trarremo vantaggio algoritmo neurale per immagini artistiche. La classe di reti
dai modelli forniti dal repository TensorFlow Hub. neurali profonde che è più potente nelle attività di elabo-
TensorFlow Hub è un repository di modelli di Machine razione delle immagini è quella relativa alle reti neurali
Learning addestrati pronti per l'ottimizzazione e distribui- convoluzionali. Come base su cui sviluppare l'algoritmo
bili ovunque. Svariati modelli pre-addestrati sono presenti venne usata la rete VGG, addestrata per il riconosci-
nell'Hub per le più diverse applicazioni; quella che utilizze- mento e la localizzazione di oggetti. Dell'originale rete
remo noi è la rete di stilizzazione di immagini arbitrarie di VGG a 19 livelli fu usato lo spazio delle features fornito da
Magenta. Magenta è un progetto di ricerca open source, una versione normalizzata di 16 strati convoluzionali e 5
supportato da Google, che mira a fornire soluzioni di Ma- di pooling. Generalmente, ogni strato nella rete definisce
chine Learning nel campo artistico. Usando Magenta, si un banco di filtri non lineare la cui complessità aumenta
possono creare canzoni, dipinti, suoni e altro. Per questo con la posizione dello strato nella rete. Una data imma-
62 - Firmware 2.0
COME TRASFERIRE UNO STILE PITTORICO SU UNA FOTOGRAFIA CON PYTHON
Figura 1: Esempio di trasferimento di stile
gine di input è codificata in ogni strato della rete neurale multiscala dell'immagine di input, che acquisisce le infor-
convoluzionale dalle risposte dei filtri a quell'immagine. mazioni sulla tessitura ma non la disposizione globale (Fi-
Per visualizzare le informazioni codificate nei diversi livelli gura 2). Di nuovo, possiamo visualizzare le informazioni
della gerarchia si può eseguire la discesa del gradiente catturate da questi spazi di features sui diversi livelli della
su un'immagine di rumore bianco fino a trovare un'altra rete, costruendo un'immagine che corrisponda alla rap-
immagine corrispondente il più possibile alle risposte del- presentazione dello stile dell'immagine di input.
le features dell'immagine originale. Quando le reti neurali Questo viene fatto utilizzando la discesa del gradiente su
convoluzionali vengono addestrate per il riconoscimento un'immagine di rumore bianco per ridurre al minimo la di-
oggetti, sviluppano una rappresentazione dell'immagine stanza quadratica media tra gli elementi delle matrici di
che rende le informazioni sugli oggetti sempre più esplici- Gram dell'immagine originale e le matrici di Gram dell'im-
te nella gerarchia di elaborazione. magine da generare.
Pertanto, lungo i vari livelli della rete, l'immagine in ingres- Quindi per trasferire lo stile di un'opera d'arte su una foto-
so viene trasformata in rappresentazioni sempre più sen- grafia sintetizziamo una nuova immagine che corrispon-
sibili al reale contenuto dell'immagine, ma che diventano da simultaneamente alla rappresentazione del contenuto
relativamente invarianti rispetto al preciso aspetto. Quindi, della foto e alla rappresentazione dello stile dell'opera
i livelli più alti nella rete catturano il contenuto di alto livello d'arte. Così cerchiamo di minimizzare congiuntamente la
in termini di oggetti e la loro disposizione nell'immagine distanza della rappresentazione nello spazio delle featu-
di input ma non l'esatto valore dei pixel. La risposta delle res di un'immagine di rumore bianco dal contenuto della
features negli strati superiori della rete rappresenta quindi fotografia in uno strato e dalla rappresentazione dello stile
il contenuto dell'immagine. Per ottenere una rappresen- del dipinto su più strati della rete neurale convoluzionale.
tazione dello stile di un'immagine di input, si può utiliz- Le immagini di output vengono quindi sintetizzate trovan-
zare uno spazio delle caratteristiche progettato in origine do un'immagine che corrisponda contemporaneamente al
per acquisire informazioni sulla tessitura (texture). Que- contenuto della fotografia e alla rappresentazione stilistica
sto spazio è costruito in cima alle risposte dei filtri di ogni dell'opera d'arte. Mentre viene preservata la disposizio-
layer. Esso consiste nelle correlazioni tra le diverse rispo- ne globale della fotografia originale, i colori e le strutture
ste dei filtri sull'estensione spaziale delle mappe delle ca- locali che compongono lo scenario globale sono forniti
ratteristiche. Includendo la correlazione delle features di dall'opera d'arte.
più strati, otteniamo una rappresentazione stazionaria e La funzione di perdita che viene minimizzata durante la
Firmware 2.0 - 63
Figura 2: Rappresentazioni di immagini in una rete neurale convoluzionale (CNN). Una data immagine di input è rappresen-
tata come un insieme di immagini filtrate in ogni fase di elaborazione nella CNN. Mentre il numero di filtri aumenta lungo
la catena di elaborazione, la dimensione dell'immagine viene ridotta da un meccanismo di downsampling (es. max-poo-
ling) che porta a una diminuzione del numero totale di unità per strato della rete. Ricostruendo l'immagine di contenuto dai
livelli della rete VGG originale, troviamo che negli strati più alti della rete, le informazioni dettagliate sui pixel vengono perse
mentre il contenuto di alto livello dell'immagine viene preservato (d, e). Ricostruendo l'immagine di stile, oltre alle attivazio-
ni originali della CNN, viene utilizzato uno spazio per le informazioni sulla trama. La rappresentazione dello stile calcola le
correlazioni tra le diverse features nei diversi strati della CNN. Questo crea immagini che corrispondono allo stile di una data
immagine scartando le informazioni relative alla disposizione globale della scena
sintesi dell'immagine di output contiene due termini, il con- cazione, porta ad avere come risultato il trasferimento del-
tenuto e lo stile, che sono ben separati. lo stile artistico. Ottimizzare un'immagine o una fotografia
per obbedire a questi vincoli è computazionalmente costo-
GENERALIZZARE LO STILE so e non contiene l'apprendimento della rappresentazione
Quello che abbiamo visto si può riassumere come la co- dello stile artistico. Diversi gruppi di ricerca hanno affron-
struzione parametrica di modelli di texture vincolati alla tato questo problema costruendo una rete secondaria,
corrispondenza con statistiche marginali di banchi di filtri cioè una rete di trasferimento dello stile, per apprendere
lineari multiscala. In associazione ad un vincolo seconda- esplicitamente la trasformazione da una fotografia ad uno
rio per preservare il contenuto di un'immagine, valutato stile pittorico particolare. Sebbene questo metodo confe-
dagli strati di livello superiore della stessa rete di classifi- risca velocità di calcolo, perde molto in flessibilità. Una
64 - Firmware 2.0
Figura 3: La rete di previsione dello stile P() prevede un vettore di incorporamento S da un'immagine dello stile di input. Tale
vettore fornisce un insieme di costanti di normalizzazione per la rete di trasferimento dello stile T(). La rete di trasferimento
dello stile T() trasforma la fotografia in una rappresentazione stilizzata. Le perdite relative al contenuto e allo stile sono deri-
vate dalla distanza nello spazio rappresentativo della rete di classificazione delle immagini VGG
singola rete di trasferimento dello stile viene addestrata le immagini stilizzate secondo 12 stili differenti.
per un singolo stile pittorico e una separata rete di trasfe-
rimento dello stile deve essere costruita e addestrata per import tensorflow as tf
ogni nuovo stile di pittura. Il problema di questi metodi è
import tensorflow_hub as hub
l'impossibilità di apprendere una rappresentazione condi-
import matplotlib.pyplot as plt
visa di più stili pittorici. Comunque sia passando alla ma-
nipolazione dei parametri di normalizzazione si è scoperto import matplotlib.image as mge
possibile addestrare una singola rete di trasferimento di import numpy as np
stili per molti stili pittorici. Il modello fornito da TensorFlow
Hub è una rete di trasferimento di stili addestrata su circa Come al solito importiamo le librerie che utilizzeremo nel
80.000 dipinti e 6.000 trame visive. Questa rete è in grado programma.
di generalizzare, per catturare e trasferire lo stile artistico
dei dipinti mai osservati prima dal sistema (Figura 3).
hub_handle = 'https://tfhub.dev/google/magenta/arbi-
LO SCRIPT trary-image-stylization-v1-256/2'
Adesso possiamo descrivere lo script in linguaggio hub_module = hub.load(hub_handle)
Python che implementerà un'applicazione di trasferimen-
to dello stile. In particolare, tale applicazione prenderà
un'immagine di contenuto e visualizzerà in un singolo plot Quindi carichiamo il modulo pre-addestrato dall'Hub di
Firmware 2.0 - 65
Figura 4: L'applicazione fornisce in uscita le 12 immagini stilizzate dell'immagine di contenuto. Per ogni immagine stilizzata,
nell'angolo in alto a sinistra, è presente la corrispondente immagine di stile
TensorFlow, fornendo l'URL alla funzione hub.load(). 255 nell'intervallo da 0 a 1.
content_image = plt.imread('contenuto.jpg') Queste operazioni sono necessarie per adattare l'input

all'ingresso della rete.
content_image = content_image.astype(np.float32)[np.
newaxis, ...] / 255.
titles=['stile0','stile1','stile2','stile3','stile4','stile5','sti-
content_image = tf.image.resize(content_image,
le6','stile7','stile8','stile9','stile10','stile11']
[784,784], preserve_aspect_ratio=True)
for i in range(12):
try:
L'immagine di contenuto, così come le immagini degli stili,
style_image = plt.imread(titles[i]+'.jpg')
deve essere contenuta nella stessa cartella in cui si trova
style_image = style_image.astype(np.float32)[np.newa-
salvato lo script. Carichiamo quindi l'immagine di conte-
xis, ...] / 255.
nuto nella variabile content_image ed eseguiamo alcune
operazioni di pre-processing. In particolare: style_image = tf.image.resize(style_image, [256,256],
• cambiamo il tipo di dati convertendolo in float a 32 preserve_aspect_ratio=True)
bit, astype(np.float32) style_image = tf.nn.avg_pool(style_image, ksize=[3,3],
• aggiungiamo una dimensione (np.newaxis) per strides=[1,1], padding='SAME')
rendere l'input un tensore a 4 dimensioni [batch, outputs = hub_module(tf.constant(content_image),
altezza, larghezza, canali]. Le componenti altezza tf.constant(style_image))
e larghezza si riferiscono alle dimensioni dell'im- stylized_image = outputs[0]
magine, canali è pari a 3 essendo l'immagine a plt.imsave('z_'+titles[i]+'.png',tf.squeeze(stylized_ima-
colori (RGB) ed infine batch è pari ad 1 rappresen- ge).numpy())
tando il lotto di immagini che alimentano la rete di except:
volta in volta.
continue
• Normalizziamo i valori dei pixel compresi tra 0 e
66 - Firmware 2.0
All'interno della lista titles definiamo i nomi delle immagini CONCLUSIONI

di stile. Tradurre il contenuto semantico di un'immagine in uno
All'interno del ciclo for eseguiamo le operazioni di pre-pro- stile diverso è un compito difficile di elaborazione delle
cessing, sull'immagine di stile, identiche a quelle eseguite immagini.
sull'immagine di contenuto.
Grazie alle reti neurali convoluzionali è possibile separare
Assegniamo quindi le due immagini, stile e contenuto, alla il contenuto di un'immagine dallo stile artistico con cui è
funzione hub.module() che fornirà in uscita l'immagine sti- stata prodotta.
lizzata stylized_image.
In questo modo è possibile ricombinare il contenuto di
Salviamo quindi le varie immagini stilizzate con il nome un'immagine e lo stile di un'altra, per produrre nuove im-
dello stile corrispondente, precedute però da z_. Le immagini di alta qualità percettiva che combinano il contenu-
magini verranno salvate nella cartella dove è stato salvato to di una fotografia con lo stile di numerose opere d'arte.
lo script.
ALLEGATI
for j in range(12+1):
Facendo click sul LINK è possibile scaricare una cartella
try: con lo script in Python e le immagini di stile.
img = mge.imread('z_'+titles[j-1]+'.png')
plt.subplot(3,4,j) RIFERIMENTI
plt.imshow(img) "Fast Neural Style Transfer in 5 Minutes with TensorFlow

Hub & Magenta" Orhan G. Yalçın, towardsdatascience.
plt.title(titles[j-1])
com
plt.axis('off')
"Exploring the structure of a real-time, arbitrary neural
except:
artistic stylization network", Golnaz Ghiasi, Honglak Lee,
continue Manjunath Kudlur, Jonathon Shlens, Vincent Dumoulin
plt.show() "Image Style Transfer Using Convolutional Neural Networ-

print('FINITO!') ks", Leon A. Gatys, Alexander S. Ecker, Matthias Bethge
Figura 2 tratta da "Image Style Transfer Using Convolutio-

nal Neural Networks"
Infine l'ultimo ciclo serve a visualizzare le immagini stiliz- Figura 3 tratta da "Exploring the structure of a real-time,
zate in un unico plot. arbitrary neural artistic stylization network"
Il risultato che si ottiene viene mostrato in Figura 4.
Per ogni immagine stilizzata è presente, nell'angolo in alto
a sinistra, la corrispondente immagine di stile.
Poiché l'algoritmo di estrazione dello stile è derivato da

quello per l'estrazione delle texture, il modello offre ottimi
risultati nei casi di pattern che si ripetono (stile5 ad esem- direttamente all’articolo sul Blog e partecipare alla discussione:
pio). https://it.emcelettronica.com/come-trasferire-uno-stile-
Nei casi come lo stile 0, 2 o 3, ad alcuni osservatori potreb- pittorico-su-una-fotografia-con-python
be venire il dubbio che si tratti di un'opera fatta a mano.
Firmware 2.0 - 67
L’APPRENDIMENTO
AUTOMATICO
APPLICATO
ALL’ASTRONOMIA di Maila Agostini
La metodologia data-driven ha attirato molta attenzione recentemente nella comunità fisica. Questo non è
sorprendente poiché uno degli obiettivi fondamentali della fisica è quello di dedurre o scoprire le leggi della
fisica dai dati osservativi. Il rapido sviluppo della tecnologia dell'Intelligenza Artificiale fa sorgere la doman-
da se queste scoperte possano essere eseguite algoritmicamente dai computer. In questo articolo parlere-
mo del fisico Hong Qin, programmatore di un algoritmo di apprendimento che, da un insieme di dati osser-
vativi su un reticolo spaziale, usa la teoria di campo appresa da una AI per prevedere nuove osservazioni.
L'approccio di apprendimento delle teorie di campo discrete supera le difficoltà associate all'apprendimen-
to delle teorie continue da parte dell'Intelligenza Artificiale e predice correttamente altre orbite planetarie
del Sistema Solare, senza necessità di imparare o conoscere le leggi del moto di Newton e la gravitazione
universale. Gli algoritmi proposti dovrebbero essere applicabili anche agli effetti della Relatività Speciale e
della Relatività Generale.
UN APPROCCIO NUOVO • Utilizzo di reti neurali per generare dati di campio-
L
'apprendimento automatico non è un concetto nuovo namento in insiemi statistici per il calcolo delle pro-
in fisica. In particolare, la connessione tra reti neurali prietà di equilibrio di sistemi fisici
artificiali e sistemi dinamici è nota da decenni.
Il problema affrontato in questo articolo appartiene a una
nuova categoria. Il metodo proposto "impara" una te-
“Qual è il nuovo contributo portato dallo studio del oria di campo da un dato insieme di dati di addestra-
professor Hong Qin del Princeton University Program
mento che consistono in valori di un campo fisico os-
in Fisica del Plasma?
servati in alcune posizioni spaziali. Le leggi della fisica
sono fondamentalmente espresse sotto forma di teorie di
La maggior parte delle attuali applicazioni delle tecniche campo, invece di equazioni differenziali.
di apprendimento automatico in fisica rientrano nelle se- Poiché le teorie di campo sono in generale più sempli-
guenti categorie: ci delle corrispondenti equazioni differenziali, l'apprendi-
• Usare le reti neurali per modellare processi fisici mento delle teorie di campo è più facile, il che è vero sia
complessi, come le interruzioni del plasma nei di- per l'intelligenza umana che per quella artificiale.
spositivi di fusione magnetica e lo stress effettivo A parte l'assunzione fondamentale che i dati osservativi
di Reynolds dovuto alla turbolenza sono governati dalle teorie di campo, gli algoritmi di ap-
• Risolvere equazioni differenziali in fisica matema- prendimento e di servizio proposti non presuppongono
tica approssimando le soluzioni con reti neurali alcuna conoscenza delle leggi della fisica, come la legge
• Scoprire funzioni sconosciute o parametri indeter- del moto di Newton e l'equazione di Schrödinger.
minati in equazioni differenziali Questo è diverso dalla maggior parte delle metodologie
68 - Firmware 2.0
L’APPRENDIMENTO AUTOMATICO APPLICATO ALL’ASTRONOMIA
discreta del sistema è la sommatoria delle

densità su tutte le celle della griglia.
A differenza della difficile situazione per l'ap-
prendimento di una teoria di campo conti-
nua, l'apprendimento di una teoria di campo
discreta è semplice.
Basta impostare un'approssimazione dell'a-
zione utilizzando una rete neurale o qualsiasi
altro schema di approssimazione adeguato.
Si possono applicare algoritmi differenziali
automatici, che sono stati ampiamente adot-
tati nelle reti neurali artificiali. Per addestra-
re la rete neurale o altra approssimazione,
sono disponibili metodi consolidati, tra cui
l'algoritmo di ricerca delle radici di Newton e
l'ottimizzatore di Adam.
Una volta che la densità è addestrata, la te-
oria di campo discreta appresa è pronta per
essere utilizzata per prevedere nuove osser-
vazioni.
Dopo aver specificato le condizioni al con-
Figura 1: Il reticolo spaziale come campo discreto
torno, l'equazione data per descrivere il pro-
blema viene risolta per il campo discreto.
esistenti di apprendimento automatico in fisica.
L'APPRENDIMENTO AUTOMATICO
GLI ALGORITMI DI AUTOAPPRENDIMENTO APPLICATO AL PROBLEMA DI KEPLERO
DELLE TEORIE DI CAMPO DISCRETE Come abbiamo visto, il problema di Keplero rappresenta
L'apprendimento di una teoria di campo discreta diretta- il moto di un corpo in un campo a forze centrali. In que-
mente dai dati di addestramento e il suo successivo uti- sto caso particolare, l'algoritmo di apprendimento impara
lizzo costituiscono un approccio interessante per la sco- la teoria di campo da un insieme di dati di orbite plane-
perta di modelli fisici da parte dell'Intelligenza Artificiale. tarie simili a quelle che Keplero ereditò da Tycho Brahe
L'algoritmo di apprendimento delle teorie di campo discre- nel 1601; si tratta quindi di misurazioni della parallasse
te appartiene alla famiglia degli algoritmi geometrici che planetaria, fenomeno per cui un oggetto sembra spostarsi
conservano la struttura, ed hanno dimostrato di essere rispetto allo sfondo se si cambia il punto di osservazione,
superiori agli algoritmi convenzionali basati sulla discretiz- accurate al minuto d'arco. Perché questo test nell'utilizzo
zazione delle equazioni differenziali. dell'algoritmo? Keplero impiegò 5 anni per scoprire la sua
L'efficacia del metodo e degli algoritmi sviluppati è dimo- prima e seconda legge del moto planetario, e altri 78 anni
strata utilizzando gli esempi di oscillazioni non lineari ed il prima che Newton risolvesse il problema kepleriano usan-
problema di Keplero, cioè il problema del moto di un corpo do le sue leggi del moto e della gravitazione universale.
in un campo di forze centrali. Appare evidente quindi come prevedere l'osservazione
Nel caso specifico gravitazionale, abbiamo in particolare possa aiutare a velocizzare la soluzione del problema.
che la forza centrale è direttamente proporzionale all’in- Per semplicità, i dati sono le orbite di Mercurio, Venere,
verso del quadrato della distanza. Terra, Marte, Cerere e Giove, generate risolvendo l'e-
Per una teoria di campo discreta, il campo è definito su un quazione del moto di Newton, per un pianeta nel campo
reticolo spaziale etichettato da due indici interi (i, j). Per gravitazionale del Sole, secondo la legge di gravitazione
semplicità, adottiamo un reticolo rettangolare mostrato in universale di Newton. Le lunghezze della scala di nor-
Figura 1. malizzazione spaziale e temporale sono rispettivamente
Il primo indice i identifica i punti della griglia temporale, e 1 a.u. e 58,14 giorni, e i passi temporali dei dati orbitali
il secondo indice j i punti della griglia spaziale. L'azione sono 0,05 giorni. Ricordiamo che l'obiettivo non è quello
Firmware 2.0 - 69
di riscoprire le leggi di Keplero del moto pla-

netario o le leggi di Newton del moto e della
gravitazione universale attraverso l'appren-
dimento automatico. Si tratta invece di alle-
nare una AI ad una teoria di campo discreta
dalle orbite visualizzate in Figura 2 per poi
prevedere nuove orbite planetarie.
Per modellare il problema si utilizza una
rete neurale completamente connessa con
due strati nascosti, ognuno dei quali ha 40
neuroni con la funzione di attivazione. La
rete è inizializzata in modo casuale con
una distribuzione normale, e poi addestra-
ta dall'ottimizzatore Adam fino a quando
la perdita media su un singolo punto della
griglia temporale è ridotta di un fattore 105
rispetto al suo valore iniziale. Partendo dalle
stesse condizioni iniziali delle orbite di ad-
destramento, l'algoritmo addestrato predice
le orbite tracciate con i marcatori rossi in Fi-
gura 3, rispetto alle orbite di addestramento
Figura 2: Le orbite di Mercurio, Venere, Terra, Marte, Cerere e Giove gene-
rate risolvendo l'equazione del moto di Newton per un pianeta nel cam- indicate dai marcatori verdi.
po gravitazionale del Sole secondo la legge di gravitazione universale di È degno di nota che la teoria del campo
Newton. Queste orbite sono i dati di allenamento per la teoria di campo discreto addestrata predice correttamente
discreta
le orbite di fuga paraboliche e iperboliche,
anche se le orbite di addestramento sono
tutte ellittiche, come si vede nelle Figure 2
e 3. Storicamente, Keplero sosteneva che
le orbite di fuga e le orbite ellittiche sono
governate da leggi diverse. Fu Newton che
scoprì la dipendenza da 1/r del campo gra-
vitazionale dalle leggi del moto planetario di
Keplero e unificò le orbite ellittiche e quelle
di fuga sotto la stessa legge fisica. I risulta-
ti mostrati nelle Figure 4 e 5 mostrano che
gli algoritmi di apprendimento automatico e
di servizio risolvono il problema di Keplero
in termini di previsione corretta delle orbite
planetarie senza conoscere o imparare le
leggi del moto di Newton e la gravitazione
universale.
Gli algoritmi sviluppati funzionano parti-
colarmente bene contro le variazioni delle
leggi della fisica, perché il metodo non ri-
chiede alcuna conoscenza delle sue leggi,
oltre all'assunzione fondamentale che le
Figura 3: Orbite di Mercurio, Venere, Terra, Marte, Cerere e Giove. Le orbite
leggi che governano il moto siano teorie di
indicate dai marcatori rossi sono generate dalla teoria del campo discre-
to appresa. Le orbite indicate dai marcatori verdi sono le orbite di allena- campo. Quando gli effetti della relatività
mento della Figura 2 speciale o generale sono importanti, ci
70 - Firmware 2.0
si aspetta che anche gli algoritmi siano

validi. Tuttavia, alcune note sono d'obbligo.
Esistono piccole discrepanze tra le previsio-
ni della teoria discreta del campo appresa e
le leggi di Newton nelle Figure 4 e 5. Questo
perché non sono fornite orbite di addestra-
mento in alcuni particolari raggi. Le orbite
previste lì sono quindi meno accurate. Per
comprendere ulteriormente l'effetto dei dati
di allenamento ridotti, si rimuove l'orbita di
Cerere dal set di dati di allenamento e poi
si applica l'algoritmo addestrato per preve-
dere le orbite iniziate dal perielio dell'orbita
terrestre come in Figura 4. Il risultato è mo-
strato in Figura 6, che mostra una maggio-
re deviazione dalla previsione delle leggi di
Newton rispetto alla Figura 4.
Le maggiori discrepanze sono comprensibi-
li perché, senza i dati orbitali di Cerere, ci
sono meno dati di allenamento che coprono
lo spazio. Questo indica che l'algoritmo ad-
Figura 4: Orbite iniziate al perielio dell'orbita terrestre. L'orbita e0 è l'or-
bita terrestre. Le orbite e1 ed e2 sono ellittiche, l'orbita p è l'orbita di fuga destrato non può interpolare accuratamente
parabolica e l'orbita h è l'orbita di fuga iperbolica. I marcatori rossi sono il campo gravitazionale nelle regioni senza
le previsioni della teoria del campo discreto allenata, e i marcatori blu dati di addestramento. D'altra parte, senza
sono le soluzioni secondo le leggi del moto di Newton e la gravitazione
alcuna assunzione fisica aggiuntiva, non
universale
c'è un modo unico per determinare il cam-
po gravitazionale in una regione senza dati
osservativi. Per esempio, questa regione
potrebbe essere vuota o potrebbero essere
presenti altri piccoli corpi celesti e modificare
il campo gravitazionale in quell'area. Questo
modello di rete neurale ha la flessibilità di im-
parare il campo gravitazionale nella regione,
qualunque esso sia, una volta che i dati di
allenamento nella regione sono disponibili.
Ma senza i dati di addestramento, il campo
gravitazionale nella regione è sotto-determi-
nato nel modello di rete neurale. Il calcolo
basato sulle leggi di Newton presuppone im-
plicitamente che la regione sia vuota. Da qui
le maggiori discrepanze. Inoltre, ricordiamo
che lo studio presentato vuole essere una
prova di principio. Fattori pratici, come il
rumore dei dati di allenamento e gli ef-
fetti dei tre corpi, non sono inclusi. Tut-
tavia, aggiungendo rumore gaussiano, con
media zero e deviazione standard 10-3, le
Figura 5: Orbite iniziate dal perielio dell'orbita di Mercurio. I marcatori e le orbite previste non vengono alterate. Il me-
etichette dei grafici sono simili a quelli della Figura 4 todo utilizzato per effettuare questa verifica
Firmware 2.0 - 71
Figura 6: L'effetto dei dati di allenamento ridotti. L'orbita di Cerere viene rimossa dai dati di allenamento. Le orbite simulate
sono le stesse della Figura 4. I marcatori rossi sono le previsioni della teoria del campo discreto addestrata, e i marcatori blu
sono le soluzioni secondo le leggi del moto di Newton e la gravitazione universale
è semplice; l'algoritmo fa passare i dati attraverso un filtro campo in fisica. È quindi ragionevole, suggerire che alcuni
passa-basso prima dell'addestramento ed i parametri del algoritmi di apprendimento automatico siano ciò che l'uni-
filtro sono variati per minimizzare la funzione di perdita. verso discreto, cioè la simulazione del computer, esegue
L'errore risultante non è trascurabile ed è auspicabile mi- per minimizzare le azioni.
gliorare la precisione del modello di apprendimento auto-
matico contro il rumore. Nota: le immagini presenti nell'articolo sono tratte dal la-
voro originale del professor Hong Qin, "Machine Learning
CONCLUSIONI and serving of discrete field theories".
È stato a lungo teorizzato, fin dallo studio di Euclide sugli
specchi e l'ottica, che come legge fondamentale della fi-
sica, tutto ciò che la natura fa è minimizzare certe azioni. BIBLIOGRAFIA
Ma come fa la natura a farlo? "Machine Learning and serving of discrete field theories",
Gli algoritmi di apprendimento automatico e di servizio Hong Qin
delle teorie di campo discrete proposte potrebbero fornire
un indizio, incorporando il concetto base dell'ipotesi di si-
mulazione di Bostrom.
L'ipotesi della simulazione afferma che l'universo fisico è
una simulazione al computer; non si tratta di fantascienza, direttamente all’articolo sul Blog e partecipare alla discussione:
ma potrebbe trattarsi della realtà. https://it.emcelettronica.com/lapprendimento-automatico-
Se l'ipotesi fosse vera, allora lo spaziotempo sarebbe applicato-allastronomia
necessariamente discreto. Lo stesso vale per le teorie di
72 - Firmware 2.0
AVNET ABACUS
RICEVE IL PREMIO
HARWIN “EUROPEAN
DISTRIBUTOR OF THE
YEAR 2021” di Giordana Francesca Brescia
Avnet Abacus, distributore specializzato in prodotti di interconnessione, passivi, elettromeccanici, di ali-

mentazione e batterie, ha annunciato di aver ricevuto il premio “European Distributor of the Year 2021” da
Harwin, leader riconosciuto a livello globale per le soluzioni di interconnessione a elevata affidabilità.
A
vnet Abacus è una business unit regionale di nel “5 Star Awards” di Harwin, che ha visto protagonisti
Avnet, con headquarters europei in Belgio. L’ec- due importanti riconoscimenti individuali all’interno del
cezionale servizio clienti, il know-how tecnico ed i team Avnet Abacus, premiati per aver ottenuto risulta-
progetti chiave realizzati, hanno consentito ad Avnet Aba- ti estremamente meritevoli nel supportare il business di
cus di raggiungere la prima posizione per il 2021 nella rete Harwin.
di distribuzione europea di Harwin. Avnet Abacus è anche Grazie all’importante attenzione che riserva al servizio
una delle società leader in Europa nella distribuzione di clienti, all’eccellente supporto tecnico e all’eccezionale
prodotti d'interconnessione, componenti passivi, di- collaborazione con Harwin, Avnet Abacus è stata in gra-
spositivi elettromeccanici e unità di potenza. Quest’ul- do, ancora una volta, di rafforzare la propria posizione di
timo premio segue il recente successo di Avnet Abacus distributore numero 1 in tutta la rete EMEA di Harwin per il
2021. Avnet Abacus distribuisce un ampio portfolio di pro-
dotti di interconnessione ad elevata affidabilità a marchio
Harwin, per utilizzi in mercati emergenti che includono
IoT, aerospazio/difesa, oltre a soluzioni di schermatura
EMC.
INFORMAZIONI&RIFERIMENTI
www.overcomm.it/newsroom
www.avnet-abacus.eu
www.avnet.com

https://it.emcelettronica.com/avnet-abacus-riceve-il-
premio-harwin-european-distributor-of-the-year-2021
Firmware 2.0 - 73
RILEVAMENTO DELLE
INTRUSIONI SU RETE
CAN-BUS CON TINYML di Andrea Garrapa
Le reti neurali e l'apprendimento automatico in generale, rappresentano oggi una delle maggiori aspetta-
tive per la realizzazione di modelli che possano determinare il comportamento e il funzionamento di diversi
sistemi fisici. Indubbiamente le risorse di calcolo necessarie per l'addestramento e la realizzazione del mo-
dello sono elevate, soprattutto in funzione della grande quantità di dati necessari per rilevare i parametri sa-
lienti del modello. Allo stesso tempo, però, i modelli così ottenuti possono essere integrati su sistemi embed-
ded, grazie alle tecnologie TinyML, permettendo di operare esattamente dove i fenomeni fisici avvengono. In
questo articolo presentiamo un lavoro di ricerca in cui viene utilizzato un framework per l'implementazione
di modelli di reti neurali su famiglie di microprocessori per l'automotive, dimostrando la loro efficienza nel
rilevamento delle intrusioni su una rete di comunicazione CAN-bus.
INTRODUZIONE controllo del motore alla gestione dei diversi dispositivi di
I
l Machine Learning (ML) sta rivoluzionando il modo in bordo. In questo articolo presentiamo un lavoro di ricerca
cui comprendiamo il mondo, permettendoci di ottenere in cui, grazie ad un framework per l'implementazione di
informazioni da grandi quantità di dati che non possono modelli NN su microprocessori della famiglia automotive,
essere analizzate dal cervello umano. I dati prodotti da viene dimostrata la loro efficienza e prestazione per appli-
noi o dai nostri dispositivi, vengono raccolti da sensori, e cazioni come la stima del traffico dati su Controller Area
richiedono grandi quantità di risorse in termini di potenza Networks (CAN) all'interno del veicolo.
di elaborazione per essere gestiti e analizzati. In questa
direzione la ricerca negli ultimi anni ha indagato una vasta CONCETTI BASE
gamma di tecniche ML: reti neurali (NN), Deep Learning I veicoli moderni stanno diventando prodotti molto com-
(DL), clustering, Reinforcement Learning (RL) e così via. plessi e dozzine di unità di controllo elettronico (ECU)
Tuttavia, un segmento di ricerca sempre più importante interagiscono tra loro per eseguire le più svariate funzio-
riguarda la distribuzione di modelli ML su unità microcon- ni. In un sistema di comunicazione a bordo di un veico-
trollore (MCU). Questi dispositivi vengono spesso utiliz- lo le diverse sottoreti, divise per funzionalità, sono tutte
zati per elaborare le informazioni e prendere decisioni in interconnesse tramite un gateway. Per avere un quadro
loco senza ricorrere a potenti mainframe. Una delle ca- completo, ogni ECU è interconnessa tramite un bus, il
ratteristiche principali del settore automotive è che la ca- CAN-bus: una soluzione semplice ma efficace al proble-
pacità di calcolo deve essere localizzata sui processori ma di interconnessione di ECU che soddisfa i requisiti di
presenti nelle ECU e quindi i modelli ML devono essere comunicazione in tempo reale e implementazione a basso
facilmente discretizzati e codificati per queste unità di cal- costo. CAN-bus è lo standard di fatto per le interconnes-
colo. Diventa quindi importante concentrarsi sul fatto che sioni di ECU di diverse sottoreti, divise per funzionalità, e
lo scopo delle architetture tinyML è analizzare i dati men- interconnesse per mezzo di gateway (Figura 1).
tre vengono prodotti, mentre l'intera fase di addestramen- I produttori automotive devono progettare attentamente le
to e la realizzazione del modello sono delegate a sistemi interconnessioni tra sottoreti per cercare di impedire un
con più alte prestazioni. Inoltre, occorre tenere a mente tentativo di aggressione volto ad acquisire il controllo da
che i dispositivi elettronici di bordo devono svolgere an- remoto di una ECU tramite una falla nella sicurezza, ad
che le funzioni primarie per le quali sono progettati, dal esempio nel sistema di infotainment (tramite Bluetooth,
74 - Firmware 2.0
RILEVAMENTO DELLE INTRUSIONI SU RETE CAN-BUS CON TINYML
Figura 1: Esempio di sistema di comunicazione a bordo
Wi-Fi). È stato dimostrato che è possibile attaccare la rete con la giusta qualità. In questo articolo viene descritta una
CAN disabilitando ad esempio l'impianto frenante utiliz- versione originale di questo approccio che può essere in-
zando la connessione cellulare in più veicoli. I ricercatori corporato nelle MCU.
hanno già riscontrato alcune vulnerabilità nel CAN-bus:
• È un protocollo di messaggistica multicast con SPC5-STUDIO.AI
nessun meccanismo intrinseco di indirizzamento e SPC5-Studio.AI è un componente plug-in dell'ambiente di
autenticazione. In altre parole, una ECU hackerata sviluppo integrato SPC5-STUDIO che supporta la famiglia
può "ascoltare" ogni messaggio della sua sottore- di MCU per applicazioni automotive SPC58 "Chorus". L'I-
te e può inviare messaggi con un'identità falsa DE fornisce la capacità di generare, eseguire e convalida-
• È un protocollo con larghezza di banda limitata per re automaticamente modelli NN pre-addestrati su MCU di
i veicoli di oggi, il che rende difficile l'introduzione livello automobilistico. Esso produce un'efficiente libreria
della crittografia del messaggio “ANSI C” che può essere compilata, installata ed eseguita
• La maggior parte dei nodi sono MCU di livello au- su MCU SPC58. Framework DL, come Keras, TensorFlow
tomotive con limitate capacità di memoria e calco- Lite, ONNX, Lasagne, Caffe, ConvNetJS sono supportati.
lo e questo rende difficile l'implementazione di un Le librerie possono essere integrate nei progetti grazie a
protocollo di sicurezza complesso un numero breve e ben definito di API pubbliche. Inoltre,
fornisce strumenti di validazione e analisi delle prestazioni
L'introduzione di un IDS (Intrusion Detection System) che consentono di validare e caratterizzare la rete neurale
può essere una contromisura adatta per la vulnerabilità convertita, misurandone le metriche chiave come errore
del CAN-bus. Uno dei metodi di rilevamento delle intru- di validazione, requisiti di memoria (Flash e RAM), e tem-
sioni è l'approccio basato sull'anomalia. Una descrizione po di esecuzione direttamente sull'MCU. Questo plug-in
intuitiva di questo metodo consiste nel considerare un è integrato all'interno di SPC5-STUDIO. SPC5-Studio.AI
sistema di monitoraggio, una ECU, che ascolti il traffico è stato utilizzato, nella ricerca, per integrare e convalida-
del CAN-bus per apprendere il comportamento normale. re il modello di rete neurale su tre MCU di grado auto-
Le attività dell'intruso generano traffico anomalo e que- mobilistico, adatte per applicazioni che richiedono bassa
sto mette in guardia l'IDS addestrato. Al giorno d'oggi una potenza, connettività e sicurezza: SPC584B, SPC58EC e
delle promesse più allettanti legate a DL è la capacità di SPC58NH. Le caratteristiche tecniche principali delle
addestrare le NN fornendo una quantità adeguata di dati MCU scelte vengono mostrate nella Tabella 1.
Firmware 2.0 - 75
Tabella 1: Principali caratteristiche delle MCU appartenenti alla famiglia SPC58
Figura 2: Struttura di un data frame CAN
Il consumo di energia è stato calcolato considerando ogni attacco.

MCU operante alla sua massima frequenza e con tutti i Il set di dati è composto da segnali di traffico normali e
core abilitati. anomali, questi ultimi suddivisi in base al tipo di attacco:
1. Attacco Plateau - un segnale sovrascritto con un
IDS PER CAN-BUS valore costante su un periodo di tempo
Andremo adesso a descrivere un Autoencoder Long 2. Attacco a cambiamento continuo - un segnale
Short-Term Memory (LSTM), utilizzato per riconoscere le si allontana lentamente dal suo vero valore
anomalie sul CAN-bus generate dal traffico fuori norma, 3. Attacco Playback - una già registrata serie tem-
utilizzando il dataset SynCAN. L'Autoencoder pre-adde- porale di valori dello stesso segnale, su un periodo
strato è stato incorporato nelle tre diverse MCU automo- di tempo
bilistiche tramite SPC5-STUDIO-AI, ed è stato quindi con- 4. Attacco soppressivo - un segnale completamen-
validato per poi profilare la sua complessità. te soppresso
5. Attacco alluvionale - un segnale per negare l'ac-
IL DATASET cesso alle altre ECU
Un pacchetto CAN è costituito da un timestamp, un ID
identificativo e 8 byte di payload. Il pacchetto viene tra- Il rilevatore di anomalie sviluppato è stato addestrato sui
smesso sul bus e il campo di identificazione rappresenta il segnali di traffico normale, e quindi testato su quelli di traf-
tipo di messaggio. Il payload può portare uno o più segnali fico anomalo, corrispondenti agli attacchi.
significativi.
Pertanto, il traffico del bus in una sottorete può essere L'AUTOENCODER LSTM
rappresentato da serie temporali di segnali. La Figura Un Autoencoder è un modello di rete neurale che cerca di
2 mostra la struttura di un data frame CAN. apprendere una rappresentazione compressa di un input.
I dati per l'analisi sono stati presi da SynCAN, un set di Sono metodi di apprendimento non supervisionato, anche
dati artificiale creato per confrontare, valutare e compa- se tecnicamente vengono addestrati utilizzando metodi di
rare diversi IDS per CAN-bus rispetto a diversi scenari di apprendimento supervisionato, denominati auto-supervi-
76 - Firmware 2.0
coder per sequenze dati utilizzando

un'architettura LSTM Encoder-De-
coder. Per un determinato dataset
di sequenze, un codificatore-deco-
dificatore LSTM è configurato per
leggere la sequenza di input, codi-
ficarla, decodificarla e ricrearla. Le
prestazioni del modello vengono va-
lutate in base alla capacità del mo-
dello di ricreare la sequenza di input.
Una volta che il modello raggiunge
il livello di prestazioni desiderato
ricreando la sequenza, la parte de-
codificatore del modello può essere
rimossa, lasciando solo il modello
codificatore. Questo modello può
quindi essere utilizzato per codifi-
care sequenze di input in un vettore
di lunghezza fissa. I vettori risultanti
Figura 3: Errore di ricostruzione dell'Autoencoder LSTM rispetto al dataset di ogni
tipologia di attacco. In verde il traffico normale sul CAN-bus, in rosso il traffico
possono quindi essere utilizzati in
anomalo una varietà di applicazioni, non da
ultimo come rappresentazione com-
pressa della sequenza come input
sionati. In genere, vengono addestrati come parte di un per un altro modello di apprendimento supervisionato.
modello più ampio che tenta di ricreare l'input. Esistono L'obiettivo di un Autoencoder è apprendere una rappre-
molti tipi di Autoencoder e il loro utilizzo varia, ma forse sentazione latente per un insieme di dati utilizzando la
l'uso più comune è come modello di estrazione delle ca- codifica e la decodifica. In questo modo, la rete neurale
ratteristiche. I problemi di previsione di sequenze sono apprende le caratteristiche più importanti dei dati. Dopo
impegnativi, anche perché la lunghezza della sequenza la decodifica, possiamo confrontare l'input con l'output ed
di input può variare. Ciò è impegnativo perché gli algo- esaminare la differenza. Se c'è una grande differenza (la
ritmi di apprendimento automatico, e in particolare le reti perdita di ricostruzione è alta), possiamo presumere che il
neurali, sono progettati per funzionare con input di lun- modello abbia faticato a ricostruire i dati, quindi possiamo
ghezza fissa. Un'altra sfida con le sequenze è che l'ordine sospettare di essere in presenza di un'anomalia. L'Auto-
temporale delle osservazioni può rendere difficile estrarre encoder implementato nel lavoro di ricerca è costituito da
caratteristiche adatte all'uso come input per modelli di ap- uno strato denso, due livelli LSTM e un livello di output
prendimento supervisionato, spesso richiedendo una pro- denso. Si alimenta per 24 consecutivi messaggi relativi al
fonda esperienza nel dominio o nel campo dell'elaborazio- traffico di rete di 20 segnali diversi. Quindi, i dati di input
ne del segnale. Le reti neurali ricorrenti, come la LSTM, sono forniti nel formato tridimensionale: numero di cam-
sono specificamente progettate per supportare sequenze pioni, fasi temporali (24) e caratteristiche (20). Gli strati
dati di input. Sono in grado di apprendere le complesse LSTM hanno 18 unità di output e lo strato di output denso
dinamiche all'interno dell'ordinamento temporale delle se- è costituito da 20 nodi. La rete risulta composta da 6272
quenze di input, nonché di utilizzare una memoria interna parametri.
per ricordare o utilizzare le informazioni attraverso lunghe
sequenze di input. La rete LSTM può essere organizza- PERFORMANCE
ta in un'architettura denominata Encoder-Decoder LSTM Gli iperparametri della rete sono stati regolati utilizzando
che consente di utilizzare il modello sia per supportare Keras-Tuner. Il punteggio dell'anomalia è stato valutato
sequenze di input a lunghezza variabile sia per prevedere utilizzando la media dell'errore assoluto (MAE) tra il vero
o produrre sequenze di output a lunghezza variabile. Un traffico di rete e la sua ricostruzione, prodotta dall'Autoen-
Autoencoder LSTM è un'implementazione di un Autoen- coder. La Figura 3 mostra l'errore di ricostruzione (MAE)
Firmware 2.0 - 77
A causa della sua maggio-

re complessità, lo strato
LSTM risulta il più oneroso
per tutti e tre i parametri di
valutazione.
CONCLUSIONE
In questo articolo abbiamo
descritto l'implementazio-
ne tramite ML di un siste-
ma di rilevamento delle
intrusioni (IDS) per CAN-
bus. Il modello addestrato
offline è stato quindi con-
vertito per essere imple-
mentato su una famiglia di
MCU specifiche per l'auto-
motive. L'accuratezza del
modello è stata valutata
Figura 4: Percentuali di memoria Flash, RAM e di tempo di esecuzione medio necessari ad
ogni strato dell'Autoencoder LSTM utilizzando un appropriato
set di dati su cui è stato sti-
mato l'errore, dimostrando
l'efficacia dell'algoritmo.
L'aspetto innovativo del
lavoro di ricerca è stata
la definizione di alcune
metriche utili per valutare
i consumi energetici ed il
calcolo delle prestazioni
del modello durante la sua
Tabella 2: Flash, RAM e tempo di inferenza medio richiesti dall'Autoencoder LSTM, per ogni
MCU scelta esecuzione su MCU. Un
futuro lavoro riguarderà
l'attuazione del modello
ottenuto su ciascun dataset relativo al tipo di attacco. tenendo conto dei requisiti di sicurezza richiesti per le ap-
La situazione di traffico normale sul bus CAN viene rap- plicazioni automobilistiche integrate.
presentata in verde, mentre in rosso quella anomala. Per
tutte le tipologie di attacco, la precisione media e il richia-
mo risultano rispettivamente 0,86 e 0,81. RIFERIMENTI
Passando alla valutazione delle prestazioni con le MCU "Characterization of Neural Networks Automatically Map-
di livello automobilistico (SPC584B, SPC58EC e SPC- ped on Automotive-grade Microcontrollers"
58NH), il plug-in AI di SPC5-STUDIO ha consentito l'a-
nalisi delle prestazioni in termini di memoria Flash (Kb)
occupata, memoria RAM (Kb) utilizzata e tempo medio di
inferenza (ms), riportati in Tabella 2.
Solo il tempo medio di inferenza differisce tra le MCU poi-
ché diminuisce linearmente all'aumentare della frequenza direttamente all’articolo sul Blog e partecipare alla discussione:
di clock. Le percentuali di Flash, RAM e tempo medio di https://it.emcelettronica.com/rilevamento-delle-intrusioni-
esecuzione sono mostrate in Figura 4, per ogni strato su-rete-can-bus-con-tinyml
del modello.
78 - Firmware 2.0
COME DISCRIMINARE
GLI ASINTOMATICI
COVID DA UN COLPO
DI TOSSE di Andrea Garrapa
I ricercatori del MIT hanno ipotizzato che i soggetti affetti da COVID-19, in particolare gli asintomatici, po-
trebbero essere accuratamente discriminati per mezzo di un colpo di tosse forzato utilizzando una AI nel
telefono cellulare. Da questa idea si potrebbe creare uno strumento di screening per gli asintomatici positivi
al COVID-19, gratuito, non invasivo, su larga scala, in tempo reale, in grado di migliorare gli approcci attuali
nel contenere la diffusione del virus. I casi d'uso pratici potrebbero essere lo screening quotidiano di studenti,
lavoratori e la riapertura del trasporto pubblico o i test per trovare rapidamente i focolai. In questo articolo
vedremo il modello di Intelligenza Artificiale progettato dal MIT, le fasi di addestramento e i risultati ottenuti.
INTRODUZIONE 5.320 divise equamente tra positivi al COVID-19
M
an mano che il virus si diffonde nei vari paesi che e negativi.
non possono permettersi test giornalieri a livel- • Per affrontare la strategia di modellazione, i ri-
lo nazionale né confinamento, una preselezione cercatori si sono ispirati alla loro precedente ricer-
su larga scala, a basso costo e accurata potrebbe essere ca sull'Alzheimer. Tale scelta trova giustificazione
uno strumento essenziale per dare la priorità ai test rapidi dalla crescente evidenza dei sintomi riportati da
e prevenire localmente i focolai. Recentemente, sono stati pazienti affetti da COVID-19, che hanno subito
diversi gli approcci AI proposti per supportare la gestione menomazioni neurologiche come la perdita dell'ol-
della pandemia. Un test per la tosse con Intelligenza Artifi- fatto durante e dopo l'infezione. Dopo aver prova-
ciale fornirebbe qualche vantaggio che potrebbe compen- to senza successo alcuni modelli CNN di base,
sare parzialmente i problemi esistenti con i test biologici. la connessione tra COVID-19 e cervello ha por-
I vantaggi dei test mediante AI includono: non invasività, tato gli sforzi di modellazione verso il framework
risultati in tempo reale, zero costi variabili e accessibilità OVBM (Open Voice Brain Model), già applicato
per tutti. alla diagnosi dell'Alzheimer con una precisione del
Come ogni approccio AI mediante Deep Learning, si ren- 93,8%. Il framework OVBM identifica i biomarcato-
dono necessari dei dati di addestramento e una strate- ri acustici utili per la diagnostica.
gia di modellazione.
• Per la componente dati è stato avviato un crowd- DATASET
sourcing mondiale per raccogliere campioni audio Nell'aprile 2020 è stata avviata una raccolta di dati sulla
della tosse forzata di persone affette da COVID-19, tosse a livello mondiale attraverso il motore di registrazio-
insieme a 10 domande a risposta multipla relative ne del sito web (opensigma.mit.edu). L'obiettivo era quello
alla diagnosi della malattia ed ai sintomi rilevanti. di creare il dataset MIT Open Voice per la discriminazione
Il MIT Open Voice COVID-19 Cough dataset rap- dei positivi al COVID-19 attraverso la tosse.
presenta il più grande set di dati audio sulla salute Sono state raccolte per ogni soggetto le seguenti infor-
con diverse centinaia di migliaia di registrazioni di mazioni:
colpi di tosse. Tra queste sono state selezionate • registrazioni audio di colpi di tosse di lunghezza
Firmware 2.0 - 79
COME DISCRIMINARE GLI ASINTOMATICI COVID DA UN COLPO DI TOSSE
Figura 1: Panoramica dell'architettura del discriminatore COVID-19 attraverso le registrazioni della tosse come input e dia-
gnosi di positività o negatività al virus come output
variabile (in media 3 per soggetto) 1. diagnosi eseguita negli ultimi 7 giorni
• 10 domande a risposta multipla relative alla dia- 2. insorgenza dei sintomi non più in là di 20 giorni con
gnosi della malattia sintomi continuati fino alla cattura del campione
• informazioni generali come età, sesso, paese, re-
gione L'audio della tosse forzata del soggetto e i risultati dia-
• la data e il risultato della eventuale diagnosi me- gnostici sono stati utilizzati per addestrare e convalidare il
dica fatta e se la fonte della diagnosi era un test discriminatore COVID-19. Nello specifico, 4256 campioni
ufficiale, una valutazione medica o una valutazio- (80%) sono stati utilizzati per la fase di addestramento e
ne personale 1064 (20%) per la fase di validazione.
• informazioni sui sintomi e numero di giorni dalla
loro comparsa. I sintomi includevano febbre, stan- ARCHITETTURA DEL MODELLO
chezza, mal di gola, difficoltà a respirare, dolore L'architettura utilizzata (Figura 1) riceve in ingresso una
persistente o pressione al petto, diarrea e tosse registrazione con uno o più colpi di tosse, eseguendo due
fasi di pre-elaborazione su di essa e la inserisce in un
Il motore di registrazione è stato reso disponibile su vari modello basato su CNN per produrre in uscita una dia-
browser e dispositivi, riducendo così ogni possibile bias gnostica di pre-screening.
specifico del dispositivo. I dati resi anonimi prima di esse- Come pre-elaborazione, ogni registrazione in ingresso è
re raccolti su un server sicuro. I campioni sono stati sal- suddivisa in segmenti audio (audio chunks) da 6 secondi,
vati senza compressione in formato WAV (bit rate 16kbs, elaborati con il blocco MFCC e successivamente passati
canale singolo, codec opus). Nessuna segmentazione è al biomarcatore. L'output di questi passaggi diventa l'in-
stata eseguita sulle registrazioni utilizzate per addestra- put per la rete CNN. L'architettura della CNN è composta
re e testare. Sono stati utilizzati tutti i campioni relativi ai da tre ResNet50 in parallelo.
positivi al COVID-19 presenti nel set di dati e selezionati Lo strato di output del tensore di ciascun modello Re-
casualmente lo stesso numero di soggetti negativi al CO- sNet50 è concatenato in parallelo. Nei modelli di base,
VID-19 per una distribuzione equilibrata. Sono stati utiliz- questi ResNet50 non sono pre-addestrati. Nel modello
zati solo campioni rispondenti a due condizioni: con le migliori prestazioni, sono pre-addestrati per l'ac-
80 - Firmware 2.0
Tabella 1: La selezione dei soggetti COVID-19 non è equilibrata nei termini di nessuna statistica demografica specifica. I po-
sitivi risultano per il 41,8% essere uomini, per il 53,0% donne e per l'8,9% altro; questo perché tali sono le percentuali rispetto
al totale dei partecipanti volontari. Pertanto, le percentuali riflettono il campione e quindi la migliore stima delle prestazioni
complessive se uno screening fosse effettuato su base volontaria su larga scala. La colonna "Hit" mostra l'accuratezza del
modello per ogni rispettivo sottogruppo. Le 3 categorie a fine tabella (valutazione personale, dottore e ufficiale) corrispondo-
no alla fonte della diagnosi inserita da ciascun soggetto
quisizione delle caratteristiche acustiche dei biomarcatori Tali biomarcatori sono: il degrado muscolare, i cambia-
2,3 e 4. L'output di questi tre tensori concatenati è allora menti nelle corde vocali, i cambiamenti nell'umore e quelli
raggruppato utilizzando uno strato 2D di Global Average nei polmoni e nel tratto respiratorio.
Pooling, seguito da uno strato di rete neurale con 1024
neuroni profondamente connesso (denso) con attiva- BIOMARCATORE 1 (DEGRADO MUSCOLARE)
zione ReLU e infine un strato binario denso con attivazio- Seguendo i modelli di decadimento della memoria, sono
ne sigmoidea. state introdotte le caratteristiche di affaticamento musco-
I risultati presentati nella Tabella 1 si basano esclusiva- lare e degrado modificando i segnali di ingresso, per en-
mente sull'uscita relativa al primo segmento audio. trambi i set di addestramento e test, mediante Masche-
ra di Poisson.
BIOMARCATORI Il decadimento di Poisson è una distribuzione comune in
L'architettura utilizza quattro biomarcatori precedente- natura che è stata precedentemente utilizzata per model-
mente testati per il rilevamento dell'Alzheimer ed ispirati lare la degradazione muscolare.
dalle scelte della comunità medica. Rimuovendo questo biomarcatore il tasso di errore in
Firmware 2.0 - 81
Figura 2: (a) L'asse x riporta il numero di strati per ogni biomarcatore necessari per superare l'accuratezza del modello base.
Minore è questo valore, maggiore sarà la rilevanza del biomarcatore nel modello completo. (b) La parte bianca delle barre
mostra le prestazioni ottenute quando il modello del biomarcatore della tosse è incorporato; pre-training indica l'addestra-
mento individuale dei modelli dei biomarcatori prima di integrarli nell'architettura multimodale
previsioni ufficiali raddoppia. pressione polmonare necessaria per iniziare e mantenere

Per catturare l'influenza del degrado muscolare nelle pre- l'oscillazione delle corde vocali e la fatica vocale.
visioni individuali, è stata sviluppata una metrica di degra- Pertanto, un modello di biomarcatore delle corde voca-
dazione muscolare basata sul confronto dell'output con e li potrebbe rilevare cambiamenti nelle caratteristiche di
senza la maschera di Poisson iniziale. base dei suoni delle corde vocali in un discorso continuo.
Questa metrica è il rapporto normalizzato della previsione Sviluppando un modello Wake Word per un suono uni-
con e senza maschera. versale quale "mmmmmm" è stata addestrata la seconda
La maschera di Poisson M applicata su un punto (Ix) ResNet50 per discriminare la parola "Them" da altre.
MFCC della registrazione viene calcolata moltiplicando Per l'addestramento è stato usato LibriSpeech, un data-
questo valore per un valore casuale della distribuzione di set di audiolibri con circa 1.000 ore di discorsi.
Poisson Poiss() di parametri Ix e λ, dove λ è la media di Utilizzando un set campione bilanciato di 11.000 pezzi au-
tutti i valori in MFCC. dio da due secondi, metà contenenti la parola chiave e
metà senza di essa, è stata raggiunta una precisione di
M(Ix) = Poiss(λ) · Ix dove Poiss(X = k) = (λk e-k)/k! convalida dell'89%.
Le caratteristiche apprese da questo biomarcatore con-
BIOMARCATORE 2 (CORDE VOCALI) sentono il rilevamento delle variazioni nelle corde vocali
I soggetti con malattie polmonari hanno spesso distinte esistenti tra soggetti COVID-19 e di controllo, discriminan-
espressioni dei biomarcatori delle corde vocali rispetto ai do il 54% del set di prova.
soggetti sani. Per il 19% dei soggetti, questo si è dimostrato l'unico bio-
Alcuni studi hanno riportato la correlazione tra la minima marcatore in grado di discriminarli correttamente.
82 - Firmware 2.0
BIOMARCATORE 3 (UMORE) destrate dei modelli di biomarcatore. Perciò, il modello di

Gli studi hanno evidenziato un declino cognitivo nei pa- base ha lo stesso numero esatto di neuroni e pesi ma
zienti COVID-19 e le prove cliniche supportano l'impor- viene inizializzato in modo casuale invece che con modelli
tanza dei sentimenti nella diagnosi precoce del declino di pre-training.
neurodegenerativo. Dalla Figura 2a appare che il biomarcatore dei polmoni e
Diversi contesti clinici enfatizzano sentimenti, come dub- delle vie respiratorie richiede pochissimi strati per essere
bio o frustrazione quali possibili indicatori neurodegene- messo a punto e così battere l'accuratezza del modello
rativi. di base, sottolineando la rilevanza delle caratteristiche
Per ottenere un biomarcatore che rilevi questo declino, pre-addestrate.
è stato addestrato un modello di classificazione per ap- Il marcatore umorale, invece, richiede il riaddestramen-
prendere le caratteristiche umorali dal dataset vocale to di molte features per superare il modello di base, di-
RAVDESS, che include diversi attori che intonano in 8 sta- mostrando che sebbene le caratteristiche pre-addestrate
ti emotivi: neutro, calmo, felice, triste, arrabbiato, pauroso, apportino valore, potrebbero essere meno strettamente
disgustato e sorpreso. correlate.
Una terza ResNet50 addestrata su campioni di 3 secon- La Figura 2b mostra la perdita di prestazioni quando un
di per la classificazione delle 8 intonazioni ha raggiunto modello di biomarcatore viene rimosso.
una precisione di convalida del 71%. Rispetto al biomarcatore umorale, il biomarcatore delle
corde vocali contribuisce il doppio in termini di accuratez-
BIOMARCATORE 4 (POLMONI E VIE za del rilevamento.
RESPIRATORIE)
L'ascolto dei polmoni mentre i pazienti forzano la tosse è CONCLUSIONI
stato usato come metodo di diagnosi fin dall'inizio della Abbiamo presentato l'idea di un gruppo di ricerca del MIT
pandemia. Algoritmi basati sul suono della tosse raccolti per un test di pre-screening basato su AI per discriminare
mediante dispositivi smartphone sono già usati per la dia- pazienti positivi al COVID-19 attraverso la registrazione
gnosi di polmonite, asma e altre malattie con alti livelli di di tosse forzata. Tale approccio è in grado di discriminare
accuratezza. il 100% degli asintomatici, essenzialmente a costo zero.
Pertanto, un modello di biomarcatore in grado di cattura- Da ciò potrebbe derivare uno strumento di rilevamento di
re le caratteristiche dei polmoni e delle vie respiratorie è gruppo per sottoporre a screening intere fasce di popo-
stato selezionato. Il biomarcatore della tosse è quello lazione su base giornaliera, evitando il costo per testare
che fornisce le features più rilevanti con il 23% di rile- biologicamente ogni abitante.
vamento unico e il 58% di rilevamento complessivo. L'approccio vocale può essere inoltre combinato in un ap-
proccio multimodale comprendente altri sensori. Se questi
RISULTATI strumenti di pre-screening si rivelassero efficaci, potreb-
Il modello proposto raggiunge una precisione di discrimi- bero essere utilizzati massivamente per migliorare la lotta
nazione del 97,1% su soggetti a cui è stato diagnosticato al COVID-19.
un test ufficiale. Il modello discrimina i soggetti testati uffi-
cialmente il 18% in più rispetto all'autodiagnosi. Gli errori
di auto diagnostica possono contribuire all'espansione del RIFERIMENTI
virus anche se i soggetti sono ben intenzionati. Lo stru- "COVID-19 Artificial Intelligence Diagnosis using only
mento proposto potrebbe aiutare a diminuire questo im- Cough Recordings" Jordi Laguarta, Ferran Hueto, Brian
patto. Subirana - MIT
A tal fine, è notevole che il modello discrimini il 100%
degli asintomatici a scapito di un tasso di falsa positi-
vità del 16,8%. Il ruolo di ogni biomarcatore nella discri-
minazione è stato misurato confrontando i risultati tra un
modello di base e il modello completo con e senza ogni direttamente all’articolo sul Blog e partecipare alla discussione:
biomarcatore. https://it.emcelettronica.com/come-discriminare-gli-
Il modello di base è stato definito con la stessa architettura asintomatici-covid-da-un-colpo-di-tosse
del modello completo, ma senza le caratteristiche pre-ad-
Firmware 2.0 - 83
TENSORFLOW:
RICONOSCIMENTO
AUTOMATICO DI
CARATTERI SCRITTI
A MANO di Andrea Garrapa
Ispirate dal funzionamento del cervello umano, le reti neurali profonde (Deep Neural Network) possono risol-
vere compiti di classificazione con un'accuratezza mai vista prima, se addestrate con una mole adeguata
di dati. Il Deep Learning è emerso negli ultimi anni come una delle principali tecnologie per la produzione
di sistemi intelligenti che imparano dai dati. I framework open source, come TensorFlow, hanno reso questa
tecnologia ampiamente disponibile a tutti coloro che vogliano mettersi in gioco con l'apprendimento mac-
china (Machine Learning). In questo articolo andremo ad illustrare un esempio di implementazione in Ten-
sorFlow di una rete neurale per il riconoscimento di caratteri scritti a mano, in particolare le prime 10 cifre.
INTRODUZIONE che fornisce un'API di basso livello, utile per un'esecuzio-
T
ensorFlow è attualmente il principale software ne efficiente in sistemi embedded e altri scenari.
open source per il Deep Learning, utilizzato da un
numero sempre crescente di professionisti che DEEP LEARNING
lavorano sulla visione artificiale, sull'elaborazione del lin- La classe di algoritmi associata all'apprendimento pro-
guaggio naturale (NLP), sul riconoscimento vocale e l'ana- fondo (Deep Learning) ha riscontrato un tale successo,
lisi predittiva in generale. In termini generali, TensorFlow è da lasciare i metodi tradizionali nella polvere. L'apprendi-
un framework progettato come interfaccia per esprimere mento profondo viene utilizzato oggi per capire il conte-
e implementare algoritmi di apprendimento automatico, in nuto delle immagini o di un discorso, in sistemi che vanno
particolare reti neurali profonde. TensorFlow è stato pro- da app mobile a veicoli autonomi. Nel Deep Learning, for-
gettato pensando alla portabilità, ovvero l'esecuzione su niamo milioni di dati ad una rete di neuroni, insegnando
un'ampia varietà di ambienti e piattaforme hardware. Con loro a riconoscere i modelli insiti nei dati. Le reti neurali
un codice essenzialmente identico, la stessa rete neurale profonde prendono input grezzi (come i valori dei pixel in
TensorFlow potrebbe, ad esempio, essere addestrata nel un'immagine) e li utilizzano per estrarre caratteristiche di
cloud e distribuita su un cluster di molte macchine o su livello superiore (come forme e bordi nelle immagini). In
un singolo computer portatile. Potrebbe essere distribuita tal modo riescono a catturare concetti complessi combi-
per fornire previsioni su un server dedicato o su piattafor- nando informazioni sempre più piccole, potendo così ri-
me per dispositivi mobile come Android, iOS o SBC come solvere compiti impegnativi come la classificazione delle
Raspberry Pi. TensorFlow è anche compatibile, ovvia- immagini.
mente, con i sistemi operativi Linux, macOS e Windows. La capacità di costruire automaticamente le rappresen-
TensorFlow presenta due linguaggi di frontend di alto tazioni dei dati è un vantaggio chiave delle reti neurali
livello. Uno di essi è Python, utilizzato dalla maggior parte profonde rispetto alle tecniche tradizionali di Machine Le-
dei ricercatori e data scientist. Mentre il secondo è C ++, arning. Queste ultime, in genere, richiedono competenze
84 - Firmware 2.0
TENSORFLOW: RICONOSCIMENTO AUTOMATICO DI CARATTERI SCRITTI A MANO
nel dominio applicativo e l'ingegnerizzazione manuale del- te indicato come apprendimento profondo). L'obiettivo del
le caratteristiche (features) prima di poter avviare la fase nostro esempio sarà quindi quello di realizzare un classi-
di addestramento. Il Deep Learning è un argomento che ficatore in grado di riconoscere una cifra scritta a mano.
è stato ampiamente trattato nel nostro blog. Rimandiamo
quindi il lettore che volesse saperne di più sull'argomento
import TensorFlow as tf
alla lettura di precedenti articoli. Questo articolo sarà
invece incentrato sull'utilizzo di TensorFlow per implemen- import numpy as np
tare una rete neurale. import matplotlib.pyplot as plt
Per affrontare la lettura dell'articolo sarebbe utile che il from keras.datasets import mnist
lettore avesse familiarità con il linguaggio di programma- (x_train, y_train), (x_test, y_test) = mnist.load_data()
zione Python e con la tematica del Machine Learning.
x_train, x_test = x_train / 255.0, x_test / 255.0
VAI CON IL FLOW

Per descrivere TensorFlow, partiremo subito con un esem- Le prime 3 istruzioni ci permettono di importare le librerie
pio pratico. Dobbiamo però prima impostare l'ambiente di che utilizzeremo nello script:
lavoro. • TensorFlow chiaramente e utilizzarla nel seguito
dello script in modo abbreviato come tf
IMPOSTARE L'AMBIENTE DI LAVORO • numpy per eseguire calcoli numerici con array e
Per la scrittura e l'esecuzione del codice, utilizzeremo utilizzarla usando l'abbreviazione np
Google Colaboratory, anche detto Colab. E' uno stru- • matplotlib.pyplot per effettuare la visualizzazio-
mento gratuito con cui possiamo realizzare dei notebook ne di immagini e grafici, abbreviandola in plt
Jupiter. Senza addentrarci troppo nell'argomento, quello
che ci interessa è che Colab ci offre un ambiente di pro- La quarta riga invece, ci permette di caricare il dataset.
grammazione in Python già impostato senza la necessità Grazie al metodo load_data(), il dataset può essere sud-
di installare nulla sul nostro computer. Inoltre, per esegui- diviso assegnando i vari input ed output. In particolare:
re il codice utilizzeremo le risorse hardware messe a di- • x_train è il tensore che raccoglie i dati di adde-
sposizione da Google. Per utilizzare Colab basta: stramento. Un tensore altro non è che la genera-
1. accedere al proprio account Google lizzazione del concetto di vettore: un vettore è un
2. fare click sul seguente link tensore di rango 1, una matrice è un tensore di
3. quindi fare click sull'opzione in basso a destra de- rango 2. Il nostro x_train è un tensore di rango 3,
nominata "Nuovo Blocco Note" perchè presenta 3 dimensioni. La prima dimensio-
4. infine fare click su "Connetti" in alto a destra e sarà ne è il numero di righe pari al numero di immagi-
così tutto pronto per iniziare ni cioè 60.000. La seconda e la terza dimensione
sono date dalla larghezza e dalla lunghezza delle
Alla fine di questo articolo è anche presente un link al file immagini cioè 28 pixel. In Figura 1 è riportata una
dove tutto è già impostato ed attende solo di essere ese- rappresentazione grafica di x_train.
guito e provato. • y_train è un vettore da 60.000 righe. In ogni riga è
contenuta una cifra da 0 a 9. In sostanza, sono le
CARICARE DATASET E LIBRERIE etichette delle immagini in x_train. Se nella prima
Per il nostro esempio avremo bisogno di un dataset. riga di x_train è presente l'immagine di un 5, alla
Useremo l'MNIST (Mixed National Institute of Standards prima riga di y_train ci sarà scritto 5, e così via per
and Technology), un dataset di 60.000 immagini (28x28 tutte le altre.
pixel ognuna) in scala di grigi, insieme a un set di prova di • x_test è il tensore che raccoglie i dati di test, con
10.000 immagini. Ogni immagine contiene una delle dieci cui valuteremo le performance della rete neurale
cifre (da 0 a 9) scritte a mano. Si tratta di uno dei set di addestrata. Dal punto di vista della struttura, è si-
dati più usati nell'elaborazione delle immagini e nell'ap- mile a x_train con l'unica differenza che presenta
prendimento macchina ed ha svolto un ruolo importante solo 10.000 righe.
nello sviluppo delle reti neurali artificiali (ora generalmen- • y_test raccoglie le etichette delle immagini pre-
Firmware 2.0 - 85
Come si può notare, le immagini

in Figura 2 riportano quattro cifre
scritte a mano.
CREAZIONE DEL MODELLO

Siamo giunti alla creazione del
modello della rete neurale. La rete
neurale che andremo a modellare
viene rappresentata in Figura 3.
La rete neurale presenta:
• Uno strato di neuroni di ingres-
so - il numero di neuroni di ingres-
so corrisponde al numero di pixel
(28x28 =784) di ogni immagine del
set
• Uno strato di neuroni nascosti -
il numero di neuroni in questo stra-
to è stato scelto pari a 128
• Uno strato di neuroni di uscita
- il numero di neuroni di uscita cor-
Figura 1: Rappresentazione grafica del tensore x_train risponde al numero di classi che
vogliamo classificare (nel nostro
caso 10)
Ogni neurone di input è collegato ad ogni neurone del-

lo strato nascosto che, a sua volta, è collegato ad ogni
neurone dello strato di output. Se stiamo risolvendo un
problema di regressione, allora nello strato di output avre-
mo un solo neurone. Se invece stiamo risolvendo un pro-
blema di classificazione binaria, avremo due neuroni di
Figura 2: Quattro cifre scritte a mano, scelte a caso, dal set
di addestramento output (Y_classe1 e Y_classe2) che indicano i valori di
probabilità per ciascuna delle classi binarie. Nel nostro
senti in x_test. caso abbiamo 10 neuroni nello strato di uscita, e per ogni
Essendo le immagini in scala di grigi, i valori dei pixel ingresso, essi forniranno la probabilità che quell'ingresso
saranno numeri interi da 0 a 255. Dividendo quindi, sia possa essere la cifra (classe) che rappresentano. Il neuro-
x_train che x_test, per 255 tutti i valori vengono riportati in ne con la probabilità più alta ci indicherà la classe predetta
un intervallo di valori reali compresi tra 0 e 1. per lo specifico input. Le istruzioni per implementare il mo-
dello di rete neurale, sono le seguenti:
VISUALIZZARE I DATI
model = tf.keras.models.Sequential([
Possiamo anche visualizzare alcune immagini casuali
tf.keras.layers.Flatten(input_shape=(28, 28),na-
del set di addestramento (x_train), attraverso le seguenti
me='Strato_di_ingresso'),
istruzioni:
tf.keras.layers.Dense(128, activation='relu',na-
numero_immagini = 4 me='Strato_nascosto'),
r=range(1,numero_immagini+1,1) tf.keras.layers.Dropout(0.2),
for i in r: tf.keras.layers.Dense(10, activation='softmax',na-
n_r = np.random.randint(0, 60000 + 1) me='Strato_di_uscita')
plt.subplot(1, len(r), i) ])
plt.imshow(x_train[n_r,:,:],cmap='gray') model.summary()
86 - Firmware 2.0
Figura 3: Rappresentazione della rete neurale implementata
Un modello Sequential() è un modello di rete neurale ap- Infine, model.summary() stamperà una tabella riassun-
propriato per una semplice sequenza di strati in cui ogni tiva (Figura 4) della nostra rete neurale, dove vengono
strato ha esattamente un tensore di input e un tensore di riportati anche il totale dei parametri. I parametri sono le
output. variabili che cercheremo di ottimizzare durante la fase
È possibile costruire tale modello passando un elenco di di addestramento.
livelli attraverso l'attributo layers.
• In prima posizione troviamo lo "Strato_di_ingres- CONFIGURAZIONE DEL MODELLO
so" di tipo Flatten. Stiamo cioè fornendo un'imma- Dopo aver impostato il modello, passiamo alla sua con-
gine 28x28 e si occuperà lui di adattarla per asse- figurazione. Configurare il modello significa impostare il
gnare il valore di ogni pixel ad uno dei 784 neuroni tipo di funzione costo che l'algoritmo di ottimizzazio-
dello strato di ingresso. ne deve minimizzare operando sui parametri della rete
• In seconda posizione troviamo lo "Strato_nasco- durante la fase di addestramento. Le metriche vengono
sto" di tipo Dense. Dense è il classico strato. No- usate come parametro di valutazione delle performance
tare che la sua funzione di attivazione è la relu. ma non vengono coinvolte nell'ottimizzazione dei parame-
Anche detta funzione rettificatrice, è la funzione di tri.
attivazione più usata nel Deep Learning.
• In terza posizione troviamo lo strato di Dropout. ottimizzatore='adam'
Non diremo molto su questo strato, ma in sostan-
funzione_costo = 'sparse_categorical_crossentropy'
za la sua introduzione è giustificata dal combattere
metrica = 'accuracy'
il fenomeno negativo dell'overfitting.
model.compile(optimizer=ottimizzatore,
• In ultima posizione troviamo lo "Strato_di_uscita"
di tipo Dense. Notare che la sua funzione di atti- loss=funzione_costo,
vazione è la softmax. Softmax converte un vettore metrics=[metrica])
reale in un vettore di probabilità. Gli elementi del
vettore di output sono compresi nell'intervallo (0, Il codice riportato definisce ottimizzatore, funzione costo
1) e la loro somma è pari ad 1. e metrica utilizzati nel metodo compile() per configurare
Firmware 2.0 - 87
destramento risulta soddisfacente

(nel nostro caso è 98%) allora si
può passare a valutare le perfor-
mance del modello con il set di test.
VALUTAZIONE DEL
MODELLO
Per valutare le performance del
modello addestrato useremo il set
di test (x_test, y_test). In questo
modo valuteremo le risposte del
modello a degli input mai visti pri-
ma, e potremo valutare se e quan-
Figura 4: Tabella riassuntiva del modello implementato
to il modello è in grado di genera-
lizzare.
accuratezza_test = model.evaluate(x_test, y_test)
Passiamo al metodo evaluate(), i tensori di test (x_test,

y_test) e leggiamo l'accuratezza. Nel nostro caso l'accu-
ratezza risulta del 98%. Come prova aggiuntiva, abbiamo
inserito alla fine del codice, un'ulteriore cella. Ogni vol-
ta che questa viene eseguita, il codice sceglie un valore
random dal set di test, lo valuta e fornisce la sua previ-
sione. La previsione viene poi confrontata con l'immagine
originale. Un esempio di questo confronto è mostrato in
Figura 5. Si potrebbe continuare a fare click sull'icona di
esecuzione della cella fino a quando non si verifica un
errore di predizione.
CONCLUSIONI
Figura 5: Un esempio di come il modello sia in grado di rico- TensorFlow è un framework gratuito sviluppato da Goo-
noscere le cifre scritte a mano gle che permette, a professionisti e non, di interfacciarsi al
mondo del Machine Learning. In questo articolo abbiamo
il modello. voluto proporre un esempio di come poter utilizzare que-
sta libreria per realizzare il riconoscimento automatico di
ADDESTRAMENTO DEL MODELLO cifre scritte a mano. Si tratta chiaramente di un piccolo
L'addestramento del modello viene effettuato attraverso il assaggio di quello che il framework permette di fare. Per
metodo fit(). coloro che volessero velocemente mettere alla prova il
Vengono passati al metodo il set di training d'ingresso codice presentato nell'articolo, al seguente link è possi-
x_train, il vettore delle etichette y_train relative al set di bile accedere al notebook dove tutto è già impostato ed
training, e il numero di epoche. attende solo l'esecuzione.
Le epoche rappresentano il numero di volte che la rete
verrà addestrata con lo stesso dataset.
history = model.fit(x_train, y_train, epochs=5) direttamente all’articolo sul Blog e partecipare alla discussione:
https://it.emcelettronica.com/tensorflow-riconoscimento-
automatico-di-caratteri-scritti-a-mano
Se alla fine dell'addestramento l'accuratezza sul set di ad-
88 - Firmware 2.0
REALIZZIAMO UNA
TELA VIRTUALE CON
OPENCV PER PYTHON di Andrea Garrapa
In questo articolo andremo ad utilizzare la libreria OpenCV in Python per realizzare un progetto che chiame-
remo "Tela virtuale". Tale applicazione consente di disegnare, virtualmente, sullo schermo del nostro compu-
ter utilizzando soltanto una webcam ed un pennarello. In realtà, invece del pennarello, può essere utilizzato
qualsiasi oggetto di colore uniforme e che si distingua dallo sfondo. Questo perché l'applicazione sfrutta la
tecnica del rilevamento del contorno basata su una maschera dell'oggetto utilizzato. Grazie ai dati in tempo
reale della webcam, questa applicazione è in grado di tracciare un oggetto specifico, consentendo all'utente
di disegnare sullo schermo nella posizione tracciata.
INTRODUZIONE IL PROGETTO
O
penCV (Open Source Computer Vision Library) Sebbene si tratti di un progetto non particolarmente com-
è una libreria software open source per la vi- plicato, prima di iniziare con la descrizione, vogliamo con-
sione artificiale e l'apprendimento automatico. sigliare a chi fosse a digiuno degli argomenti che affronte-
OpenCV è stata progettata per essere multipiattaforma. remo nell'articolo alcune letture di supporto. In particolare:
La libreria è stata scritta in C rendendola portabile su qua- • Per chi non avesse un'installazione Python o non
si tutti i sistemi commerciali. Per la maggior parte, i nuovi sapesse come importare la libreria OpenCV, può
algoritmi OpenCV sono ora sviluppati in C ++. seguire le istruzioni presenti in "Machine Lear-
Sono stati sviluppati anche wrapper per linguaggi come ning con Python: introduzione al progetto".
Python e Java per incoraggiarne l'adozione da parte di • Per chi volesse saperne di più sulla Computer Vi-
un pubblico sempre più ampio. OpenCV funziona sia su sion, può leggere gli articoli di Cristiano Scavon-
sistemi operativi desktop (Windows, Linux, MacOS, Fre- gelli, come "Computer Vision 1.01 – Filtraggi"
eBSD, OpenBSD) che su dispositivi mobili (Android, Ma- e "Computer Vision 1.02 – Canny Edge De-
emo, iOS). tection".
In questo nostro progetto useremo il linguaggio Python e • Per quanto riguarda gli spazi di colore consigliamo
quindi la libreria OpenCV corrispondente. "Tutti i colori dell’astrofotografia digitale".
La libreria presenta più di 2500 algoritmi ottimizzati, sia
per la visione artificiale che per l'apprendimento automa- Dopo questa premessa possiamo tuffarci nella descri-
tico. zione del progetto. Le fasi principali per la realizzazione
Questi algoritmi possono essere utilizzati per rilevare e dell'applicazione sono le seguenti:
riconoscere volti, identificare oggetti, classificare azioni • Fase 1 - Trovare l'intervallo di valori nello spazio
umane nei video, tracciare i movimenti della telecamera, di colore HSV relativo all'oggetto usato come
tracciare oggetti in movimento, estrarre modelli 3D di og- marker (il pennarello nel nostro caso).
getti, unire immagini insieme per produrre un'immagine ad • Fase 2 - Creare una maschera del marker uti-
alta risoluzione di un'intera scena, trovare immagini simili lizzando la gamma di valori nello spazio di colore
in un database di immagini, rimuovere gli occhi rossi dalle HSV trovati nella Fase 1.
immagini scattate con il flash, seguire i movimenti degli • Fase 3 - Utilizzare il rilevamento del contorno
occhi, riconoscere lo scenario e stabilire marcatori per so- per tracciare la posizione del marker. In poche
vrapporlo alla realtà aumentata, etc. parole, ottenere le coordinate x, y del pennarello
Firmware 2.0 - 89
REALIZZIAMO UNA TELA VIRTUALE CON OPENCV PER PYTHON
Figura 1: Operando sui cursori nella finestra "Track", l'immagine sulla destra viene filtrata nello spazio di colore HSV estraen-
do così solo i pixel relativi al marker di interesse
all'interno della "tela virtuale". ne, valore) poiché è molto più facile manipolare i colori
• Fase 4 - Disegnare un punto colorato alle coordi- in tale modello. Lo script presente al seguente LINK ti
nate x, y della posizione trovata. consentirà di utilizzare i vari cursori presenti nella finestra
"Track" per regolare i canali min e max relativi a tonalità
Oltre ad implementare queste quattro fasi, nel nostro co- (H), saturazione (S) e valore (V) dell'immagine. Si tratta
dice abbiamo inserito alcune funzionalità aggiuntive come di giocare con i cursori nella finestra affinché solo il mar-
la possibilità per l'utente di scegliere la forma, la dimensio- ker (pennarello nel nostro caso) sia visibile, lasciando il
ne ed il colore del pennello virtuale, grazie ad una finestra resto dello schermo nero. In Figura 1 abbiamo riportato
ospitante dei cursori di selezione. l'esempio del pennarello. Il marker scelto è un pennarello
Passiamo ora alla descrizione dell'implementazione delle con il tappo verde e il corpo di altri colori. Quello che ci
quattro fasi principali. interessa è mettere in evidenza il tappo verde, poiché
all'interno della scena quel colore non è presente e
FASE 1 quindi risulta più facile da tracciare. I valori trovati ci
Il tracciamento video è il processo di localizzazione di un serviranno nella Fase 2 per la creazione della maschera. I
oggetto in movimento nel tempo utilizzando una telecame- valori possono essere pensati come due array: uno conte-
ra. Ha una varietà di usi, alcuni dei quali sono: interazione nente i valori dei cursori con _min [H_min, S_min, V_min],
uomo-computer, sicurezza e sorveglianza, comunicazio- e l'altro contenente i valori dei cursori con _max [H_max,
ne e compressione video, realtà aumentata, controllo del S_max, V_max].
traffico, imaging medico e montaggio video. Nel nostro
progetto dobbiamo tracciare la posizione di un marker FASE 2
(pennarello). Per farlo cercheremo di filtrare il marker Una volta trovati i valori che evidenziano il nostro marker,
in uno spazio di colore appropriato in modo da sepa- oscurando il resto della scena, possono essere utilizzati
rarlo da tutto ciò che si trova nella scena. Occorre cioè per creare la maschera. Per mezzo della funzione cv.in-
trovare un intervallo ristretto di valori in cui è compreso il Range(img, bordoinf, bordosup) possiamo controllare se
colore del nostro marker. gli elementi di un'immagine (img) si trovano compresi tra
Dal momento che stiamo cercando di rilevare il colore, gli elementi di due array (bordoinf, bordosup). In parole
convertiremo la nostra immagine dal formato RGB (o semplici, quello che faremo è convertire img nello spazio
BGR in OpenCV) al formato HSV (tonalità, saturazio- di colore HSV. Quindi filtreremo l'immagine per estra-
90 - Firmware 2.0
Figura 2: Dopo aver ottenuto la maschera è possibile tracciare il movimento del marker nella scena
polare solo i pixel il cui valore HSV rientra tra i valori IL CODICE
espressi da bordoinf e bordosup. Passiamo quindi all'analisi del codice in Python per im-
La funzione fornirà in uscita un'immagine delle stesse di- plementare l'applicazione. Analizzeremo il codice suddivi-
mensioni di img ma con valore 1 nelle posizioni dei pixel dendolo in piccole porzioni.
estrapolati e 0 altrimenti. Nel nostro caso img è dato dai
fotogrammi catturati dalla webcam e convertiti in formato import cv2 as cv
HSV, e gli array di riferimento sono i valori trovati nella import numpy as np
Fase 1, ovvero [H_min, S_min, V_min] e [H_max, S_max,
V_max]. Come al solito, per prima cosa importiamo le librerie che
utilizzeremo nello script. In particolare cv2 è il nome della
FASE 3 libreria OpenCV per Python mentre numpy è la libreria
L'intera applicazione si basa fondamentalmente sul rile- Python che ci permette di manipolare array e matrici.
vamento dei contorni. Una volta ottenuta la maschera
binaria del nostro marker, possiamo utilizzare il rileva-
L=960
mento del contorno per trovare la posizione del marker
AR=4/3
nella scena. Tracciato il marker, possiamo localizzare il
punto effettivo da cui partirà la pittura sulla tela virtuale. H=int(L/AR)
La Figura 2 dimostra il tracciamento del marker tramite il cap = cv.VideoCapture(0)
rettangolo verde intorno al tappo del pennarello, e la valu- cap.set(3,L) #id=3 larghezza
tazione della punta del pennello virtuale con il punto blu. cap.set(4,H) #id=4 altezza
Queste operazioni sono eseguite dalla funzione cap.set(10,150) #id=10 luminosità
getContorno() che verrà descritta più nel dettaglio prose-
guendo nell'articolo.
myPs = []
FASE 4
Una volta che il marker è stato tracciato si può cominciare Nella seconda porzione di codice impostiamo alcuni para-
a dipingere, grazie alla funzione drawOC(). Anche questa metri di configurazione come la larghezza (L), il rapporto
funzione verrà analizzata più nel dettaglio durante la de- d'aspetto (AR) e l'altezza (H) della tela virtuale su cui vo-
scrizione del codice. Per rendere l'applicazione più diver- gliamo dipingere. Adesso dobbiamo catturare lo streaming
tente, sono state inserite delle funzioni che permettono di live con la webcam. OpenCV fornisce un'interfaccia molto
selezionare il colore, la forma e la dimensione del pennel- semplice per farlo. Per acquisire un video, è necessario
lo virtuale attraverso una barra selezionatrice (Figura 3). creare un oggetto VideoCapture(). Il suo argomento può
Firmware 2.0 - 91
###Dimensione dello spot###

def on_trackbar2():
spotSize = cv.getTrackbarPos("Dimens.", "Palette")
return spotSize
###Forma dello spot###
def on_trackbar3():
spotShape= cv.getTrackbarPos("Forma", "Palette")
return spotShape
Queste due funzioni servono per ottenere la dimensione

della punta (spot) del pennello virtuale e la forma, scel-
te dall'utente attraverso la barra selezionatrice. Esse
ritornano un valore che verrà poi passato alla funzione
findColor().
###Impostazioni della Barra###

Figura 3: La finestra "Palette" permette all'utente di selezio- cv.namedWindow("Palette")
nare il colore, la forma e la dimensione del pennello virtuale
cv.createTrackbar("Blu", "Palette" , 0, 255, on_trackbar)
cv.createTrackbar("Verde", "Palette" , 255, 255, on_
trackbar)
essere l'indice del dispositivo o il nome di un file video.
L'indice di un dispositivo è solo il numero per specificare cv.createTrackbar("Rosso", "Palette" , 0, 255, on_
quale telecamera selezionare. Passando semplicemente trackbar)
0 o -1, richiediamo la webcam integrata. Per selezionare cv.createTrackbar("Dimens", "Palette" , 5, 20, on_
altre telecamere basta passare il valore 1, 2 e così via. trackbar)
Una volta creata un'istanza che abbiamo denominato cv.createTrackbar("Forma", "Palette" , 0, 1, on_trackbar)
cap, possiamo utilizzare il metodo set() per impostare al-
cuni parametri come larghezza, altezza e luminosità. Ogni In questo pezzo di codice avvengono le impostazioni del-
parametro viene impostato, indicando il relativo identifi- la barra selezionatrice. Si definisce il nome della finestra
cativo (id) e il valore. Passiamo quindi a definire alcune namedWindow("Palette") che ospiterà i vari cursori. Ven-
funzioni che verranno poi chiamate nel ciclo principale. gono quindi aggiunti i selezionatori createTrackbar() rela-
tivi ai tre colori primari, alla dimensione del pennello e alla
sua forma.
###Colore dello spot###
def on_trackbar(): ###Tracciamento del pennello###
B = cv.getTrackbarPos("Blu", "Palette") def findColor(img, spotColore, spotSize, spotShape):
V = cv.getTrackbarPos("Verde", "Palette") imgHSV = cv.cvtColor(img,cv.COLOR_BGR2HSV)
R = cv.getTrackbarPos("Rosso", "Palette") newP=[]
spotColore =[B, V, R] lower = np.array([53,79,0])
return spotColore upper = np.array([109,255,255])
mask = cv.inRange(imgHSV,lower,upper)
Questa funzione serve per ottenere il colore scelto dall'u- x,y=getContorno(mask)
tente attraverso la barra selezionatrice. Ogni cursore rap- if x!=0 and y!=0:
presenta uno dei tre colori primari, combinando insieme newP.append([x,y,spotColore,spotSize,spotShape])
diverse quantità di rosso, verde e blu è possibile ottenere
return newP
una grande varietà di colori.
92 - Firmware 2.0
Figura 4: Opera realizzata con la "Tela Virtuale", da un artista poco conosciuto per fortuna
La funzione findColor() rappresenta il cuore dell'applica-

zione. ###Localizzare la punta del pennello###
Tale funzione non solo traccia la posizione del pennello, def getContorno(img):
istante per istante, ma tiene traccia anche delle opzioni
contorno, gerarchia = cv.findContours(img,cv.RETR_
scelte come il colore, la forma e la dimensione scelte per
EXTERNAL,cv.CHAIN_APPROX_NONE)
il pennello virtuale.
x,y,w,h = 0,0,0,0
All'interno della funzione avviene la conversione dell'im- for cnt in contorno:

magine dallo spazio di colore BGR a quello HSV per mez- area =cv.contourArea(cnt)
zo di cvtColor(). if area>500:
In questo modo è possibile applicare la maschera peri = cv.arcLength(cnt,True)
(mask).
approx = cv.approxPolyDP(cnt,0.02*peri,True)
La funzione getContorno() viene usata per localizzare il
x, y, w, h = cv.boundingRect(approx)
marker e per stabilire un punto medio dove applicare il
return x+w//2,y
colore sull'immagine.
Se il marker si muove, la sua nuova posizione e i dati del
pennello vengono letteralmente appesi al vettore newP, La funzione getContorno(), utilizzata in findColor(), ese-
che viene poi restituito come output della funzione. gue l'estrazione del contorno del marker grazie a
Firmware 2.0 - 93
findContours(). Quindi valuta un contenitore rettangolare

boundingRect() per il contorno trovato e valuta un punto if cv.waitKey(1) == ord('q'):
medio sulla faccia superiore di questa scatola (la punta
cap.release()
del pennello), che viene poi restituito come output della
funzione. break
cv.destroyAllWindows()
###Colorare il punto myPs###
def drawOC(myPs):
for pts in myPs: L'ultimo blocco di codice rappresenta il ciclo iterativo in cui
vengono richiamate le funzioni descritte in precedenza.
if pts[4]==0: Alla fine del codice sono state incluse alcune opzioni
cv.circle(imgResult,(pts[0],pts[1]),pts[3],pts[2],cv. come la possibilità di cancellare tutto il contenuto della
tela premendo il tasto E sulla tastiera.
FILLED)
Oppure chiudere tutto attraverso il tasto Q.
if pts[4]==1:
cv.rectangle(imgResult,(pts[0],pts[1]),(pts[0]+pts[3],p-
LA PRIMA OPERA
Devo fare una premessa: a scuola in educazione artistica
ts[1]+pts[3]),pts[2],cv.FILLED) ero pessimo.
Mi sono voluto comunque cimentare nella prima opera
A questo punto possiamo dipingere con la funzione con la "Tela Virtuale"; la riporto in Figura 4, abbiate pa-
drawOC(). All'interno della funzione viene eseguita anche zienza.
la scelta sulla forma della punta del pennello, a seconda
che vogliamo una punta circolare o quadrata. CONCLUSIONE
In questo articolo abbiamo descritto come implementa-
###MAIN###
re una "Tela Virtuale" nel linguaggio di programmazio-
while True: ne Python, sfruttando le potenzialità offerte dalla libreria
OpenCV.
suc, f = cap.read() Una "Tela Virtuale" è un'applicazione che consente di di-
segnare sul nostro monitor usando come pennello virtua-
imgResult = f.copy()
le un oggetto qualsiasi che abbiamo chiamato marker. Il
newP = findColor(f, on_trackbar(),on_trackbar2(),on_ marker viene tracciato nei suoi movimenti per mezzo della
webcam e di un algoritmo.
trackbar3()) L'applicazione è provvista di una barra di selezione che
consente all'utente di scegliere colore, forma e dimensio-
if len(newP)!=0:
ne del pennello. Altre opzioni possono essere aggiunte
for pts in newP: seguendo il modo in cui sono state implementate le altre
all'interno del codice.
myPs.append(pts)
if len(myPs)!=0:
ALLEGATI
Da questo LINK è possibile scaricare lo script in Python.
drawOC(myPs)
cv.imshow("Canvas",cv.flip(imgResult,1))
if cv.waitKey(1) == ord('e'):
https://it.emcelettronica.com/realizziamo-una-tela-
myPs=[] virtuale-con-opencv-per-python
94 - Firmware 2.0
I NOSTRI CORSI DI ELETTRONICA
PER I PROFESSIONISTI
E I MAKERS
i corsi
c at a a
urce dedi
Open So
onica
di Elettr
orma
La piattaf
&
S I D I
T T I I COR
RE T U
I AV E
PUO
A PORTATA DI CLICK

Firmware 2.21

Caricato da

Informazioni sul documento

Descrizione:

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Descrizione:

Copyright:

Formati disponibili

Firmware 2.21

Caricato da

Descrizione:

Copyright:

Formati disponibili

Firmware2.

Giordana Francesca Brescia

EDITORIALE COME UTILIZZARE

Il nome e logo Microchip, il logo Microchip e PolarFire

INTRODUZIONE comunicazione wireless, che su questa scala è di gran

Infine, la rete viene riaddestrata per apprendere i pesi fi-

Figura 4: Nello stadio relativo alla codifica di Huffman ven-

tatura e quantizzazione utilizzati singolarmente o insieme.

CODIFICA DI HUFFMAN COMPILAZIONE

Arduino. Può anche generare progetti per ambienti di svi-

L’autore è a disposizione nei commenti per eventuali

schede industriali è solo l'ultimo esempio di come Apacer

le nostre promesse, ci impegniamo per il miglioramento

per lo storage digitale e applicazioni integrate Internet of https://it.emcelettronica.com/sono-ora-disponibili-le-

INTRODUZIONE come servizi per memorizzare e interrogare la persistenza

Figura 1: Flusso dei dati di temperatura e umidità

Figura 2: Schema di assemblaggio

Figura 3: Piedinatura dei componenti

CONFIGURAZIONE DELL’ESP8266 Per caricare le istruzioni sul modulo Wi-Fi è necessario

CREAZIONE DELLO SKETCH

#define DHTPIN 2 /* Arduino pin for DHT sensorn */

const char* ssid = "TUOSSID"; /* Network's name */

char* topic = "mosquitto_main_topic"; /* MQTT Broker topic */

const char mqtt_user[] = "mosquitto"; /* MQTT broker username */

const int timezone = -5; /* Timezone (Colombia) */

/* Structure to store DHT sensor data */

void callback(char* topic, byte* payload, unsigned int length) {

DHT dht(DHTPIN, DHTTYPE); /* DHT sensor client */

if(metric == NULL) return;

payload = createPayload(datetime, now, metric);

for (int i = 0; i < 6; ++i) {

while (WiFi.status() != WL_CONNECTED) {

if (timezone < 0){

struct Metrics *metric = (Metrics*)malloc(sizeof(struct Metrics));

if (isnan(metric->humidity) || isnan(metric->celsius) || isnan(metric->fahrenheit)) {

metric->heatIndexFahr = dht.computeHeatIndex(metric->fahrenheit, metric->humidity);

String payload = "{\"cliente\":";

Serial.print("Sending payload: ");

Figura 1: Schema elettrico dei collegamenti dei componenti

Figura 2: Dati pubblicati di temperatura e umidità

appena riceve alimentazione. Inoltre, il pin Data del sen- destra).

Figura 3: Dashboard Mosquitto con messaggi IoT

Figura 4: Ricezione di messaggi su Mosquitto e Kafka

data”. I dati sono stati generati secondo le seguenti spe- paragrafi.

Figura 5: Messaggi catturati da NiFi

Associazione delle medie Tracciamento dei dati

Classificazione - Dati casuali

Tabella 1: Specifiche tecniche dei processori ATMega328P e ATMega16U2

MINI LE ARDUINO - Arduino | 5VDC; ATMEGA16U2,AT- re ATMega16U2.

Figura 3: Dimensioni di Arduino UNO Mini LE

l'alimentazione della scheda, e pin disponibili

“Arduino UNO Mini Limited Edition (LE) è

Anche il passo tra i pin header è ridotto, ap-

Figura 5: Diagramma pinout di Arduino UNO Mini Limited Edition

CONCLUSIONI Open Source potrai condividere i tuoi primi progetti

INTRODUZIONE zazione (overfitting).

COME USARE IL TRANSFER LEARNING destrato:

e 1. Lo faremo utilizzando un livello di normalizzazione

from tensorflow.keras import layers train_ds = train_ds.map(lambda x, y: (tf.image.resize(x,

import matplotlib.pyplot as plt size), y))

import numpy as np validation_ds = validation_ds.map(lambda x, y: (tf.ima-

struct Metrics metric = (Metrics)malloc(sizeof(struct Metrics));