UNIVERSITA’ TELEMATICA “e-Campus”

Facoltà di INGEGNERIA
Corso di laurea in INGEGNERIA INFORMATICA E
DELL’AUTOMAZIONE

"Comparazione fra tecniche di controllo classiche e

tecniche di Deep Reinforcement Learning"

Relatore: Gioacchino Manfredi

Tesi di Laurea di:

Favella Daila
Matricola:001393974

Anno Accademico 2022/2023

1
2
Sommario
Introduzione.................................................................................................................................4
Capitolo 1....................................................................................................................................5
Introduzione...........................................................................................................................5
1.1 Il Machine Learning.........................................................................................................7
1.2 Gli algoritmi di Reinforcement Learning.....................................................................10
1.2.1 Componenti del Reinforcement Learning.............................................................15
1.2.2 Modello dell’ambiente: Markov Decision Process................................................17
1.2.3 Valore di ritorno......................................................................................................18
1.2.4 La funzione valore...................................................................................................19
1.2.5 Equazioni di Bellman..............................................................................................19
1.3 Le reti neurali.................................................................................................................25
1.3.1 Il modello matematico del neurone........................................................................27
1.3.2 L’architettura della rete..........................................................................................30
1.3.3 Addestramento della rete........................................................................................32
1.3.4 Le Reti convoluzionali.............................................................................................34
1.4 Il Deep Reinforcemente Learning.................................................................................41
1.4.1 Algoritmo Deep Q-Learning...................................................................................41
Capitolo 2..................................................................................................................................43
Introduzione.........................................................................................................................43
2.1 I Regolatori PID.............................................................................................................47
2.1.1 L’azione proporzionale...........................................................................................49
2.1.2 L’azione integrale....................................................................................................57
2.1.3 L’azione derivativa..................................................................................................68
Capitolo3...................................................................................................................................76
Introduzione.........................................................................................................................76
3.1 Controllo del cart-pole mediante tecniche classiche....................................................76
3.1.1 Modello del sistema.................................................................................................77
3.1.2 Modello matematico e funzione di trasferimento..................................................78
3.1.3 Controllo a ciclo aperto...........................................................................................82
3.1.4 Controllo a ciclo chiuso...........................................................................................85
3.2 Controllo mediante tecniche Reinforcement Learning................................................95
3.2.1 Ambiente di simulazione.............................................................................................95

3
 3.2.2 Implementazione degli algoritmi................................................................................98
Algoritmo Q-Learning.....................................................................................................99
Algoritmo Deep Q-Network...........................................................................................103
3.2.4 Risultati ottenuti........................................................................................................110
Conclusioni.............................................................................................................................115
Bibliografia.............................................................................................................................117

Introduzione

Obiettivo di questa tesi è cercare di comparare attraverso con l’ausilio di alcuni trattati e

articoli scientifici, le prestazioni del classico controllo in retroazione PID (o anche il

controllo mediante altre tecniche classiche come ad esempio il controllo predittivo

MPC Model Predictive Control) a quelle degli algoritmi di Deep Learning e in

particolare di quelli che sono gli algoritmi di rinforzo profondo detti appunto Deep

Reinforcement Learning. Prima di arrivare a questo è doveroso affrontare una breve

disamina a scopo puramente didattico e non esaustivo su quelli che sono i punti di forza

e gli obiettivi che si possono raggiungere con ciascuna di queste tecniche da quelle

classiche a quelle di deep learning. Nello specifico nel primo capitolo passeremo in

rassegna su quelle che sono le diverse tecniche di Intelligenza Artificiale esistenti

partendo dal Machine Learning in quanto il Deep Learning rappresenta un sottocampo

di questa più ampia branca. Nel secondo capitolo invece parleremo del controllo

mediante regolatori PID cercando di analizzare nello specifico le prestazioni e anche i

limiti legati all’implementazione di ciascuna delle tre azioni di cui si compongono tali

regolatori, l’azione proporzionale, l’azione integrale e l’azione derivativa, si

analizzeranno le varie combinazioni di tali azioni per cercare di dedurre quali sono gli

effetti dei vari parametri sulla bontà del controllo e anche provare a definire quale possa

4
essere il miglior compromesso per raggiungere gli obiettivi impostati. Infine nel terzo

capitolo prenderemo in considerazione un caso di studio in particolare quello del

pendolo inverso su un carrello, anche detto Cart Pole, in quanto esso costituisce un

esempio “didattico” che però ben rappresenta molte altre applicazioni di controllo, di

vario genere, di interesse pratico in ambito industriale quali ad esempio sistemi guida

missili, di controllo di gru, di azionamento di bracci robotici, ecc... Analizzeremo nel

dettaglio il codice usato per le diverse simulazioni presenti nei diversi articoli e

materiale didattico trovato, confrontando la capacità del sistema di controllo a seguire il

setpoint al variare dell’algoritmo scelto e nello specifico al variare da un lato dei

parametri dei diversi regolatori PID e dall’altro dei parametri che l’algoritmo di deep

learning usa durante il processo di apprendimento.

Capitolo 1

Introduzione

L'apprendimento per rinforzo profondo, deep reinforcement learning (deep RL)

rappresenta un sottocampo dell’apprendimento automatico, cioè di quello che è detto

Machine Learning (ML) . A sua volta l’apprendimento automatico (ML) è visto come

parte dell’intelligenza artificiale (AI), e rappresenta un campo di indagini dedicato alla

comprensione e alla costruzione di metodi che “apprendono”, ovvero metodi che

sfruttano i dati per migliorare le prestazioni di tutta una serie di attività. Gli algoritmi di

apprendimento automatico costruiscono un modello basato su dati campione, noti come

dati di addestramento, per fare previsioni o prendere decisioni senza essere

esplicitamente programmati per farlo. Essi sono utilizzati in un'ampia varietà di

5
applicazioni, come in medicina, filtraggio della posta elettronica , riconoscimento

vocale, eolico, enigmistica, trading, analisi economico-finanziaria delle aziende,

agricoltura e visione artificiale, tutti campi in cui è difficile sviluppare algoritmi

convenzionali per eseguire le attività necessarie. Ebbene l’apprendimento per rinforzo

profondo (deep RL) combina l'apprendimento per rinforzo (RL) e l’apprendimento

profondo (DL). L'apprendimento per rinforzo ( RL ) è un'area dell'apprendimento

automatico che si occupa di come gli agenti intelligenti dovrebbero

intraprendere azioni in un ambiente per massimizzare la nozione di ricompensa

cumulativa . Esso rappresenta uno dei tre paradigmi di apprendimento automatico di

base, insieme all'apprendimento supervisionato e all'apprendimento non

supervisionato. L'apprendimento profondo ( DL ) invece fa parte di una famiglia più

ampia di metodi di apprendimento automatico basati su reti neurali

artificiali con apprendimento di rappresentazione, il DL quindi utilizza una rete neurale

per trasformare un insieme di input in un insieme di output tramite una rete neurale

artificiale . Diversi tipi di architetture di apprendimento profondo tra cui reti

neurali profonde, reti neurali ricorrenti e reti neurali convoluzionali sono state applicate

a vari campi tra cui visione artificiale , riconoscimento vocale , elaborazione del

linguaggio naturale , traduzione automatica , bioinformatica , progettazione di

farmaci , analisi delle immagini mediche , scienza del clima , ispezione dei materiali

e gioco da tavolo, dove hanno prodotto risultati paragonabili, e in alcuni casi anche

superiori, alle prestazioni che sono in grado di avere gli esperti umani.

Il funzionamento delle reti neurali artificiali (ANN) si ispira al modo in cui vengono

elaborate le informazione e al modo in cui avviene la comunicazione nei sistemi

biologici . Possiamo affermare però che esse presentano però varie differenze rispetto

6
ai cervelli biologici. Nello specifico, le reti neurali artificiali tendono ad essere statiche

e simboliche, mentre il cervello biologico della maggior parte degli organismi viventi è

dinamico (plastico) e analogico.

Riassumendo quindi possiamo dire che RL considera il problema di un agente

computazionale che impara a prendere decisioni per tentativi ed errori e che il deep RL

incorpora quindi il deep learning(DL) nella soluzione, consentendo agli agenti di

prendere decisioni da dati di input non strutturati senza ingegneria manuale dello spazio

di stato. Gli algoritmi Deep RL sono in grado di accettare input molto grandi (ad es.

ogni pixel visualizzato sullo schermo in un videogioco) e decidere quali azioni eseguire

per ottimizzare un obiettivo (ad es. massimizzare il punteggio del

gioco). L'apprendimento per rinforzo profondo è stato utilizzato per una serie

diversificata di applicazioni tra cui, a titolo esemplificativo, ma non esaustivo,

robotica , videogiochi , elaborazione del linguaggio naturale , visione artificiale ,

istruzione, trasporti, finanza e assistenza sanitaria. Data la complessità e continua

evoluzione della materia trattata si è ritenuto opportuno introdurre sommariamente i

concetti che sono alla base della teoria dell’apprendimento e che ne costituiscono le

vere e proprie fondamenta e cioè il Machine Learning, il Reinforcement Learning e il

Deep Learning.

1.1 Il Machine Learning

È possibile far risalire gli albori del Machine Learning già all’Inghilterra Vittoriana, ma

è solo in seguito che esso ha avuto una svolta decisiva grazie alle teorie innovative di

Alan Turing il quale, nel 1950, ipotizzò la necessità di realizzare algoritmi specifici per

realizzare macchine capaci di apprendere: nell’articolo “Computing Machinery and

7
Intelligence” introdusse i concetti base per modellare un’intelligenza artificiale. Quando

si parla di Machine Learning si affronta quindi una branca dell’informatica nota come

AI (intelligenza artificiale) in cui l’attenzione si sposta dal programmatore alla

macchina stessa: non è più l’essere umano che tenta di codificare algoritmi al fine di

trovare soluzioni ad un determinato problema ma, al contrario, è la macchina che, in

base ai dati di input e alle risposte fornitele, determina le regole per risolvere il

problema tramite un processo di apprendimento automatico. Nel 1959 fu Arthur

Samuel, a definire esplicitamente il Machine Learning come: "field of study that gives

computers the ability to learn without being explicitly programmed" [1]. Le basi del

Machine Learning sono essenzialmente date dalla teoria della probabilità e statistica.

Come riportato nel testo “Deep reinforcement learning: An overview” [2] il ML, ad

oggi, trova applicazione in diversi ambiti della società moderna, arrivando ad

influenzare le scelte dei suoi utilizzatori, grazie allo sviluppo di intelligenza artificiale in

grado di intercettare e risolvere problematiche quali, ad esempio, il riconoscimento di

un oggetto all’interno di un’immagine, la trascrizione in formato testuale dei messaggi

audio, o ancora il posizionamento di annunci pubblicitari personalizzati per ogni

specifico utente. Ciascun algoritmo di machine learning si compone essenzialmente di

cinque parti fondamentali: dataset, modello, funzione d’errore e procedura di

ottimizzazione: il dataset viene diviso in diverse parti non sovrapponibili, una per il

training dell’algoritmo e una per la sua validazione; la funzione d’errore misura le

performance del modello rispetto al livello di accuratezza dei risultati prodotti

dall’algoritmo. Attualmente, a secondo delle modalità di apprendimento e di

determinazione delle regole utilizzate, si possono individuare tre categorie che

differiscono non solo per gli algoritmi utilizzati, ma soprattutto per lo scopo per cui

8
sono realizzate le macchine stesse: apprendimento supervisionato, non supervisionato e

Reinforcement Learning.

Nell’apprendimento supervisionato vengono forniti all’algoritmo una serie di dati di

input e di informazioni relative ai risultati desiderati e l’obiettivo perseguito è quello

che il sistema identifichi una regola generale che associ l’input all’output corretto. La

classificazione e la regressione sono due tipi di apprendimento supervisionato che

fornisco rispettivamente come output una categorizzazione e una quantità numerica.

Nell’apprendimento non supervisionato invece, al sistema vengono forniti solo set di

dati, non etichettati, senza alcuna indicazione sulla loro categoria di appartenenza: in

questo caso l’obiettivo è quello di risalire a schemi e modelli nascosti ovvero

identificare negli input una logica di struttura senza appunto che questi siano

preventivamente etichettati. A differenza degli altri due precedenti, invece

l’apprendimento per rinforzo, opera tramite feedback di valutazione ma senza

meccanismi di supervisione. In questa tipologia di apprendimento il sistema interagisce

con un ambiente dinamico per ottenere i dati in input e raggiungere un obiettivo,

raggiunto il quale si riceve una “ricompensa” (reward), di fondamentale importanza è

imparare anche dagli errori, il comportamento del sistema è basato su una politica di

ricompense e rilevazioni di errori. Possiamo infine concludere che il reinforcement

learning è diverso dal learning supervisionato, in cui si parte da un training set di esempi

già classificati che quindi offrono all’algoritmo già un certo grado di conoscenza. Ogni

elemento di questo training set possiede una specifica (label) che indica la corretta

azione che il sistema dovrebbe intraprendere in quella situazione, che di solito consiste

nell’identificazione di una categoria a cui quella situazione appartiene. L’algoritmo in

questo caso cerca di estrapolare e generalizzare le informazioni e la conoscenza

9
contenuta nel training set per poi essere utilizzata per identificare le label corrette non

presenti negli insiemi di test. Il reinforcement learning si differenzia anche dal learning

non supervisionato che consiste tipicamente nell’estrapolare conoscenza e associazioni

da dati non classificati. Quello supervisionato e quello non supervisionato sono

importanti metodi di learning ma non adeguati per imparare dalle interazioni. Nei

problemi interattivi in effetti è molto spesso impraticabile ottenere esempi di

comportamenti desiderati che siano, sia corretti che rappresentativi di tutte le situazioni

nel quale l’agente potrebbe trovarsi ad operare. In queste situazioni costituite anche da

territori inesplorati un agente dovrebbe poter imparare solo dalla propria esperienza.

Ecco che nel reinforcement learning si cerca di massimizzare un segnale di reward

invece di provare ad estrapolare conoscenza nascosta dai dati.

1.2 Gli algoritmi di Reinforcement Learning

La tecnica di apprendimento di Reinforcement Learning (RL) come già accennato, mira

a creare degli agenti, che operano in un certo ambiente, tali agenti sono in grado di

risolvere task basandosi su dati che variano nel tempo il che implica che tali agenti

avranno un comportamento dinamico, rispetto ai dati elaborati, per cui le azioni da essi

eseguite in un dato istante saranno influenzate da quelle effettuate in precedenza. La

risoluzione di un determinato task si ottiene addestrando l’algoritmo, che rappresenta

l’agente, attraverso il meccanismo delle ricompense, al raggiungimento di obiettivi

prefissati e disincentivando invece quei comportamenti non desiderabili.

Contrariamente a quanto il linguaggio naturale potrebbe suggerire, il termine

ricompensa, viene usato per indicare sia una quantità positiva che negativa: lo scopo

primario dell’agente è quello di massimizzare tale ricompensa apprendendo delle abilità

elementari che lo stimolino in tal senso. Rispetto al paradigma dell’apprendimento

10
supervisionato il reinforcement learning differisce in quanto non necessita di un set di

dati di confronto per poter sviluppare conoscenza, a tale scopo l’accento si pone sul

trovare il giusto bilanciamento tra l’esplorazione di scelte non ancora effettuate e la

conoscenza di quelle già affrontate. Le tecniche di apprendimento per rinforzo si

applicano bene quindi alla risoluzione di task di controllo. Una delle prime strategie di

reinforcement learning fu introdotta nel 1957 da Richard Bellman e denominata

dynamic programming (DP): il problema viene scomposto in sotto problemi di

dimensione sempre minore e di più facile risoluzione che conducono in ultima istanza

alla risoluzione del problema principale. Tale metodologia risultò però non sempre

applicabile in maniera generalizzata a tutti i task di controllo in quanto l’insorgere di

eventi inattesi, non più catalogabili come già affrontati o da affrontare, ne andava a

limitare la funzionalità. Inoltre si riscontrò un ulteriore vincolo dovuto al livello di

conoscenza dell’ambiente posseduto, che rendeva necessario variare la strategia di

risoluzione del problema. Per ovviare a tali problemi si rese necessario ricorrere ad una

strategia "per tentativi" (trial and error) che generalmente si riconduce ai metodi Monte

Carlo, che includono una vasta classe di algoritmi computazionali, i quali effettuano un

campionamento casuale dell’ambiente per ottenere risultati numerici. L’esperienza ha

dimostrato che la strategia più idonea nell’affrontare task di reinforcement learning è

quella che combina l’applicazione di metodi per tentativi, da cui possiamo ricavare

conoscenza dell’ambiente, con quella di scomposizione in sotto problemi noti. Alcuni

esempi di problemi che possono essere risolti con il Reinforcement Learning ed

applicazioni che ne hanno favorito lo sviluppo sono:

• L’esecuzione di una mossa da parte di un giocatore di scacchi: la strategia è

volta ad anticipare mosse e contromosse dell’avversario.

11
 • L’ottimizzazione dei parametri in tempo reale di una raffineria di petrolio da

parte di un controllore: tale operazione consiste nel perfezionare il trade-off

rendimento/costi/qualità basandosi su specifici costi marginali.

• L’apprendimento delle abilità motorie da parte di una gazzella: qualche minuto

dopo essere nata si alza in piedi, dopo qualche ora è già in grado di correre a 20

miglia all’ora;

• La decisione di un robot aspirapolvere di iniziare a pulire una nuova stanza

oppure rientrare alla base per ricaricarsi: il fattore discriminante sarà dato da un

lato dall’attuale livello di carica delle batterie e dall’altro dalla velocità e facilità

con cui in passato è stato in grado di raggiungere la stazione di ricarica.

Tutti questi esempi condividono delle caratteristiche basilari facili da individuare, in

particolare: in ognuno di essi è presente un’interazione tra un agente attivo, capace di

prendere decisioni, e l’ambiente in cui è immerso, nel quale cerca di raggiungere un

obiettivo in contrasto con l’incertezza dell’ambiente stesso. Le azioni che l’agente

esegue permettono di simulare lo stato futuro dell’ambiente in tal modo l’agente potrà

capire quali azioni e opportunità saranno disponibili in seguito il che, nel caso degli

esempi riportati sopra si traduce in: la previsione della successiva posizione di un pezzo

sulla scacchiera, la previsione del livello delle riserve della raffineria, della posizione

successiva del robot e del futuro livello di carica. Pe arrivare alla scelta corretta

dell’azione ad intraprendere è necessario anche tener conto delle conseguenze a

posteriori in modo da di indurre una certa capacità di pianificazione e previsione. Al

tempo stesso l’effetto delle azioni non può essere totalmente determinato e per tale

ragione l’agente deve costantemente monitorare l’ambiente e reagire di conseguenza. Ci

sono obiettivi espliciti con cui l’agente può giudicare i suoi progressi una volta che

12
questi vengono raggiunti che nel caso degli esempi citati si traducono in: il giocatore di

scacchi riconosce quando ha vinto o meno, il controllore della raffineria sa quanto

petrolio viene prodotto, la gazzella percepisce un’imminente caduta ed infine il robot

stima quando la batteria sarà scarica. L’agente però può usare anche la propria

esperienza per migliorare le sue performance nel tempo in modo che, ad esempio,

durante il gioco si raffini l’intuizione riguardo la valutazione delle successive posizioni

degli scacchi oppure o nel caso dell’esempio della gazzella, possa migliorare

l’efficienza della corsa. La conoscenza che l’agente porta all’inizio della risoluzione del

task può derivare da task simili svolti precedentemente oppure costituita da una

specifica posta all’interno dello stesso algoritmo mentre l’interazione con l’ambiente è

essenziale per correggere il comportamento dell’algoritmo al fine di adattarsi alle

specifiche esigenze del compito in esecuzione.

Nel seguito di questo paragrafo viene definito il RL in termini delle sue componenti

principali quali: Policy, funzione valore, condizione di ottimalità di Bellman e in termini

di controllo ottimo di un processo decisionale di Markov. Sarà quindi effettuata

un’analisi di alcuni tra i più comuni algoritmi nello specifico SARSA e Q-Learning per

poi spostarsi, nel prossimo paragrafo, il paragrafo tre, su algoritmi più avanzati basati su

reti neurali come Deep Q-Network. La trattazione che segue trae spunto da [3].

Come già detto in precedenza il RL permette ad un agente di scoprire in totale

autonomia, senza il meccanismo di supervisione, il corretto comportamento da eseguire.

L’apprendimento dell’agente è dato dalla continua interazione con l’ambiente da cui

esso ottiene uno stato, ma anche dalle azioni che l’agente stesso decide di intraprendere

e che vanno a modificare lo stato stesso, dove l’ambiente è definito come tutto ciò che

13
circonda l’agente e con cui esso può interagire. Il funzionamento di algoritmi di

reinforcement learning può essere sintetizzato nella figura 1.1 che segue:

Figura 1.1: Funzionamento Reinforcement learning

Notiamo che in un dato time step t, sia l’agente che l’ambiente si trovano in uno stato s,

che contiene tutte le informazioni rilevanti sulla situazione, come ad esempio la

posizione di un oggetto. Dallo stato s può essere eseguita un’azione a, ottenendo quindi

una coppia stato-azione. L’insieme di tutte le coppie stato-azione, può essere sia

discreto sia continuo. Prima di passare al successivo time step, t+1, l’agente riceve un

premio (reward) che viene trasferito al prossimo stato. Ciò che permette di determinare

quale azione scegliere quando ci si trova in un determinato stato è la policy. Il concetto

di policy sarà definito e approfondito nel successivo paragrafo, insieme a quelli che

sono gli altri elementi che contraddistinguono il RL. Per adesso continuiamo dicendo

che all’agente non viene detto quale azione intraprendere, ma è lui che deve scoprire

quale azione porterà ad ottenere un reward maggiore semplicemente provando ed

esplorando l’insieme delle azioni possibili. Nei problemi più interessanti le azioni
14
possono condizionare non solo il reward immediato ma anche la successiva situazione e

il conseguente stato che si verrà a creare, e quindi condizionare anche i successivi

reward. Per ottenere molti reward, o reward alti, l’agente deve preferire azioni che ha

già provato in passato e per cui ha già ottenuti reward elevati. Ma per scoprire queste

azioni, deve provare azioni che non ha mai selezionato prima. Quindi l’agente deve da

un lato sfruttare quello che ha già avuto modo di apprendere per ottenere il reward,

dall’altro esplorare nuove strade per selezionare migliori azioni nel futuro.

1.2.1 Componenti del Reinforcement Learning

Oltre agli agenti e all’ambiente, possiamo identificare altri sotto elementi nel paradigma

di reinforcement learning che sono: policy, segnale di reward, funzione valore e

modello dell’ambiente. La policy definisce il modo con cui l’agente apprende e il suo

comportamento in un dato istante. Per semplificare, una policy può essere vista come il

mapping di tutti gli stati percepibili dall’ambiente e le azioni da prendere quando si è in

tali stati. In alcuni casi la policy può essere espressa come semplice funzione o tabella di

ricerca, mentre in altri può coinvolgere anche una ulteriore computazione come i

processi di ricerca. La policy è il cuore di un agente di RL nel senso che da sola

determina il suo comportamento. In generale, le policy possono essere deterministiche,

quando a partire da un per un certo stato viene intrapresa sempre la stessa azione,

oppure probabilistiche, quando l’azione da intraprendere quando ci si trova in un

determinato stato viene scelta in base al calcolo della distribuzione di probabilità tra le

possibili azioni e lo stato dato. Il segnale di reward, possiamo dire che rappresenta il

goal in un problema di reinforcement esso definisce così quali sono i buoni ed i cattivi

comportamenti per l’agente. In ogni time step, l’ambiente invia all’agente un singolo

valore chiamato appunto reward. L’unico obiettivo dell’agente è quello di massimizzare

15
il reward totale che riceve durante un episodio del programma. Questo segnale è la base

di partenza per cambiare in modo appropriato la policy, infatti se un’azione selezionata

dalla policy è seguita da un reward basso, allora la policy potrebbe cambiare per

selezionare qualche altra azione in una situazione futura.

Mentre il reward indica cosa è buono nell’immediato, la funzione valore specifica cosa

è buono nel lungo termine. Il valore dello stato è l’ammontare totale dei reward che un

agente si aspetta di accumulare nel futuro, partendo da quello stato. La funzione valore

quindi determina la desiderabilità a lungo termine degli stati dopo aver preso in

considerazione gli stati migliori da seguire e i reward disponibili in questi stati.

Per esempio uno stato potrebbe sempre portare un reward immediato basso ma avere

ancora un valore alto poichè è regolarmente seguito da altri stati che portano reward alti,

e viceversa. Per fare un’analogia umana, i reward sono come il piacere (reward alto) o il

dolore (reward basso). I reward sono in un certo senso, elementi primari, mentre i

valori, intesi come predizione dei reward, sono secondari. Senza reward non ci possono

essere valori e l’unico scopo di stimare i valori è quello di raggiungere reward più alti.

Pure essendo elementi secondari, sono però i valori gli elementi di confronto utilizzati

quando si valutano le decisioni da prendere. Le scelte delle azioni sono fatte sulla base

di giudizi sui valori. Si cercano le azioni che producano stati a massimo valore, non a

massima ricompensa, perché queste azioni ottengono maggior ricompensa nel lungo

periodo. Sfortunatamente, è molto più difficile determinare i valori che determinare i

reward. I reward sono fondamentalmente dati direttamente dall’ambiente mentre i valori

devono essere stimati e re-stimati dalle sequenze di osservazioni che un agente compie

durante la sua intera esistenza. In effetti, la componente più importante di quasi tutti gli

algoritmi considerati è un metodo per stimare in modo efficiente i valori, anche se tale

16
ragionamento non è detto sia valido per qualsiasi ambiente. Il quarto ed ultimo elemento

è il modello dell’ambiente. Per modello si intende un’entità in grado di simulare il

comportamento dell’ambiente. Per esempio, data una coppia stato-azione, il modello

può predire il risultato della prossima coppia stato-azione. I modelli sono usati per

pianificare, ovvero decidere prima quali azioni saranno eseguite sulla base degli stati

che potranno essere raggiunti. Vediamo più nel dettaglio come viene viene modellato

l’ambiente.

1.2.2 Modello dell’ambiente: Markov Decision Process

A questo punto proviamo a dare una descrizione formale dell’ambiente. Diciamo subito

che non è necessario sapere esattamente come è fatto l’ambiente ma piuttosto formulare

delle ipotesi generali sulle proprietà che esso possiede. In genere nel RL si assume che

l’ambiente possa essere descritto da un Processo di Decisione Markoviano (Markov

Decision Process o MDP). Formalmente un Markov Decision Process è definito da:

 un insieme finito di azioni A.

 un insieme finito di stati S.

 una funzione di transizione T ¿che assegna ad ogni coppia

stato-azione una distribuzione di probabilità su S.

 una funzione di rinforzo (o reward) R (R : S × A × S → R)che assegna un

valore numerico ad ogni possibile transizione.

L’interazione stato-ambiente avviene nel seguente modo:

all’istante t l’agente percepisce l’ambiente come uno stato st ∈ S e sulla base di st decide

di agire con una determinata azione a t ∈ A . L’ambiente risponde dando all’agente una

ricompensa immediata (reward) r t +1=r (s t , at ) e producendo lo stato successivo

st +1=δ(st , at ). Le funzioni δ e r sono parte dell’ambiente e non sono necessariamente

17
note all’agente (esse possono essere non-deterministiche). Si dice che un problema o

ambiente soddisfa l’ipotesi Markoviana (Markov Property) quando:

P[s t +1=s , r t +1=r ∨s t , at ]=P[ st +1=s , r t +1=r ∨s t , a t ,r t , … r 1 , s 0 , a0 ] (1.1)

L’ipotesi Markoviana implica che quello che succede all’istante t + 1, (st +1 , r t +1)

dipende solo da quello che è successo all’istante precedente (st ,r t ) e non da tutto

ciò che è successo in precedenza (st ,a t , r t , …r 1 , s 0 , a0 ). Se un problema soddisfa

l’ipotesi Markoviana ha una dinamica che può essere descritta con una “dinamica ad un

passo”: cioè il problema può essere trattato come episodico, dove gli episodi sono i

ripetuti tentativi di raggiungere un determinato obiettivo stabilito dal problema. La

proprietà di Markov è molto importante nel RL perchè tutti i metodi legati a questo tipo

di apprendimento basano le proprie scelte sull’assunto che i valori forniti dall’ambiente

siano funzione solo dello stato corrente e dell’azione intrapresa all’istante precedente.

1.2.3 Valore di ritorno

In buona sostanza l’obiettivo di un agente di RL è quello di scegliere una policy che

massimizzi la somma dei reward attesa. La somma dei reward viene chiamata valore di

ritorno (Gt ) ed è data da:

Gt =r t + r t +1+ r t+ 2+ …+r N−1 (1.2)

Per compiti a valore continuo, invece del valore di ritorno, viene definito il discount

return che è dato da:

∞
Gt =r t + γ r t +1 +γ 2 r t+ 2+ …=∑ γ k r t +k (1.3)
k=0

dove γ ϵ ¿ è detto fattore di discount.

18
1.2.4 La funzione valore

Per decidere quale azione intraprendere in un certo istante, è importante per l’agente

conoscere quanto è “buono” essere in un particolare stato. Un modo per misurare questa

bontà dello stato è la funzione valore. Essa è definita come la somma dei rewards attesa

(E π ) che l’agente riceverà mentre segue una particolare policy π partendo da un

particolare stato s. Per una data la policy π la funzione valore, V π (s) è data da:
∞
V π ( s )=E π ( Gt|s t =s )=E π ( ∑ γ k r t +k ∨st =s) (1.4)
k=0

Invece una funzione azione-valore(action value function), chiamata anche Q-function,

può essere definita come la somma dei rewards prevista mentre si intraprende un’azione

a in uno stato s, seguendo la policy π . La funzione azione-valore Q π ( s , a ) è definita

come segue:

(∑ | )
∞
Q π ( s , a )=E π ( Gt|s t =s , at=a ) =Eπ γ k r t +k s t=s , at =a (1.5)
k=0

1.2.5 Equazioni di Bellman

Mediante le equazioni di Bellman il problema di massimizzazione della somma dei

reward attesa può essere formulato in termini di relazione ricorsiva con la funzione

valore. Una policy π è considerata migliore di un’altra policy π ' se il ritorno atteso per

quella policy è maggiore di quello atteso per π ' e questo per tutti gli s ∈ S, che implica

V π ( s ) ≥ V π (s) per tutti gli s ∈ S . La funzione valore ottimale V ¿ (s) quindi può essere
'

definita come:

V ¿ ( s ) =max V π ( s ) , ∀ s ∈ S (1.6)

Similmente, la funzione azione-valore ottimale Q¿ (s , a) può essere definita come:

Q¿ ( s , a ) =max Q¿ (s , a)∀ s ∈ S , a∈ A (1.7)

19
Inoltre, per una policy ottimale, possiamo definire l’equazione:

V ¿ ( s ) = max Q π (s , a) ¿
(1.8)
a ∈ A (s)

Sostituendo la 1.5 nella1.8 otteniamo:

V ¿ ( s ) =max E π ( G t|st =s , at =a ) =max E π ¿ ¿

¿ ¿

a a

Nel primo passaggio è stata effettuata la scomposizione ricorsiva di Gt (come

nell’equazione 1.3), mentre nel secondo passaggio si pone:

E π [ ]=∑ p ( s '|s , a ) [ ] (1.10)

'
s

dove p ( s '|s , a ) indica la probabilità di arrivare nello stato s' partendo dallo stato s

ed intraprendendo l’azione a.

L’equazione 1.9 è conosciuta come equazione di ottimalità di Bellman per V ¿ (s) .

Mentre per Q¿ l’equazione di ottimalità è:

( a
'
'
| ) s
' [
Q¿ ( s , a ) =E r t + γ max Q¿ ( s t +1 , a ) s t=s , at =a =∑ p ( s |s , a ) r t +γ max Q¿ ( s ,a ) (1.11)
'

a
'
' '
]
dove Q¿ (s , a) è definita ricorsivamente in base alle equazioni 1.5 e 1.7.

Le equazioni di ottimalità di Bellman possono essere risolte in modo iterativo a patto

che siano conosciute le probabilità di transizione e le funzioni di reword. Tale approccio

è noto come programmazione dinamica e i corrispondenti algoritmi sono conosciuti

come algoritmi model-based, essi presuppongono che le probabilità di transizione siano

conosciute, o che al limite vengano stimate sul momento. Per altri algoritmi invece,

quelli conosciuti come algoritmi model-free si assume che le probabilità non siano

conosciute e che debbano essere stimate sia policy che funzione valore attraverso un

rollout del sistema, ovvero applicando uno o più step di simulazione per testare le

possibili conseguenze. Gli algoritmi model-free più comunemente usati sono: Monte

Carlo, Temporal Difference e Policy Search. Nel seguito del paragrafo ci focalizzeremo

20
sui metodi model-free per poi poter introdurre gli algoritmi Q-learning e, nel successivo

paragrafo, Deep Q-Learning.

1.2.5.1 Metodi model-free

Gli approcci model-free che non richiedono alcun modello dell’ambiente, possono

essere classificati anche come approcci on-policy o approcci off-policy. I primi cercano

di apprendere la funzione valore e da essa desumere la policy ottimale, i secondi

ricercano la policy ottimale direttamente nello spazio dei parametri della policy stessa.

Inoltre i metodi on-policy utilizzano la policy corrente per generare azioni e per

aggiornare la policy stessa mentre i metodi off-policy utilizzano una policy di

esplorazione diversa per generare azioni rispetto alla policy che viene aggiornata.

Vediamo ora nel dettaglio due tipologie di metodi model-free: i metodi Monte Carlo e

quelli Temporal Difference.

I metodi Monte Carlo

I metodi Monte Carlo lavorano sull’idea della GPI (generalized policy iteration). La

GPI è uno schema iterativo ed è composto da due processi. Il primo prova a costruire

un’approssimazione della funzione valore basandosi sulla policy corrente (policy

evaluation step). Nel secondo step, la policy viene migliorata rispetto alla funzione a

valore corrente (policy improvement step). Nei metodi Monte Carlo, per stimare la

funzione valore si utilizza la tecnica del rollout eseguendo la policy corrente sul sistema.

La funzione valore viene poi stimata utilizzando il reward accumulato sull’intero

episodio e la distribuzione degli stati incontrati. La policy corrente è quindi stimata

attraverso tecnica greedy. Utilizzando questi due step in modo iterativo, è possibile

dimostrare che l’algoritmo converge alla funzione e alla policy del valore ottimale.

Sebbene i metodi Monte Carlo siano semplici nella loro implementazione, richiedono
21
un gran numero di iterazioni per la loro convergenza e soffrono di una grande varianza

nella stima della funzione valore.

I metodi Temporal Difference

Anche i metodi Temporal Difference (TD) si basano sull’idea della GPI ma differiscono

dai metodi Monte Carlo nell’ evaluation step della policy. Questi metodi calcolano

l’errore temporale, ovvero la differenza tra la nuova stima e la vecchia stima della

funzione valore, considerando il reward ricevuto al time step corrente e utilizzandolo

per aggiornare la funzione valore, invece di usare la somma totale di renard. Un simile

modo di aggiornamento riduce la varianza ma incrementa il bias nella stima della

funzione valore. Per aggiornare la funzione valore è usata l’equazione:

'
V ( s) ←V ( s)+α [r +γ V (s )+V ( s)]( 1.12)

nella 1.12 α rappresenta il fattore di learning, r è il reward ricevuto nell’istante

corrente, s è il vecchio stato e s' è il nuovo stato, da essa si nota che nei metodi temporal

difference la funzione valore viene aggiornata ad ogni time step, al contrario dei metodi

Monte Carlo che per aggiornare la funzione valore che l’episodio sia completato. Per

risolvere problemi di reinforcement learning i due algoritmi TD più diffusi sono

SARSA e Q-Learning.

Algoritmo Sarsa

SARSA è un metodo temporal difference on-policy,ovvero tenta di apprendere la

funzione azione-valore invece della funzione valore. Lo step di evaluation usa l’errore

temporale per la funzione azione-valore, come avviene in modo simile per la funzione

valore. Di seguito riportiamo la descrizione dell’algoritmo:

Algoritmo SARSA
22
In(s,a) random
repeat
Osserva stato iniziale s1
Seleziona un’azione a1 usando la policy derivata da Q (es: ϵ-greedy)
for t=1 to T do
Esegui azione a 1
Osserva il reward rt e il nuovo stato st+1
Scegli la nuova azione at+1 la policy derivata da Q (es: ϵ-greedy)
Aggiorna Q usando
Q ( s t , at ) ←Q ( st , a t ) + α [r t + γ Q ( s t +1 , at +1 )−Q ( s t , a t ) ]
end for
until terminazione

Algoritmo Q-Learning

Q-Learning è un algoritmo temporal difference off-policy, questo algoritmo fu istruito per

la prima volta nel 1989 da Watkins, come citato in [4]. A differenza di SARSA, esso

approssima direttamente Q¿ indipendentemente dalla policy che sta seguendo. Ogni

esperienza è definita dall’insieme (s , a , r , s ' ) il che vuol dire che l’agente partendo

dallo stato s, dopo aver eseguito l’azione a e aver ricevuto un reward r, si muove inverso

un nuovo stato s' . Ricevendo il reward massimo possibile da un’azione nello stato s' si

ottiene l’aggiornamento su Q(s , a) che è dato da :

Q ( s t , at ) ←Q ( st , a t ) + α [r t + γ max Q ( st +1 , at ) −Q(st ,a t )] 1.13

a

Di seguito si riporta la descrizione dell’algoritmo:

Algoritmo Q-Learning

Inizializza Q(s,a) random

23
repeat

Osserva stato iniziale st

for t=1 to T do
Scegli un’azione at usando la policy derivata da Q (es: _-greedy)
Esegui azione at
Osserva il reward rt e il nuovo stato st+1
Aggiorna Q usando 1.13
end for

until terminazione

Per salvare i valori della funzione valore per ognuno dei differenti stati, il metodo più

semplice è utilizzare la forma tabellare. Questo metodo presenta però alcune limitazioni:

se lo spazio degli stati del problema è molto vasto risulta impossibile salvare tutti i

valori nel formato tabellare in quanto la memoria richiesta per salvare tutti questi dati

risulterà troppo vasta. Inoltre anche la ricerca nella tabella di un solo valore in un

particolare stato potrebbe essere proibitiva dal punto di vista computazionale. Infine uno

spazio degli stati continuo comporterebbe una ulteriore limitazione in quanto

risulterebbe impossibile utilizzare la forma tabellare, a meno di una rielaborazione o

meglio discretizzazione degli stati stessi. Questi sono i motivi che portano ad adottare il

formato tabellare solamente ad ambienti con ridotto numero di stati e azioni.

Al fine di superare questi problemi sono stati introdotti approssimatori di funzione in

cui viene salvata la funzione valore. Essa viene parametrizzata da un vettore

T
θ ¿(θ 1 , θ2 , ⋯ ,θ n) che è indicato con V ( s , θV ) . L’approssimatore di funzione può essere

pensato come ad un mapping tra il vettore θ in Rn con lo spazio della funzione

valore. Il cambiamento di un valore di un certo parametro comporta il cambiamento

della funzione valore in più regioni dello spazio degli stati, questo fintato che il numero
24
dei parametri dell’approssimatore è minore del numero di valori di stato, ciò fa sì che gli

approssimatori di funzione effettuino una migliore generalizzazione in un numero di

passi di training minore.

Esistono vari metodi per l’approssimazione di funzione. Per brevità nel prossimo

paragrafo verranno trattare solamente le Reti Neurali, in maniera generale, per poi

focalizzare l’attenzione nel paragrafo 1.4 sull’algoritmo di Deep Q-Learning.

1.3 Le reti neurali

Per risolvere problemi complessi le reti neurali artificiali (ANN Artificial Neural

Network) sono uno degli strumenti attualmente più utilizzati, sono modelli ispirati

alla natura infatti quello che rende le ANN particolarmente interessanti è la possibilità

di riprodurre molte delle caratteristiche del cervello umano, quali ad esempio la capacità

di parallelismo, abilità di apprendimento, di generalizzazione, tolleranza a failure e

basso consumo di energie, come spiegato nella fonte [5] di questa tesi. Di seguito

riportiamo la struttura del neurone biologico:

FIGURA 1.1 STRUTTURA DEL NEURONE BIOLOGICO [7]

25
Le reti neurali artificiali imitano il comportamento dalle reti neurali biologiche durante

la fase di apprendimento possiamo dire che esse si ispirano proprio al funzionamento

biologico del cervello caratterizzato dalla trasmissione di informazioni all’interno di una

rete di neuroni. Ogni neurone biologico è composto da una parte centrale, detta corpo

cellulare, in cui risiede il nucleo che regola tutte le attività del neurone stesso. Dal corpo

cellulare hanno origine due tipi di prolungamenti, detti dendriti e assoni. I dendriti

hanno il compito di ricevere i segnali da migliaia di altri neuroni, per poi propagarli

verso il nucleo, l’assone, invece, conduce il segnale dal nucleo verso i dendriti di altri

neuroni permettendo la propagazione dell’impulso nervoso tra cellule diverse, come

spiegato nella fonte [6] che riportiamo in bibliografia. Ciascun neurone esegue una

elaborazione molto semplice che possiamo riassumere in acquisire i segnali, elaborare la

risposta, trasmettere il nuovo segnale, quindi è grazie alla connessione rapida ed

efficiente tra tutte le cellule che si sviluppa quella che definiamo intelligenza.

Una rete neurale artificiale, in analogia alla struttura biologica appena descritta, è

costituita dall’interconnessione di tante semplici unità di elaborazione, dette neuroni

artificiali, che prendono tanti input dall’esterno, li codificano in quello che rappresenta

il corpo cellulare, per così dire, e li propagano verso le altre unità. Nel modello

artificiale un parametro che influenza il risultato della rete, è il cosiddetto peso sinaptico

che viene inserito per tenere conto dell’importanza degli ingressi. La rete ANN è un

sistema adattivo cioè un sistema che durante l’allenamento cambia la propria struttura

con l’obiettivo di avere un output della rete sempre più simile a quello desiderato. A tale

scopo vengono variati i valori dei pesi sinaptici, questo parametro può assumere un

qualsiasi valore reale. L’obiettivo della rete è di minimizzare la differenza tra output

26
reale e quello predetto dall’algoritmo a partire da una serie di dati di input e dagli stessi

output associati agli ingressi. Durante la fase di addestramento della rete, si cercherà

dunque una combinazione di pesi che permetta di minimizzare questa differenza. In

questo modo, a partire dagli esempi con cui si è allenata, la rete costruirà una mappa

input-output del sistema.

1.3.1 Il modello matematico del neurone

Per capire il ruolo dei pesi all’interno della rete risulta fondamentale descrivere la

funzione matematica che modellizza ogni neurone artificiale. L’unità di elaborazione

riceve in ingresso una serie di input e dà come uscita una combinazione lineare dei suoi

ingressi nel seguente modo:

FIGURA 2 MODELLO DEL NEURONE ARTIFICIALE [8]

dove:

• xn = ingresso relativo all’assone del n-esimo neurone a monte della connessione;

• wn = peso, o weight, della connessione n-esima;

• a = funzione di attivazione del neurone, ovvero la legge che regola la sua uscita.

Secondo tale modello, il neurone artificiale riceve dei valori in ingresso (x1, x2, ...,

27
xn) (tanti quanti sono i dati di input scelti dall’operatore) che vengono moltiplicati

per il peso della connessione corrispondente (w1, w2, ....., wn). Successivamente i

risultati di tutte le moltiplicazioni vengono sommati tra loro, ottenendo un valore

di attivazione a. Se tale valore supera una data soglia, il neurone genera un segnale di

uscita y, altrimenti rimane silente, come mostrato di seguito:

{
N
y=1 , se ∑ w i x i >0
i=1
N
y=0 , se ∑ w i x i <0
i=1

Il neurone così descritto può essere assimilato ad un modello matematico di

classificazione che, a seconda del risultato della moltiplicazione tra input e peso,

restituisce un output. Dal momento che i dati di input e il valore soglia sono definiti

prima dell’inizio dell’addestramento, l’unico parametro che può essere cambiato al fine

di ottenere un output differente è il valore dei pesi w n. Nella fase di allenamento

l’algoritmo cercherà di modificare i pesi in modo tale che l’output sia più vicino

possibile a quello desiderato. Nella figura che segue mostriamo questa variazione,

conosciuta come Delta Rule, la quale permette di variare i pesi in modo proporzionale ai

dati di input e all’errore δ operato dal neurone che è valutato come la differenza tra

l’uscita reale y e quella target yd, mentre la costante di proporzionalità è detta tasso di

apprendimento, tale parametro verrà approfondito in seguito.

28
 FIGURA 3 MODELLO DEL NEURONE CON DELTA RULE [8]

Dal momento che realizza una semplice combinazione lineare dei valori di ingresso,

questo tipo di modello non permette di gestire i problemi complessi. Per questo motivo

viene introdotta una funzione di attivazione diversa dalla semplice soglia. Tra le

principali funzioni di attivazioni esistenti ricordiamo la funzione sigmoidale che

determina valori di uscita compresi tra 0 e 1, e la tangente iperbolica che determina

valori compresi tra -1 e 1). Al fine di alleggerire l’onere computazionale, spesso

vengono utilizzate funzioni di attivazione ancora più semplici, come la ReLu che

permettono di mantenere comunque delle capacità di apprendimento molto elevate. Le

tre tipologie appena descritte sono mostrate nella figura che segue:

29
 FIGURA 4 FUNZIONI DI ATTIVAZIONI: A SINISTRA LA FUNZIONE SIGMOIDALE, AL
CENTRO QUELLA A TANGENTE IPERBOLICA, A DESTRA LA RELU [8].

1.3.2 L’architettura della rete

Com’è facile intuire, siccome un singolo neurone non è abbastanza per costruire un

algoritmo capace di prendere decisioni complesse, si possono utilizzare tante unità

neurali connesse tra loro che formano appunto una rete neurale. Le reti assumono una

struttura stratificata cioè sono composte da diversi livelli ciascuno dei quali contiene

una quantità distinta di neuroni. L’unità neurale di ogni strato riceve come input gli

output dei neuroni dello strato precedente e fornisce il proprio output ad ognuno dei

neuroni dello strato successivo, che lo accetta come input pesato. L’architettura più

semplice di una rete neurale artificiale è composta da tre layer in cui ogni neurone

elabora i segnali ricevuti dal livello precedente e trasmette il risultato alle unità

successive. Questo tipo di struttura è mostrato nella figura che segue:

30
 FIGURA 5 ARCHITETTURA A STRATI DI UNA SEMPLICE RETE NEURALE [9]

Di seguito vengono descritti i singoli strati:

 Il primo strato, detto input layer, è formato da neuroni che ricevono come

ingresso i dati del problema definiti dall’operatore.

 Lo strato intermedio, detto hidden layer(strato nascosto), esegue trasformazioni

non lineari degli input immessi nella rete. Nell’architettura più semplice è

presente solo un livello di questo tipo, ma nei modelli più complessi ci sono

diversi strati nascosti. Maggiore è il numero di livelli nascosti, maggiore sarà la

profondità della rete, il che permette di determinare astrazioni sempre maggiori.

31
  L’ultimo strato, chiamato output layer, sarà formato da tanti neuroni quanti

sono gli output del problema che si vuole risolvere. Se ad esempio si vuole

determinare il contenuto di una immagine che può rappresentare due oggetti

diversi, l’ultimo strato della rete sarà formato da due neuroni associati agli

oggetti da riconoscere. Nel caso di problemi di classificazione, il compito delle

unità neuronali consiste nel definire a quale categoria appartiene l’ingresso. Al

fine di consentire l’individuazione della categoria di appartenenza, l’output di

ogni neurone di questo livello viene convertito attraverso una funzione che può

anch’essa essere di diversi tipi. La più comunemente usata è la funzione softmax

che permette di trasformare i valori output, in una distribuzione di probabilità

normalizzata, in modo da permettere di individuare facilmente il neurone a cui è

associata una probabilità maggiore. Sarà questo neurone a identificare la classe

di appartenenza dell’oggetto in ingresso alla rete.

1.3.3 Addestramento della rete

Come appena accennato, l’addestramento della rete, consiste in un problema di

ottimizzazione. L’obiettivo della rete è di minimizzare la differenza tra output reale e

quello predetto dall’algoritmo, a partire da una serie di dati di input e dagli stessi output

associati agli ingressi. Per addestrare una rete neurale uno dei metodi più efficaci è

l’algoritmo di propagazione all’indietro dell’errore, che prevede che i valori dei pesi

vengono modificati iterativamente al fine di avvicinare sempre di più l’uscita prodotta

dalla rete al valore desiderato cioè l’output noto. L’errore commesso dall’algoritmo,

ovvero la distanza che intercorre tra gli output desiderati e i corrispondenti output della

rete, può essere descritto da una funzione detta funzione di costo. Durante

l’addestramento, l’algoritmo aggiorna iterativamente i pesi dei neuroni fino al

32
raggiungimento del minimo assoluto della funzione di costo. All’inizio dell’algoritmo di

retro-propagazione dell’errore i pesi vengono inizializzati in maniera casuale.

L’algoritmo consta di due fasi: la forward propagation e la backward propagation, come

mostrato nella figura che segue:

FIGURA 6 STRUTTURA DELLA RETRO-PROPAGAZIONE DEGLI ERRORI [10]

Durante la prima fase si calcolano le attivazioni dei neuroni in base al valore corrente

dei pesi procedendo così dal layer di input si arriva al layer di output. Una volta arrivati

al risultato dell’ultimo layer, si confronta questo risultato con il valore di output

desiderato e si calcola l’errore attraverso la funzione di costo. Inizia a questo punto la

33
fase di backward propagation in cui si correggono i pesi a partire dal layer di output fino

al layer di input. L’aggiornamento dei pesi sinaptici avviene in funzione dell’errore e di

un altro parametro del sistema molto importante detto tasso di apprendimento o learning

rate. Esso può assumere valori tra zero e uno e condiziona la velocità di apprendimento

dell’algoritmo, in effetti quanto più tale parametro si avvicina a uno tanto più rapido

sarà l’addestramento dal momento che questo causa una modifica maggiore del peso

sinaptico verso il valore ottimo. D’altro canto però, un learning rate molto alto comporta

un maggiore rischio di instabilità del sistema. Conviene quindi attribuire a tale

parametro un valore adeguato, in modo tale da portare a convergenza l’algoritmo nel

minor tempo possibile.

1.3.4 Le Reti convoluzionali

Le reti neurali convoluzionali (CNN) sono una tipologia di reti stratificate ispirate alla

corteccia visiva dei mammiferi, ovvero una regione del cervello che elabora le

immagini provenienti dal sistema visivo. A tale scopo le cellule appartenenti alla

corteccia sono suddivise in gruppi, ognuno dei quali estrae informazioni da una

specifica zona dell’immagine, agendo da filtro locale. Questo tipo di architettura è

ottimale per cercare forti correlazioni spaziali, caratteristica tipica delle scene naturali.,

Gli studiosi, visto le grandi performance di queste strutture, hanno cercato di riprodurle

con l’obiettivo di identificare e classificare il contenuto all’interno delle immagini in

modo molto accurato. Per analizzare un’immagine, essa viene rappresentata come una

matrice di pixel, ovvero una matrice di valori che indicano l’intensità di colore dei vari

punti dell’immagine. Utilizzando una rete neurale per analizzare l’immagine, ogni

valore della matrice rappresenterà un dato di input. Però questa tipologia di rete

presenta due limitazioni. La prima riguarda il numero di neuroni di input nel primo

34
strato della rete che risultea essere troppo elevato dal momento che è associato al

numero totale dei pixel dell’immagine (si noti che anche nel caso si immagini con

dimensioni contenute, il numero di pixel risulta essere molto alto), il che comporterebbe

un numero enorme di pesi di collegamento tra l’input layer e l’hidden layer che

aumenterebbe molto la complessità e il costo dell’algoritmo. Un secondo problema è

legato alla perdita della spazialità dei dati. Infatti considerando ogni pixel come un dato

separato dagli altri, la rete non risulterebbe più essere influenzata dalle traslazioni e

distorsioni dell’immagine, caratteristica invece fondamentale durante l’analisi visiva.

Grazie allo sviluppo delle reti convoluzionali,questi limiti si possono superare. Esse

sono così chiamate perché al loro interno si utilizza un’operazione matematica detta

convoluzione che permette di estrarre delle caratteristiche all’interno dell’immagine.

Architettura di una CNN

Una rete neurale convoluzionale, di cui è mostrata la composizione nelle figura 7:

FIGURA 7 STRUTTURA DI UNA RETE NEURALE CONVOLUZIONALE [11]

è strutturata come le reti precedentemente descritte cioè è costituita da un blocco di

input, uno o più blocchi nascosti e un blocco di output che effettua la classificazione,

ma a differenza di esse presenta degli ulteriori blocchi: un layer di convoluzione, uno di

attivazione e uno di pooling che consentono l’estrazione di caratteristiche dalle

immagini. Vediamo nel dettaglio la descrizione di ciascuno layer.

35
Strato di input

Costituisce il primo strato della rete e prende in input le immagini del Dataset,

introdotte come matrici di pixel. Ciascun dato singolare a cui è associato un neurone

della rete,è rappresentato da un pixel formando così per ogni immagine una matrice di

neuroni.

Strato di convoluzione

Il convolution layer ha il compito di estrarre delle caratteristiche salienti presenti

all’interno delle immagini. L’estrazione avviene Attraverso l’utilizzo di filtri, ovvero

delle matrici numeriche (solitamente di dimensione ridotta rispetto all’immagine da

analizzare)è possibile l’estrazione di caratteristiche peculiari peculiarità ed elementi

distintivi all’interno dell’immagine. A seconda del filtro applicato, si estrae una

proprietà diversa dell’immagine originale, ottenendo comunque in ogni caso una

immagine (detta feature map) di dimensione uguale a quella originale, come si può

notare dalla Figura 8 riportata di seguito:

Figura 8 Esempio di filtro convoluzionale e della sua applicazione applicazione

SU UN’IMMAGINE [12]

Notiamo che vengono applicati diversi filtri in sequenza e il risultato del filtraggio viene

“impilato” per cosi dire a formare un blocco che ha spessore pari al numero di filtri
36
utilizzati. Il filtraggio è un’operazione che consiste nel prodotto scalare tra i valori dei

filtri e quelli dell’immagine e la successiva somma dei risultati ottenuti. Un esempio di

convoluzione è mostrato di seguito:

FIGURA 9 ESEMPIO DELLA CONVOLUZIONE TRA LA MATRICE DI INPUT E UN KERNEL

3X3

Notiamo che la moltiplicazione, siccome il filtro è di dimensione più piccole rispetto

all’immagine, avviene su una porzione dell’immagine della stessa dimensione del filtro,

detta campo di ricezione locale. Il filtro viene chiamato anche sliding window (finestra

scorrevole) proprio perché viene fatto scorrere sull’intera immagine.

37
 FIGURA 10 ESEMPIO DELLA CONVOLUZIONE TRA LA MATRICE DI INPUT E UN KERNEL
3X3

Quando si effettua il filtraggio sul bordo dell’immagine, può accadere che la

dimensione del filtro sia maggiore del campo di ricezione, per ovviare viene effettuata

una operazione detta padding, cioè viene aggiunto un bordo all’immagine contenente

valore zero in modo da non compromettere le dimensioni e il valore di uscita. Di solito

una CNN possiede più di un livello convolutivo. Man mano che vengono trasmesse

delle informazioni, dal primo strato verso l’uscita della rete, ogni filtraggio permette di

estrarre caratteristiche sempre più astratte, fin quando all’ultimo livello si effettua la

classificazione dell’immagine.

Strato di attivazione

In questo livello viene applicata una funzione di attivazione chiamata "ReLu function"

all’uscita del layer precedente. Essa è particolarmente importante in quanto permette di

introdurre all’interno delle reti un elemento di non linearità che è fondamentale per

38
risolvere problemi complessi. In figura 10 è mostrata la funzione ReLu descritta

dall’equazione f(x) = max0; x

FIGURA 11 RELU FUNCTION

Come notiamo dalla figura, permette di annullare tutti i valori di output del livello

convoluzionale che sono minori di zero. Tutto questo non solo permette di facilitare ma

anche velocizzare il meccanismo di retro-propagazione degli errori in quanto verranno

analizzati soltanto quei percorsi in cui un neurone ha contribuito alla formazione

dell’errore a valle .

Strato di raggruppamento

Tali layer di raggruppamento (polling) vengono utilizzati con lo scopo principale di

ridurre la dimensione dell’input al layer successivo e, quindi, di limitare i parametri che

la rete deve apprendere. Vengono prodotte in questo modo delle nuove mappe delle

caratteristiche che mantengono solo le caratteristiche essenziali, eliminando quelle che

sono fonte di disturbo ed errore. Le tecniche più comuni per effettuare pooling sono:

l’average pooling in cui si estrae la radice quadrata della somma dei quadrati dei pixel

osservati, e il max pooling in cui si estrae il valore massimo fra i pixel nella finestra di

osservazione. Nel caso è presente il problema dei bordi,anche in questo livello è

39
possibile introdurre un padding per preservare le dimensioni della matrice di output,

come mostrato nella figura che segue:

FIGURA 12 ESEMPIO DI RIDUZIONE DELLA DIMENSIONE SPAZIALE DI UNA MATRICE

Strati completamente connessi

Il Fully connected layer rappresenta l’ultimo livello di una rete neurale convoluzionale.

Esso è mostrato nella figura 12 che segue:

FIGURA 13 ESEMPIO DI RETE NEURALE FULLY CONNECTED CON 10 CLASSI DI OUTPUT

40
Prima di questo livello però è sempre necessario applicare un Flatten layer, cioè un

livello che permette di trasformare le matrici tridimensionali in uscita dal layer

precedente in un vettore lineare. Fatto ciò si introduce il livello Fully connected ciascun

neurone sarà collegato a tutti i neuroni dello strato precedente, ma due neuroni

appartenenti allo stesso layer non possono essere connessi tra loro. L’output di questo

layer avrà un numero di neuroni pari al numero di oggetti che si vogliono classificare. I

valori di output verranno infine trasformati in un dato di probabilità normalizzata che

rappresenter la probabilità che l’oggetto appartenga alla classe i-esima.

1.4 Il Deep Reinforcemente Learning

Una rete che ha più di due hidden layer viene chiamata Deep e il meccanismo di

apprendimento legato ad essa viene chiamato Deep Learning. Con il termine Deep

Reinforcement learning ci si riferisce quindi semplicemente all’uso di reti neurali

profonde come approssimatori di funzione per la funzione valore o la policy, negli

algoritmi di Reinforcement learning. Grazie a questa tecnica, gli algoritmi di Deep

reinforcement learning, hanno raggiunto, e in alcuni casi superato, le prestazioni umane

in molti settori come per esempio nel giocare a videogiochi Atari come spiegato nella

fonte [13] riportata in bibliografia. Nel paragrafo che segue viene spiegato nel dettaglio

l’algoritmo di Deep Q-learning.

1.4.1 Algoritmo Deep Q-Learning

Un algoritmo largamente usato nel reinforcement learning è quello chiamato Q-

Learning. Esso inizialmente era considerato instabile quando usato con le reti neurali e

per questo veniva a usato solo per compiti e problemi che coinvolgevano spazi di stato a

41
limitata dimensionalità. In seguito pero è stato dimostrato, come spiegato nella fonte

citata [13], che le tecniche di Q-Learning possono essere utilizzate con le DNN. Questo

algoritmo ha mostrato il raggiungimento di performance di livello umano [13] . Nel

seguito questa tesi ci si riferirà sempre a tale algoritmo con il nome di Deep Q-Learning

o Deep Q-Network (DQN). DQN in realtà rappresenta un’evoluzione del metodo Q-

Learning dove la tabella stato-azione viene sostituita da una rete neurale. In questo

algoritmo quindi l’apprendimento non consiste nell’aggiornare la tabella ma consiste

nell’aggiustamento dei pesi dei neuroni che compongono la rete attraverso la tecnica

della backpropagation. L’apprendimento della funzione valore è basato quindi sulla

modifica dei pesi in base alla funzione costo o loss function, nel seguente modo:

Lt ¿ ¿ ¿ (1.14)

dove Lt quindi rappresenta l’errore commesso. L’obbiettivo è quello di far tendere questa

differenza a zero in modo tale che la previsione si avvicini il più possibile al risultato

desiderato. In particolare E ¿ rappresenta l’expected return ottimo mentre Q(s ¿ ¿ t , at )¿ è

il valore stimato dalla rete. Mediante backpropagation, gli errori calcolati dalla funzione

costo saranno propagati all’indietro nella rete seguendo la logica di discesa del gradiente

in quanto sappiamo che il gradiente indica la direzione di maggior crescita di una

funzione e muovendoci in direzione opposta riduciamo (al massimo) l’errore. Il

comportamento della policy è dato da un approccio e-greedy per garantire

un’splorazione sufficiente. L’aspetto chiave che fa funzionare le DQN è l’utilizzo

dell’experience replay. Con questa tecnica, l’esperienza dell’agente

e t =(st , at , r t , s t +1) viene presa ad ogni time step t e salvata in un data-set

D=et ,e t +1 ,⋯ , e n chiamato replay memory. Prelevando un sotto-insieme di campioni di

esperienze estratte random da questo replay memory, viene effettuato il training. Questa

42
tecnica permette quindi di utilizzare le esperienze passate che saranno usate in più di un

aggiornamento della rete. Scegliere il sotto-insieme in maniera casuale dalla replay

memory permette di interrompere la forte correlazione che potrebbe essere presente tra

esperienze successive, riducendo così la varianza tra gli aggiornamenti. Di seguito

riportiamo la descrizione dell’algoritmo:

Algoritmo Deep Q-Learning con Experience Replay

Inizializza Replay Memory D

Inizializza Q(s,a) con pesi random
repeat
Osserva stato iniziale s1
for t=1 to T do
Seleziona un’azione at usando Q (es: ϵ-greedy)
Esegui azione a t
Osserva il reward rt e il nuovo stato st+1
Salva la transizione (st, at, rt, st+1) nel Replay Memory D
Preleva un campione di transizioni ( sj, aj, rj, sj+1) da D
Calcola il target T per ogni transizione
if sj+1 è Terminale then
T = rj
else
T = rj + γ maxa Q(sj+1, aj)
end if
Addestra la rete Q minimizzando (T – Q(sj, aj))2
end for
until terminazione

Capitolo 2

Introduzione
In questo capitolo passeremo in rassegna alcune tra le principali tecniche di controllo

classiche in particolare quella basata sui regolatori PID e quella denominata MPC.

43
Con il termine “controllo” si indica l’azione svolta per portare, e mantenere, ad un

valore prefissato un parametro fisico di un impianto o di un processo ad esempio, la

posizione del braccio di un robot, la temperatura di un forno, il livello di un fluido, la

velocità di rotazione di un motore, l’automatismo che regola il servomotore, ecc.... In

passato si usavano tecnologie meccaniche ed elettroniche (con l’ausilio di circuiti

analogici contenenti resistenze, condensatori o amplificatori operazionali) per realizzare

i regolatori e le trasmissioni dei segnali, ma dall’inizio degli anni ’80 abbiamo assistito

all’avvento dei primi controllori a microprocessore che, rispetto ai loro predecessori,

hanno prestato maggiori possibilità di elaborazione e una maggiore precisione oltre che

maggiore stabilità nel tempo. Questi regolatori industriali sono riusciti a svolgere quella

che è funzione che li contraddistingue cioè assicurare un controllo accurato della

grandezza che si desidera manipolare, supposta misurabile.

Sappiamo che l’obiettivo di un sistema di controllo è quello di soddisfare determinati

requisiti in termini di funzionalità, specifiche e prestazioni. La funzionalità consiste nel

fare in modo che la/e variabile/i di uscita del sistema da controllare inseguano nel modo

più fedele possibile determinate variabili riferimento. Soddisfare le specifiche implica

invece che il sistema controllato sia stabile, che la risposta a regime a certi segnali di

ingresso sia sufficientemente precisa e che siano attenuati i disturbi. Soddisfare i

requisiti di controllo in termini di prestazioni implica che la risposta in transitorio a ceti

segnali di ingresso risulti limitata e il costo del sistema di controllo sia basso. Con

riferimento alla risposta a regime e alla risposta in transitorio ad una determinata classe

di ingressi vengono determinate corrispettivamente le specifiche e le prestazioni.

Applicando un segnale di ingresso la risposta in transitorio si esaurisce nel tempo in

quanto a seguito dell’energia immessa nel sistema dalle variabili di ingresso essa è

44
soggetta a fenomeni di dissipazione e accumulo di energia. La risposta a regime è

quella invece la parte della risposta che persiste nel tempo mentre il segnale di ingresso

è ancora applicato al sistema e rappresenta quindi il nuovo equilibrio energetico in cui

si pone il sistema a seguito della sollecitazione dovuta alla variabile di ingresso.

Ai giorni d’oggi esistono molti tipi di sistemi di controllo, più o meno sofisticati,

realizzati con diverse tecniche (alcuni attraverso dispositivi informatici ma altri ancora

secondo tecnologie idrauliche e pneumatiche), nel seguito del capitolo, nel primo

paragrafo ci occuperemo di una particolare tipologia chiamata PID. Questi regolatori

standard tempo invarianti molto diffusi utilizzano tre tipi di leggi di controllo diverse:

azione Proporzionale, azione Integrale, azione Derivativa , da qui l’acronimo PID che è

usato per identificarli.

Benché siano realizzati mediante una tecnologia antiquata per gli standard tecnologici

attuali (possono infatti essere di tipo meccanico, idraulico o anche elettronico e

digitale), questi controllori vengono ancora diffusamente utilizzati soprattutto per la

relativa semplicità di taratura dei loro parametri di lavoro. Ragion per cui il controllore

PID, nelle sue innumerevoli varianti, gestisce attualmente circa il 95% degli anelli di

regolazione presenti negli impianti.

Ci sono svariati fattori che hanno favorito il successo dei regolatori PID tra cui

possiamo elencare:

 relativa semplicità di taratura in rapporto alla difficoltà del compito e alle

capacità degli utenti;

45
  convenienza economica derivanti dalla standardizzazione a cui si è oramai

arrivati nella produzione e manutenzione e nella la gestione delle scorte degli

stessi. oltre che per la loro l’affidabilità e robustezza;

 notevole efficacia nella regolazione di un’ampia gamma di processi industriali;

 a causa della natura stesa delle prestazioni piuttosto scadenti della maggior parte

dei sistemi di controllo dovute a problemi nei sensori e negli attuatori, dovute

essenzialmente a rumore e filtri anti-aliasing inadeguati, errori di calibrazione

dei sensori, cattivo dimensionamento, isteresi e attriti statici nelle valvole di

regolazione. Ebbene in presenza di problemi di tale natura, il ruolo della legge di

controllo può diventare modesto, per cui viene meno la motivazione di cercare

leggi di controllo più sofisticate di quelle PID;

 essi possono essere usati anche e soprattutto in schemi di controllo più complessi

e articolati, quale il controllo in cascata, con il quale si riesce ad apportare

notevoli miglioramenti delle prestazioni a fronte di costi e sforzi realizzativi

relativamente modesti, sfruttando la sola conoscenza di specifiche proprietà

dinamiche del processo;

In sintesi, possiamo affermare che il successo dei PID è dovuto al fatto che essi

rappresentano in generale, una soluzione non facilmente superabile, nel rapporto

efficacia/costo globale.

Di seguito quindi analizzeremo i PID nella loro struttura, descrivendo nel dettaglio il

funzionamento di ognuna delle parti che li compongono e da cui prendono il nome. Di

ognuna di esse saranno messi in evidenza pregi e difetti, ed anche i problemi tecnici che

sorgono al momento del loro utilizzo pratico nelle diverse situazioni di lavoro. La

trattazione che segue trae spunto dalle fonti presenti in bibliografia come [1], [2], [3].

46
2.1 I Regolatori PID
I regolatori PID possono essere adattati ad una vasta gamma di sistema di regolazione in

quanto sono dei regolatori standard tempo invarianti e permettono di regolare i

parametri del sistema di controllo in cui sono inseriti entro ampi limiti. Essi possono

essere utilizzati dunque sia per controllare, ad esempio, una portata, sia per controllare

una temperatura, la quale ha una risposta molto più lenta della prima.

Una rappresentazione semplice e schematica di un regolatore PID e mostrato in figura 2.1

FIGURA 14

In essa compaiono i seguenti segnali:

 r(t): segnale di riferimento in ingresso;

 y(t): segnale in uscita del sistema di controllo in retroazione;

 e(t): errore dato dalla differenza tra il segnale di riferimento in ingresso e l’uscita

(In realtà nello schema completo sarebbe la differenza tra riferimento e uscita

misurata cioè il segnale all’uscita del trasduttore di misura sulla catena di

retroazione. Per semplicità in questa trattazione riterremo che la f.d.t del sensore

di misura sia unitaria quindi l’uscita misurata coincide con la y(t));

 u(t): ingresso di controllo.

47
Dalla figura (2.1) possiamo notare come il controllore venga posto in serie al sistema da

controllare, ovviamente prima di esso perché il controllo abbia effetto sulla grandezza in

ingresso al sistema, notiamo come il circuito di retroazione riporti in ingresso il termine

y(t), il quale, attraverso un nodo sommatore, va a modificare il segnale vero e proprio

d’ingresso del controllore. La legge di controllo del regolatore, cioè il legame tra e(t) e u(t)

sarà:
t
de (t)
u ( t )=K P e ( t ) + K I ∫ e( τ )dτ + K D (2.1)
t0 dt

i parametri KP, KI, e KD rispettivamente, i guadagni delle azioni proporzionale, integrale

e derivativa. La (2.1) può essere riscritta nella forma:

( )
t
1 de(t)
u ( t )=K P e ( t ) + ∙∫ e ( τ ) dτ +T D ∙ (2.2)
TI 0 dt

Nella 2.2 insieme al KP, al posto di KI, e KD compaiono le costanti di tempo delle azioni

derivativa e integrale, rispettivamente TD e TI. Risulta evidente che i parametri KI, e KD

sono legati ai parametri TD e TI dalle relazioni:

KP
 T I=
KI

KD
 T D=
KP

Essendo i PID, almeno nella loro forma ideale, sistemi dinamici SISO, lineari, stazionari,

impropri, possiamo applicare la trasformata di Laplace alla formula (2.2), così facendo si

ricava immediatamente la funzione di trasferimento ingresso uscita data dalla seguente:

) ( )
2

(
U (s ) 1 T T s +T I s+ 1
PID( s)= =K P 1+ +T D s =K P D I (2.3)
E( s) TI s TI s

48
che rappresenta un sistema lineare tempo invariante e dinamico improprio il che lo

rende fisicamente irrealizzabile. Per ovviare a tale problema, se ne filtra l’azione

derivativa, che ne rappresenta proprio la componente non fisicamente realizzabile,

ottenendo la funzione:

( )
U (s ) 1 TD s
PID( s)= =K P 1+ +
E( s) TI s T s (2.4)
1+ s D
N

Nel seguito approfondiremo tale aspetto analizzando, più nel dettaglio, una per una le tre

azioni di cui si compone il regolatore.

2.1.1 L’azione proporzionale

In riferimento alla formula generale del PID riportata sopra e data dalla (2.2), nelle

condizioni in cui KI = KD = 0 oppure equivalentemente T I → ∞ e T D=0 , il regolatore

attua la sola azione di una correzione proporzionale all’errore e(t) in funzione di KP. Per

sua natura un’azione proporzionale implica che l’ingresso e(t) e l’uscita u(t) sono legati

algebricamente da un coefficiente KP detto anche coefficiente dell’azione proporzionale,

o semplicemente guadagno proporzionale.

u ( t )=K P ∙ e ( t ) (2.5)

Utilizzando la sola azione proporzionale come controllore lo schema di riferimento sarà il

seguente:

FIGURA 15

49
Il significato dell’azione proporzionale sta nel fatto che maggiore sarà l’errore e(t)

all’ingresso del controllore e maggiore sarà l’azione di controllo svolta dallo stesso

regolatore. Possiamo ben capire che la velocità di risposta del sistema, all’aumentare

del guadagno proporzionale, aumenta, ma allo stesso tempo per guadagni elevati,

aumentando le oscillazioni diminuisce la stabilità del sistema. Proprio per quanto

riguarda il guadagno proporzionale ricordiamo che più spesso, in letteratura, invece che

di guadagno proporzionale KP si parla di Banda proporzionale BP, definita come la

minima variazione dell’ingresso e(t), espressa in percentuale, che porta l’uscita u(t) dal

valore minimo al suo valore di fondo scala. Nella figura che segue, la figura 15, sono

evidenziati due esempi nei quali si ha un campo di valori uguale sia per l’ingresso che

per l’uscita del PID, ma come possiamo notare, nel diagramma di sinistra la percentuale

di variazione dell’ingresso e(t) che provoca il raggiungimento da parte dell’uscita u(t)

del suo valore di fondo scala, è del 50%, detta in altri termini è necessario che l’ingresso

e(t) arrivi a metà del suo valore massimo per avere il passaggio dell’uscita u(t) dal suo

valore minimo di 0.1V al suo valore di fondo scala di 10V, mentre nel diagramma di

destra tale variazione risulta del 25%. Dunque avviene la medesima variazione del

segnale di uscita al suo valore di fondo scala in entrambi i casi ma con valori di banda

proporzionale diversi.

50
 FIGURA 16
La relazione tra BP e KP è data da :

100
K P=
BP

Essa può essere usata nel momento in cui KP è espresso come rapporto tra i segnali di

uscita e ingresso, entrambi normalizzati ai rispettivi valori di fondo scala, cioè espresso

nel seguente modo

u(t)/u fondoscala
K P=
e (t)/e fondoscala

Dalla relazione che lega il guadagno alla banda si deduce che agendo sulla banda,

piuttosto che sul guadagno, e in particolare riducendo la banda proporzionale il che

implica aumento di guadagno, si ottiene una maggiore precisione dello strumento in

quanto è sufficiente una minore variazione dell’errore in ingresso perché questa porti ad

un significativo cambiamento in uscita.

Infine concludiamo che riducendo la banda proporzionale il guadagno aumenta, la

precisione migliora il che implica che aumenta la velocità di risposta del sistema. Ad un

aumento del guadagno corrisponde anche un aumento del valore raggiunto all’uscita del

blocco proporzionale. Tale valore si discosterà sempre di meno dal valore originale del

segnale r(t) senza però raggiungerlo a causa dell’errore a regime. Il contributo dovuto a
51
KP è appunto proporzionale all’errore e diminuisce man mano che l’errore si avvicina a

zero. All’aumento del guadagno c’è però un limite. Infatti oltre un certo valore, il

sistema entra in uno stato di auto oscillazione, cioè di instabilità. Ed è per questo che la

sola azione proporzionale viene utilizzata nei sistemi nei quali sono consentiti

scostamenti tra il valore effettivo della grandezza controllata e quello desiderato, come

ad esempio negli impianti di riscaldamento degli edifici e quindi anche valori bassi del

guadagno vanno bene.

Cerchiamo ora di dimostrare, tramite un esempio e quindi tramite formule matematiche,

le affermazioni fatte fin qui. Facendo riferimento allo schema di figura 2, associamo a

R(s) e G(s) le seguenti espressioni:

1 A0
R ( s )= e G ( s )=
s 1+τ ∙ s

Il riferimento quindi è un segnale a gradino e il processo da controllare è un sistema di

primo ordine con un polo in −1/τ . Ad anello chiuso la funzione di trasferimento del

sistema sarà data dalla seguente:

KP ∙ A0
Y (s) 1+ τ ∙ s KP ∙ A0
W ( S )= = = (2.6)
R(s) K ∙A 1+ sτ + K P ∙ A 0
1+ P 0
1+τ ∙ s

applicando poi come ingresso un gradino unitario otteniamo il seguente segnale

d’uscita:

1 KP ∙ A0
Y ( s )=R ( s ) ∙W ( s )= ∙ (2.7)
s 1+sτ + K P ∙ A 0

52
Per ottenere la risposta nel dominio del tempo del nostro sistema, scomponiamo la (2.7)

in fratti semplici mediante l’applicazione del teorema dei residui, poi antitrasformiamo

secondo Laplace e otteniamo la risposta cercata che sarà quindi data da:

( )[ ]∙ δ
−1+ K P ∙ A 0
K P ∙ A0 t
y (t)= ∙ 1−e τ
−1 ( t ) (2.8)
1+ K P ∙ A 0

Dalla (2.9) si capisce come all’aumento del guadagno proporzionale KP, corrisponde

una crescita del guadagno in continua del sistema che si avvicina circa all’unità, e nello

stesso tempo viene ridotta la costante di tempo dell’esponenziale. In altre parole,

aumentando KP, il valore asintotico dell’uscita sarà sempre più vicino al valore costante

richiesto (in questo caso si avvicinerà al valore 1 visto che il nostro segnale d’ingresso

corrisponde a un gradino di ampiezza unitaria) e allo stesso tempo si osserva una

contemporanea riduzione del tempo necessario per arrivare a tale livello asintotico.

Notiamo tuttavia che l’uscita non arriverà mai esattamente al valore richiesto ma

presenterà quello che è detto offset che corrisponde al valore asintotico dell’errore di

regime permanente, a meno di non far tendere KP all’infinito.

L’azione proporzionale del controllore ha quindi l’effetto di ridurre il tempo di salita tr

(parametro che caratterizza la prontezza del sistema), e ridurre, ma non eliminare,

l’errore a regime permanente ma anche di incrementare le sovraelongazioni.

Calcoliamo ora la funzione di errore che sarà data da:

E ( s )=R ( s )−Y ( s )=R ( s )−R ( s ) ∙

KP G (s ) 1
= ∙ 1−
1+ K P G ( s ) s ( K P ∙ A0
1+ sτ + K P ∙ A0
→
)
1 1+ sτ
→ E ( s )= ∙ (2.9)
s 1+ sτ + K P ∙ A 0

53
Invece l’errore a regime, ottenuto mediante il teorema del valor finale, sarà espresso

dalla seguente formula:

1
lim e ( t )=lim s ∙ E (s )= (2.10)
t →+ ∞ s→0 1+ K P ∙ A 0

Dall’espressione dell’errore a regime e della W(0) si evince che per eliminare

definitivamente l’errore a regime bisogna che il termine KP tenda all’infinito,

operazione solo idealmente realizzabile ma nella realtà impossibile da implementare.

Vediamo ora un secondo esempio nel quale il processo è caratterizzato da una funzione

di trasferimento del secondo ordine, priva di zeri e in particolare data da:

A0
G ( s )= (2.11)
( )( )
2
s s
1+2 ξ +
ωn ωn

In cui ξ e ω n sono due costanti positive dette rispettivamente fattore di smorzamento e

pulsazione naturale. Analogamente a come fatto nel caso del sistema di primo ordine

possiamo ricavare la funzione di trasferimento:

Y (s) K P ∙ A0
W ( s )= = (2.12)
( )( )
2
R(s) s s
1+ K P ∙ A 0 +2 ξ +
ωn ωn

Allo stesso modo seguendo la procedura usata nella (2.9), in cui ora la G(s) è data dalla

(2.11), possiamo esprime l’errore del sistema ciclo chiuso sempre in riferimento ad un

segnale di ingresso a gradino come:

( ) ( ) (2.13)
2
s s
1+2 ξ +
1 ωn ωn
E ( s )= ∙
( ωs )+( ωs )
2
s
1+ K ∙ A + 2 ξ
P 0
n n

Applicando il teorema del valor finale all’errore otteniamo la seguente espressione

dell’errore a regime:

54
 1
lim e ( t )=lim s ∙ E (s )= (2.14 )
t →+ ∞ s→0 1+ K P ∙ A 0

Analogamente a quanto visto per un processo con un polo del primo ordine, anche in

questo caso si osserva la presenza di un offset che diminuisce all’aumentare di KP.

Tuttavia, andando ad analizzare l’espressione della funzione di trasferimento del

sistema ad anello chiuso W(s), notiamo che, all’aumentare di KP, il transitorio segue

rapide variazioni di r(t) ma sarà caratterizzato da oscillazioni di frequenza sempre più

elevata e meno smorzate. Quanto detto è evidenziato a titolo d’esempio nella figura che

segue:

FIGURA 17
Notiamo che già per KP = 10 si riduce l’effetto dell’offset, ma la risposta al transitorio è

caratterizzata da forti oscillazioni.

In conclusione possiamo dire che utilizzando un controllore esclusivamente

proporzionale, per un sistema privo di poli nell'origine, si produce una differenza

(offset) tra il valore costante richiesto a regime e quello effettivamente ottenuto. Tale

differenza può essere ridotta aumentando il guadagno proporzionale KP del controllore.

55
Se il processo da controllare possiede coppie di poli complessi coniugati, però,

l’aumento del guadagno proporzionale se da un lato riduce l’offset dall’altro è

accompagnato da un corrispondente aumento delle oscillazioni generate, a seguito dei

più rapidi transitori.

Dallo studio effettuato fin qui possiamo trarre dunque importanti conclusioni per quanto

riguarda l’utilità del blocco ad azione proporzionale P che elenchiamo di seguito:

 Per avere un errore a regime molto piccolo bisogna che A0 KP sia elevato (ed

essendo fissato A0 tale discorso vale per KP), ma questo aumento può

compromettere la stabilità del sistema rendendolo molto suscettibile ai rumori di

misura (cioè agli errori che avvengono sull’uscita y(t) e che si ripercuotono sulla

catena di retroazione influendo sul segnale che genera e(t)).

 L’impiego di un regolatore proporzionale è normalmente limitato al controllo di

processi asintoticamente stabili, o semplicemente stabili, e nel caso in cui le

prestazioni statiche richieste al sistema di controllo non rendano necessario

l’inserimento di un’azione integrale.

 Il blocco proporzionale P non introduce ritardo di fase ed aumenta la velocità di

risposta del sistema rendendolo così capace di inseguire più velocemente il

segnale di riferimento (setpoint). A tempo stesso però diminuiscono i margini di

stabilità del sistema, margini che possono essere facilmente determinati tramite

il criterio di Routh (oppure in alternativa al criterio di Routh si può utilizzare il

diagramma di Nyquist.) il quale permette di valutare il massimo valore di KP che

garantisce la stabilità del sistema ad anello chiuso.

56
2.1.2 L’azione integrale

“Il contributo di questa azione è proporzionale all’integrale dell’errore e(t) (e quindi

proporzionale al suo valor medio). Il legame tra e(t) e u(t) sarà dato dunque dalla

seguente formula:
t
u ( t )=K I ∙∫ e ( τ ) dτ (2.15)
0

Notiamo che la formula (2.15) deriva dalla (2.2) in cui si è posto KP = 0 e KD = 0. Il

coefficiente dell’azione integrale KI può essere sostituito dalla costante di tempo

KP
integrale T I = (chiamata anche tempo di reset), in questo caso lo schema del
KI

regolatore ad azione integrale sarà quello riportato nella figura che segue:

FIGURA 18
L’azione integrale è particolarmente importante nelle applicazioni, perché assicura un

errore nullo a regime per variazioni a gradino del segnale di riferimento r(t). L’errore

rimane nullo anche in presenza di variazioni del guadagno del processo, purché sia

preservata la stabilità del sistema in anello chiuso . In generale l’azione integrale è quasi

sempre associata all’azione proporzionale in modo tale da realizzare i cosiddetti

controllori PI, proporzionali integrali appunto, il cui legame tra e(t) e u(t) sarà il

seguente:

( )
t
1
u ( t )=K P e ( t ) + ∙∫ e ( τ ) dτ (2.16)
TI 0

57
essi permettono di ottenere una maggiore precisione senza peggiorare il grado di

stabilità del sistema (mediante scelta opportuna delle costanti), unita ad una maggiore

velocità di risposta. I controllori PI vengono utilizzati quando è richiesto un errore a

regime di modesta entità unito ad una buona velocità di risposta alle variazioni della

sollecitazione; pertanto vengono inseriti soprattutto nei sistemi in cui le variazioni di

carico avvengono lentamente. La taratura della costante di integrazione è legata alle

sovraelongazioni ed alle oscillazioni che si possono innescare. Infatti cambiamenti

improvvisi di carico possono portare il sistema verso l’instabilità, quando il coefficiente

KI dell’azione integrale non è scelto in modo opportuno. In ambito industriale si può

affermare oltre il 90% dei controllori è di questo tipo.

Nel caso di un segnale di riferimento r(t) a gradino, per esempio, l’integrale crescerà

sempre più, come evidenziato nella figura che segue

FIGURA 19
Quando aggiungiamo l’azione integrale al blocco proporzionale eliminiamo a priori la

presenza dell’offset. Inoltre, con l’azione integrale, un piccolo errore positivo e(t)

condurrà sempre ad un incremento del segnale di controllo u(t), e un errore negativo

darà un decremento del segnale di controllo a prescindere dal fatto di quanto sia piccolo

l’errore. Per il blocco PI in considerazione, la variabile da tarare in base al sistema con

cui si ha a che fare è la costante di tempo integrale T I ; da essa infatti dipende l’effetto di

integrazione che è tanto più importante quanto più T I è piccola, in quanto riducendo il
58
tempo di reset, l’azione integrale entra in gioco prima, cioè l’integrale dell’errore salirà

più velocemente verso il valore r(t) in ingresso e cioè prima si raggiunge il segnale di

riferimento. Il prezzo da pagare per questa velocità di salita però sono delle forti

oscillazioni che richiederanno tempo prima di stabilizzarsi. Viceversa, aumentando T I e

facendolo idealmente tendere ad infinito, si ottiene come conseguenza l’eliminazione

dell’effetto dell’azione integrale.

Analizziamo ora un esempio in cui il processo da controllare è dato da un sistema del

primo ordine con un polo in −1/τ . Facendo riferimento alla figura 1, il segnale di

riferimento è ancora una volta un gradino di ampiezza unitaria e in cui poniamo:

( )
A0 1
G ( s )= e PI (s )=K P 1+
1+sτ TIs

Utilizzando queste espressioni ricaviamo la funzione di trasferimento ad anello chiuso:

1
W ( s )= (2.17)
T I s (1+ sτ )
1+
A 0 K P (1+T I s)

E l’errore:

1 T I s ( 1+sτ )
E ( s )= ∙ (2.18)
s T I s+ ( 1+ sτ + A0 K P ) + A 0 K P

Come fatto in precedenza nell’analisi dell’azione proporzionale, anche qui

determiniamo, tramite il teorema del valor finale, l’espressione dell’errore asintotico

lim e ( t )=lim s ∙ E (s )=0(2.19)

t →+ ∞ s→0

Notiamo che facendo tendere T I all’infinito, ovvero eliminando il termine integrale, le

espressioni (2.18) e (2.19) si riducono a quelle trovate precedentemente nel caso

dell’esempio sviluppato considerando un controllore ad azione esclusivamente

59
proporzionale. Nella figura che segue figura 19 viene mostrato l’effetto di diverse scelte

di T I in essa si nota che l’offset presente quando si opera solo con il controllore

proporzionale (T I → ∞) sparisce riducendo T I e cioè attivando il termine integrale.

Riducendo T I il sistema risponde più velocemente al transitorio, ma si osservano anche

delle forti oscillazioni.

FIGURA 20
Facciamo ora alcune considerazioni sui limiti dell’azione integrale. Sappiamo che gli

attuatori che troviamo nei sistemi industriali, di solito, lavorano entro un range di valori

molto superiore di quello della variabile che di controllo. Nonostante ciò, in qualche

caso, tuttavia, tali limiti possono essere anche raggiunti e superati, per effetto ad

esempio di rapidi transitori provocati da disturbi sul carico. Quando si verificano

situazioni del genere il circuito di retroazione può rompersi e il sistema funziona come

un anello aperto perché l’attuatore entra in saturazione e il valore che si ottiene in uscita

non rispecchia più quello in ingresso. Evidenziamo ciò nella figura che segue

60
 FIGURA 21
La saturazione dell’attuatore è definita dalla seguente relazione:

{
U max se v ( t ) ≥U max
u ( t )= v ( t ) se U max < v (t )< U max
U min se v (t )≤ U min

dove Umax e Umin sono rispettivamente i limiti massimo e minimo dell’uscita, cioè i

limiti fisici imposti dall’attuatore. Quando si presenta questa situazione si ha in uscita

dall’attuatore un valore inferiore, in modulo, al valore che lo stesso attuatore presenta in

ingresso. Quindi dopo la retroazione all’ingresso arriva un segnale correttivo minore del

previsto, che inciderà di meno sulla correzione di r(t) e perciò farà aumentare il tempo

nel quale l’errore viene inseguito e raggiunto. Il processo continua così fino a quando il

segnale y(t) non supera r(t) e l’errore non diventa negativo, ma in quell’istante anche se

il valore dell’integrale inizierà a diminuire, passerà dell’altro tempo prima che questo

valore arrivi a zero, in questo frangente si verifica una sovraelongazione y(t).

Nei grafici che seguono è mostata la differenza tra quanto avviene in presenza di un

attuatore ideale (rappresentato da una linea tratteggiata) e in presenza di un attuatore

con limiti di saturazione (rappresentato da una linea continua) quando viene utilizzato

un gradino come segnale di riferimenrto. L’uscita del sistema è rappresentata in figura

21:

61
 FIGURA 22
Con l’attuatore ideale l’uscita del sistema ha una forma d’onda che segue l’andamento

dell’integrale mostrato nella linea tratteggiata, mentre, se l’attuatore ha dei limiti di

saturazione si ottiene elevata sovraelongazione, come si vede dall’andamento della linea

continua di figura. L’errore di inseguimento, rappresentato in figura 22, nel momento di

applicazione del gradino in ingresso cresce istantaneamente , ma successivamente

assume due diversi andamenti.

62
 FIGURA 23
In presenza di attuatore ideale, comportamento indicato con la linea tratteggiata, l’errore

di inseguimento viene presto eliminato e si torna a una situazione di normalità; in

presenza di un attuatore reale indicato con la linea continua, invece, aumenta il ritardo

di correzione in quanto il potere correttivo della retroazione diminuisce e inoltre si va a

finire su valori negativi per tutta durata della sovraelongazione. Il processo evolverà

ricevendo un ingresso u(t) costante come se fosse in anello aperto, il blocco integratore

tenderà ad allontanarsi anche di molto dai valori di controllo che gli competono, a causa del

polo che possiede nell’origine esso è un sistema dinamico non stabile BIBO. Inoltre,

durante questo periodo di saturazione dell’attuatore, il sistema non avrà nessun tipo di

reiezione alla presenza di eventuali disturbi. Osservando i grafici che seguono potremmo

avere un’idea più chiara di quanto detto pocanzi.

63
 FIGURA 24

Dalla figura 23 si può evincere come il termine integrale cresca inizialmente perché

l’errore è positivo; raggiunge il suo valore massimo al tempo t = 10, quando l’errore

passa attraverso lo zero come vediamo dalla figura che segue:

FIGURA 25

Dalla figura 24 notiamo infatti che l’uscita rimane satura in quel punto a causa del

grande valore del termine integrale. La stessa uscita non lascia il limite di saturazione

fino a quando l’errore è diventato negativo per un tempo sufficientemente lungo tale da

consentire alla parte integranle di scendere a un livello basso. Infine nella figura 25 che

segue è rappresentato il segnale di controllo:

64
 FIGURA 26

notiamo come il segnale di controllo rimbalzi tra i suoi limiti più volte. L’effetto

risultante è una grande sovraelongazione ed una oscillazione smorzata sull’uscita y(t),

come se si trattasse dell’oscillazione conseguente all'apertura e chiusura di un relè. A

questo punto l’uscita finalmente arriva così vicino al valore di riferimento che

l’attuatore non satura.

In sintesi utilizzando un controllore con azione integrale, l’errore continuerà a essere

integrato, ciò significa che il termine integrale può diventare molto grande. Da qui il

fenomeno conosciuto come windup. È quindi necessario che l’errore sia di segno

opposto per un lungo periodo prima che le cose tornino alla normalità. La conseguenza

è che qualsiasi controllore con azione integrale può dare transitori di elevata durata

quando l’attuatore satura.

Supponendo di applicare al sistema di riferimento un disturbo a gradino r(t),

l'integratore inizierà ad accrescere il suo valore in uscita per via dell'errore non nullo.

Quando il valore in uscita al controllore è tale da saturare il comando di attuazione, si ha

che l'uscita dell'integratore continuerà a crescere fino a quando l'errore non diventerà

nullo mentre il comando di attuazione rimarrà costante. A questo punto l'integratore

inizierà a scaricarsi; e il segnale di controllo rimarrà costante fino a quando il valore di

uscita non sarà inferiore alla saturazione relativa all'attuatore. Ovviamente una

65
situazione del genere è indesiderata e richiede un certo periodo di tempo prima che la

situazione normale si ristabilisca, ma fortunatamente ci sono vari modi per poter ovviare

a questo problema. Uno di questi metodi può essere l’introduzione di limitatori sulle

variazioni del valore di riferimento in modo che l’uscita del regolatore non raggiunga

mai i limiti dell’attuatore.

Sempre parlando di metodi correttivi al fenomeno del windup, possiamo anche avere il

cosiddetto metodo degli algoritmi incrementali nel quale si calcola prima il tasso di

variazione del segnale di controllo che viene poi inviato all’integratore e dunque il

fenomeno del windup viene evitato mediante integrazione inibendo l’uscita ogni volta

che satura.

Un altro metodo di compensazione del fenomeno di windup consiste nel ricalcolo del

termine integrale. Secondo questa tecnica si introduce un segnale di compensazione che

viene riportato all’ingresso del blocco integrale e sottratto al valore dell’errore e(t).

Il segnale di compensazione viene generato prendendo il valore della grandezza di

misurata all’uscita dell’attuatore e confrontandolo con il valore che la stessa grandezza

presenta all’ingresso, nello specifico si ottiene come: e s ( t )=v ( t )−u(t ) .

E’ facile notare che facendo in questo modo, quando l’attuatore sta lavorando entro i

limiti di saturazione, si otterrà un segnale di compensazione nullo che quindi non

influisce in alcun modo sul controllo, mentre quando questi limiti verranno superati si

genera un valore del segnale di errore che permetta di smorzare la salita del termine

integrale. Lo schema usato è illustrato nella figura 26 che segue:

66
 FIGURA 27
Notiamo inoltre che, prima del ritorno del segnale di compensazione al blocco

integratore, è stato inserito un altro blocco chiamato dispositivo di antisaturazione, la

1
cui funzione di trasferimento F(s) è solitamente pari a il cui valore controlla la
Tt

velocità dell’azione di desaturazione. Quando costante di tempo Tt, assuma valori

ridotti, si avrà un’azione di desaturazione più rapida anche se più facilmente soggetta a

disturbi; mentre invece, se il valore della costante di tempo risulta elevato, l’azione di

desaturazione sarà più lenta, ,anche se meno influenzata dai disturbi” [4].

2.1.3 L’azione derivativa

“L’azione derivativa fornisce in uscita la derivata rispetto al tempo dell’errore e(t). In

questo caso abbiamo la presenza del coefficiente dell’azione derivativa KD. Il legame

ingresso uscita del regolatore ad azione derivativa è dato da:

de ( t )
u ( t )=K D ∙ (2.20)
dt

La (2.20) ancora una volta è ricavata come caso particolare della (2.2) in cui si è posto

67
KP = 0 e KD = 0. Se invece della KD, definiamo la costante di tempo derivativa T D come

KD
T D= lo schema del regolatore sarà quello riportato nella figura che segue:
KP

FIGURA 28
Un controllore derivativo viene chiamato anche controllore di velocità, oppure

anticipatore. Il suo comportamento è marcatamente diverso da quello dei controllori

proporzionale e integrale. L’uscita di un controllore derivativo non dipende dall’errore

presente o passato, ma dalla velocità con cui varia l’errore. Inoltre l’azione derivativa

porta all'introduzione di uno zero nell’origine ,è quindi complementare all’azione

integrale perché fornisce un anticipo di fase di 90°. Tale anticipo è di fondamentale

importanza ad esempio nel caso in cui vi sia un forte ritardo di fase nell’azione in catena

aperta, in quanto, in sua assenza una variazione della variabile di errore determina,

attraverso il meccanismo di controllo in retroazione, una variazione della variabile

controllata con un certo ritardo, cioè è come se il controllore agisse “in ritardo” rispetto

alle variazioni dell’errore.

Il valore della costante di tempo derivativa T D determina la velocità di salita del segnale

di controllo.

Ricordando che nelle applicazioni industriali più diffuse, anche l’azione derivativa

viene associata all’azione proporzionale così da creare i cosiddetti controllori PD i quali

si prestano bene ad essere utilizzati nei sistemi in cui si hanno improvvise variazioni di

68
carico, oppure sistemi che non presentano problemi di stabilità e di prestazioni statiche

ma che, invece, richiedono una buona velocità di risposta. La funzione di trasferimento

di un controllore PD risulta essere:

PD ( s )=K P ∙ ( 1+ s T D ) (2.21)

In analogia a quanto fatto per i due tipi di azioni analizzate in precedenza, consideriamo che

il processo da controllare G(s) sia un sistema del secondo ordine la cui la funzione di

trasferimento data da:

2
ω0
G ( s )= A 0 ∙ 2 2
(2.22)
s +2 ξ ω0 +ω 0

consideriamo ancora una volta in ingresso un gradino di ampiezza unitaria e per cui l’uscita

del sistema sarà:

2
A0 ω0 K P ∙ ( 1+s T D )
Y ( s )= ∙ 2 (2.23)
s s + s ( 2 ξ ω 0+ A 0 ω20 K P T D ) +ω 20 ( 1+ A 0 K P )

Il termine derivativo introduce uno zero e considerando il polinomio di secondo grado posto

al denominatore, il coefficiente del termine in s aumenta di una quantità pari a A0 K P T D e

anche il coefficiente del termine pari a 1 aumenta di un fattore pari ω 20 rispetto al caso del

regolatore proporzionale. L’effetto congiunto di questi aumenti contribuisce a stabilizzare il

sistema comportando una riduzione delle oscillazioni che si verificano in occasione dei

transitori. Riportiamo nella figura che segue il grafico dell’uscita dell’esempio appena

analizzato:

69
 FIGURA 29
da esso si può apprezzare l’azione anticipatrice del blocco derivatore e la sua correzione

sulle oscillazioni attorno al valore desiderato. L’offset è lo stesso che si ha con il solo

controllo proporzionale e come visto nel paragrafo precedente lo si può eliminare

utilizzando un opportuno contributo integrale. Purtroppo il termine derivativo introduce

l’inconveniente di amplificare i segnali con contenuto armonico a frequenze elevate,

cioè il rumore elettromagnetico sovrapposto al segnale utile. Per questo motivo

l’utilizzo del termine derivativo deve essere valutato con cautela.

Facciamo un esempio in cui si ha un rumore di misura sinusoidale n ( t )= A sin ωt , in

ingresso al blocco derivatore, esso dà luogo a un contributo sulla variabile di controllo

pari a:

dn(t)
un ( t )=T D = A T D ω cos ωt (2.24)
dt

Notiamo che tale contributo ha ampiezza crescente con ω, il che comporta che i segnali

di rumore, avendo un contributo rilevante alle alte frequenze(ω molto alta), verranno

notevolmente amplificati dal termine derivativo del PID.

70
Supponiamo che il segnale utile sia pari a e ( t )=sin 2 πt

FIGURA 30
e il segnale di rumore n ( t )=0 , 1 sin20 πt . Sommando n(t) al segnale e(t) precedente,

otteniamo la forma d’onda mostrata nel grafico di figura 30:

FIGURA 31
L’effetto dell’azione derivativa sul solo segnale utile mostrato in figura 29, sarebbe

stato il seguente riportato nella figura che segue, la figura 31:

71
 FIGURA 32
ora, invece, a causa dell’alta frequenza del rumore, assistiamo a una degenerazione

sostanziale del segnale che lo rende irriconoscibile (vedi figura 32)

FIGURA 33
Motivo per cui l’azione derivativa non è utilizzabile da sola, perché farebbe perdere al

sistema di controllo la fondamentale proprietà di essere passa-basso. Per evitare che ad

esempi che in corrispondenza di transizioni a gradino l’uscita del blocco derivatore

abbia andamento impulsivo, nella realizzazione pratica dei regolatori si adotta

l’accorgimento di limitare l’azione derivativa associandola a un filtro passa-basso che

ne limiti il guadagno alle alte frequenze., in particolare, siccome l’azione derivativa è

necessaria fino ad una certa frequenza, oltre la quale è conveniente che vi sia

attenuazione, per filtrare il rumore fuori dalla banda di regolazione, si limita il livello di

72
amplificazione del rumore introducendo un filtro del primo ordine, con funzione di

trasferimento:

1
F ( s )= (2.25)
sTD
1+
N

dove N in genere assume valori tra 5 e 10. A valle dell’introduzione di questo filtro,

funzione di trasferimento dell’azione derivativa risulta:

K PsT D
D ( s )= (2.26)
sTD
1+
N

Un punto importante è capire come scegliere il termine N per fare in modo che il polo

sia fuori dalla banda di regolazione. Per ottenere questo risultato N dovrà assumere

valori bassi, in quanto al crescere di N la nuova funzione di trasferimento (2.26) tenderà

a coincidere con quella senza filtro e quindi si riproporrebbe il comportamento

problematico. Nella figura che segue, la figura 33 vediamo come l’andamento della

risposta in frequenza di un PID migliori in maniera sostanziale se passiamo da una

versione senza filtro sul termine derivativo (linea continua) a una con il filtro (linea

tratteggiata):

73
 FIGURA 34
In ultimo osserviamo che nel caso in cui all’ingresso del controllore ci sia un segnale

r(t) a gradino, seguendo una disposizione classica in parallelo dei blocchi all’interno del

controllore, come quella mostrata nella figura che segue figura 34:

FIGURA 35
Potrebbero sorgere dei problemi in quanto essendo il segnale di riferimento un gradino,

la variabile di controllo u(t), subendo un’azione derivativa, assumerebbe un andamento

74
di tipo impulsivo. Una simile brusca variazione potrebbe provocare la saturazione

dell’attuatore l’allontanamento del sistema dalla condizione di linearità con riferimento

alla quale normalmente si progetta il regolatore. Per tali ragioni in genere si preferisce

utilizzare uno schema modificato in cui l’azione derivativa è esercitata sulla sola

variabile di uscita y(t). Poiché essa Facendo così in modo che la presenza dell’azione

derivativa non provoca il suddetto andamento impulsivo di u(t), infatti y(t) è l’uscita di

un sistema che usualmente ha le caratteristiche di un filtro passa-basso, le sue variazioni

istantanee (e quindi la sua derivata) sono in genere contenute.” [4]. Nella figura che

segue mostriamo lo schema del regolatore PID così modificato:

FIGURA 36

Capitolo3

Introduzione
Come già accennato, in questo capitolo cercheremo di mettere a confronto tecniche di

controllo classiche, nello specifico quelle basate sui regolatori PID e tecniche di

controllo mediante algoritmi di Deep Reinforcement Learning. A tal fine abbiamo

analizzato i risultati ottenuti con ciascuna delle due tecniche prendendo in esame un
75
caso studio in particolare e cioè quello costituito dal pendolo inverso anche noto come

cart-pole problem. Nel seguito quindi mostreremo nello specifico entrambe le tecniche

e a quali conclusioni si può giunge analizzando attentamente i risultati avuti da ricerche

su diversi articoli di studio. La trattazione trae sputo dalle fonti menzionate in

bibliografia “[17] [18]” ed ha uno scopo puramente illustrativo e non sperimentale.

3.1 Controllo del cart-pole mediante tecniche classiche

Il sistema preso in esame è costituito da un carrello semovente e un pendolo inverso. La

finalità del sistema in esame è quella di mantenere in equilibrio il pendolo, agendo sulla

dinamica del carrello semovente. Come si può notare dalla figura che segue il carrello

può muoversi a sinistra o a destra, per mezzo di un motore che agisce direttamente sulle

ruote. Facciamo l’ipotesi che le prestazioni che deve garantire il sistema controllato

sono tali che il pendolo sia in equilibrio instabile con una pendenza massima di 2 gradi

rispetto alla verticale.

PENDOLO
INVERSO
MOTORE IN CC

CARRELLO
SEMOVENTE

BATTERIA

76
3.1.1 Modello del sistema

Allo scopo di identificare il modello del sistema definiamo:

 θ = angolo di inclinazione rispetto alla verticale;

 mc = massa del carrello semovente;

 x = posizione del baricentro del carrello;

 p = posizione del baricentro del pendolo inverso;

 mp = massa del pendolo;

 l = lunghezza del pendolo;

Le specifiche del sistema richiedono che: θ< 2° = π/90 rad, come mostrato dalla

figura che segue:

mp

l

mc

x
p

77
3.1.2 Modello matematico e funzione di trasferimento

Possiamo a questo punto ricavare il modello matematico del sistema per descriverne la

dinamica attraverso l’analisi delle equazioni di bilanciamento delle forze e dei momenti.

Focalizzeremo la nostra attenzione sul carrello semovente e sul pendolo inverso e non

tenendo conto della dinamica propria del motore. Il sistema sarà pertanto

schematizzabile come segue:


g

Dove g è la accelerazione di gravità applicata al centro di massa del pendolo inverso e u

è la forza impressa dal motore all’intero sistema.

I due elementi del sistema il pendolo e il carrello semovente saranno una modellati a

costanti concentrate. Per cui il pendolo avrà tutta la massa concentrata nel proprio

baricentro e le forze esterne agenti su di esso si applicheranno nel punto di giunzione

con il carrello, mentre il carrello avrà tutta la massa concentra nel punto di giunzione

con il pendolo. Definendo il seguente sistema di riferimento cartesiano:

78
 y


l
y

x
x
p

La posizione del pendolo è descritta dalle due coordinate p(t) e y(t):

l
p ( t ) =x+ sin θ 3.1
2

l
y ( t ) = cos θ 3.2
2

Sul pendolo agiscono 3 forze esterne: la gravità, la spinta del carrello lungo l’asse delle

x e la spinta del carrello lungo l’asse delle y. La gravità agisce nel baricentro del

pendolo e le due spinte agiscono nell’estremità del pendolo incernierata con il carrello,

queste forze producono come effetto un’accelerazione lungo l’asse delle x, una

accelerazione lungo l’asse delle y e una accelerazione angolare, tutte applicate al

baricentro del pendolo. Con Jp indicheremo il momento di inerzia del pendolo.

Sul carrello semovente invece agiscono due forze esterne: la spinta del motore che

indicheremo con U, la reazione alla spinta orizzontale del pendolo inverso e la forza di

attrito viscoso di coefficiente β, che si oppone al moto del carrello. La forza di gravità e

la reazione alla spinta verticale del pendolo inverso non forniscono alcun contributo alla

79
dinamica del sistema, in quanto il carrello può spostarsi solo lungo l’asse x, pertanto

non è necessario prenderle in considerazione.

Tali forze causano un solo effetto: una accelerazione lungo l’asse delle x essendo quella

l’unica direzione lungo cui è vincolato a muoversi il carrello. Effettuando il

bilanciamento di tutte queste forze in gioco otteniamo un sistema di due equazioni

differenziali:

{
l l ¨ pθ
mp p̈ cos θ− ( m p ÿ + mp g ) sin θ=J
2 2 3.3
U −m p p̈− β ẋ=mc ẍ

In definitiva sostituendo le 3.1 e 3.2 nella 3.3 avremo:

{ ( ) ( ( ) )
2 2
l d l l d l
mp 2 x + sin θ cos θ− m p 2 cos θ + m p g sin θ=J p θ̈
2 dt 2 2 dt 2 3.4

( )
2
d l
U −m p 2 x + sin θ −β ẋ=mc ẍ
dt 2

Notiamo che il sistema di equazioni differenziali ottenuto è non lineare. È

possibile però effettuare una approssimazione per piccole oscillazioni attorno

al punto di equilibrio instabile θ = 0. Tale approssimazione è plausibile in

quanto le specifiche del sistema richiedono che: θ < 2° = π/90 radianti. In base

a quanto detto allora avremo:

{
θ≈0
sin θ ≈ θ
cos θ ≈ 1

Applicando l’approssimazione di cui sopra si ottiene un sistema lineare:

80
 { ( ) ( () )
2 2
l d l l d l
mp 2 x + θ cos θ− m p 2 + mp g θ=J p θ̈
2 dt 2 2 dt 2 3.5

( )
2
d l
U −m p 2 x+ sin θ −β ẋ=mc ẍ
dt 2

Svolgendo le derivate infine avremo il sistema:

{
l l2 l
mp ẍ + mp θ̈− mp gθ=J p θ̈
2 4 2 3.6
l
U −m p ẍ−mp θ̈−β ẋ=mc ẍ
2

Ponendo inoltre:

l
 L=
2

 M =m p +mc

E raggruppando i coefficienti avremo il sistema:

{ m p L ẍ=( J p −m p L2 ) θ̈+ mp Lgθ 3.7

U =M ẍ + β ẋ +m p L θ̈

Trasformando le 3.7 secondo Laplace avremo:

{
m p LX s 2=( J p−m p L2 ) θ s2 +m p Lgθ
2
U =MX s + βXs+m p Lθ s
2
3.8

Infine mettendo il termine in X nella prima equazione delle 3.8 e sostituendolo nella

seconda avremo la funzione di trasferimento ingresso uscita del sistema, dove

l’ingresso è rappresentato dalla spinta del motore U e l’uscita dalla posizione angolare

del pendolo, dopo alcune manipolazioni essa può essere espressa nella seguente forma:

81
 θ(s) m p Ls
= 3.9
U ( s) ( M J p −M m p L2+ m2p L2 ) s 3+ β ( J p−m p L2 ) s2 + M m p Lgs+ β m p Lg

Consideriamo i seguenti valori numerici per i parametri del sistema e cioè:

 m p=0.2 Kg

 mc =0.5 Kg

 l = 0.6 m (L = 0.3m)

 β = 0.1 Nm-1s

 g = 9.9 ms-2
l
2
mp 2 m
 J p= ∫ x dx= p l 2=0.006 Kg m2
−l l 12
2

Allora la funzione di trasferimento che descrive il sistema in esame sarà:

θ(s) 0.06 s
=P ( s )= 3.10
U ( s) −0.0048 s −0.0012 s 2 +0.4158 s +0.0594
3

3.1.3 Controllo a ciclo aperto

I poli e gli zeri della funzione di trasferimento sono:

 p1 = 9.2546
 p2 = -9.3618
 p3 = -0.1428
 z1 = 0
Possiamo notare subito la presenza di uno zero nell’origine e cioè un derivatore.

Inoltre notiamo che sono tutti poli reali ma che in particolare p1 è un polo a parte

reale positiva ciò comporta che il modo di evoluzione ad asso associato tende a

divergere e a causa di questo polo quindi il sistema risulta instabile e non avrà

regime permanente. Sappiamo l’importanza che ricopre la risposta impulsiva in

quanto essa rappresenta la funzione di trasferimento del sistema nel dominio del

tempo e che basta conoscere la risposta impulsiva per ricostruire la risposta del

82
sistema ad un qualsiasi segnale quindi abbiamo provato a perturbare il sistema e

abbiamo visto cosa succede quando il sistema è fermo e quindi in equilibrio

instabile e viene perturbato da un impulso, l’andamento è mostrato nella figura che

segue:

FIGURA 37

A causa proprio della natura instabile della condizione di equilibrio di partenza

dopo un tempo di ritardo iniziale, l’angolo θ diventa negativo e va ben oltre le

specifiche imposte. Allo scopo di studiare la dinamica del sistema abbiamo poi

provato a sollecitare il sistema con una spinta costante e cioè abbiamo studiato la

83
risposta a gradino. Calcoliamo innanzitutto il guadagno della funzione di

trasferimento:

1 0.06
K=lim P ( s )= =1.0101 3.11
s →0 s 0.0594

Usando la 3.11, la funzione di trasferimento può essere scritta come:

s
P ( s )=K 3.12
( 1−
s
)(
p1
1−
s
p2
1−
)(
s
p3 )
L’uscita al gradino unitario sarà data quindi dalla seguente formula:

1 1
θ ( s )=P ( s ) =K 3.13
s ( 1+s τ 1 ) ( 1+s τ 2 ) ( 1+s τ 3 )

La risposta quindi presenta tre esponenziali con costanti di tempo:

−1
 τ1= =−0.108
p1

−1
 τ 2= =0.1068
p2

−1
 τ3= =7.0028
p3

La risposta indiciale è risultata essere la seguente:

84
 FIGURA 38

Notiamo ancora una volta che dopo un tempo iniziale di ritardo, l’angolo θ diventa

negativo e va nuovamente oltre le specifiche richieste. Concludiamo che il sistema in

esame è instabile e qualsiasi segnale di comando in ingresso sia esso impulsivo o

costante, genera in uscita instabile che non si può limitare e quindi risulta chiara

l’impossibilità di utilizzare una modalità di controllo a catena aperta.

3.1.4 Controllo a ciclo chiuso

Sappiamo che il controllo a ciclo chiuso permette di ottenere come vantaggio una

migliore reiezione ai disturbi, maggiore attenuazione dei rumori di misura, riduzione

dell’errore a regime oltre alla possibilità di modificare la risposta in transitorio.

85
Abbiamo visto nel paragrafo precedente che, essendo il sistema in esame in equilibrio

instabile qualsiasi ingresso e quindi forma di energia immessa nel sistema lo perturba e

lo porta in condizioni di instabilità. La presenza di un disturbo può essere fatale ecco

che abbiamo scelto questa diversa metodologia di controllo atta ad attenuare effetti di

disturbi costanti sul pendolo o sul carrello. Consideriamo quindi il seguente sistema a

catena chiusa, con segnale di riferimento R(s) nullo:

FIGURA 39

Notiamo la presenza di un disturbo D(s) agente direttamente sull’angolo θ del pendolo.

La funzione di trasferimento disturbo-uscita è data da:

Y ( s )=D ( s ) +θ ( s ) =D ( s )+ P ( s ) U ( s )=D ( s ) + P ( s ) G ( s ) E ( s ) 3.14

Con R(s)= 0, E(s )= R(s) -Y(s)= -Y(s) la 3.14 diventa:

Y ( s )=D ( s )−P ( s ) G ( s ) Y ( s ) =D ( s )−L ( s ) Y ( s ) →Y ( s ) [ 1+ L ( s ) ] =D(s) 3.15

Da cui avremo:

Y (s) 1
= 3.16
D ( s ) 1+ L ( s )

Ipotizziamo in un primo momento che il controllore sia costituito da una semplice

azione proporzionale con funzione di trasferimento G(s) = K G. La 3.16 allora sarà data

da:

86
 Y (s) 1
= 3.17
D ( s ) 1+ K G P ( s )

Tracciando il luogo delle radici di P(s), possiamo studiare l’andamento dei poli della

funzione di trasferimento ingresso-uscita al variare di KG. Esso è dato da:

z (s )
1+ K G P ( s )=1+ K G =0 → p ( s ) + K G z ( s )=0 3.18
p (s )

Il luogo delle radici quindi sarà:

FIGURA 40

È evidente come all’aumentare di K G il polo p3, già prossimo allo zero z 1, continua ad

avvicinarsi all’origine, il che implica costanti di tempo ancora più grandi e cioè

transitorio ancora più lungo. Il luogo delle radici mostra chiaramente l’impossibilità di

stabilizzare il sistema attraverso un’azione puramente proporzionale nel controllore in

87
quanto il sistema ad anello chiuso, indipendentemente dal valore di K G presenta un

polo a parte reale positiva che all’aumentare di K G va all’infinito. Applicando una

controreazione con contributo solo proporzionale all’errore rispetto alla posizione

voluta (θ= 0), il derivatore che agisce nel processo P(s) amplifica tutte le variazioni del

segnale di ingresso U(s) che non sono attenuate nella controreazione. Infatti sappiamo

che l’azione proporzionale aumenta la velocità di risposta del sistema all’aumentare del

guadagno proporzionale ma per guadagni elevati, diminuisce la stabilità aumentando le

oscillazioni. Sorge quindi la necessità di attenuare il più possibile le variazioni

repentine in uscita dal controllore U(s), proviamo perciò ad aggiungere una azione

integrale che «addolcisca» le variazioni del segnale U(s), integrando E(s). Aggiungere

un integratore 1/s al controllore, implica eliminare l’effetto del derivatore (zero

nell’origine) presente nel processo. Il luogo delle radici con G(s) = K I /¿s diventa:

88
 FIGURA 41

Esso ancora una volta mostra chiaramente l’impossibilità di stabilizzare il sistema

attraverso un intervento puramente integrale nel controllore. Infatti si vede che per

valori opportunamente elevati di K I i poli a parte reale negativa convergono rendendo

instabile il sistema e diventano complessi coniugati. L’effetto dell’azione integrale è

comunque evidente: la cancellazione dello zero nell’origine di P(s) con il polo

nell’origine di G(s), fa sì che i due poli a parte reale negativa, all’aumentare di K I ,

rimangano nel semipiano sinistro. Concludiamo che intervenendo con un controllore

dotato di sola azione integrale G(s) = K I /¿s si elimina l’effetto dovuto al derivatore

grazie al polo nell’origine dell’integratore, assicura un errore nullo a regime per

variazioni a gradino del segnale di riferimento r(t), ma non si modifica il polo p a parte

89
reale positiva che causa l’instabilità del sistema a catena aperta e del sistema a catena

chiusa.

Bisogna pertanto scegliere un controllore che abbia una funzione di trasferimento in

grado di influenzare la posizione dei poli nella funzione di trasferimento a catena

chiusa. Nello specifico introduciamo un regolatore PID la cui funzione di trasferimento

sarò data da:

G ( s )=K P +
KI
s
+ K D s=
KI
s
1+
KP
KI(s+
KD 2
KI
s 3.19
)
Ricaviamo quindi i valori dei guadagni mediante il metodo di sintesi diretta, riscriviamo

la funzione del regolatore come:

KG
G ( s )= ( 1+ α s + β s 2) 3.20
s

Dove abbiamo posto:

KP KD
K G =K I α = β= 3.21
KI KI

Mettendo in evidenza gli zeri la 3.20 diventa:

KG K
G ( s )= ( 1+ μ s ) ( 1+γ s )= G ( 1+ ( μ+ γ ) s+ μγ s2 ) 3.22
s s

Per cui vale il sistema:

{α=μ+γ
β=μγ

90
La funzione di anello L(s) sarà:

KG Ks K G K ( 1+ μ s )( 1+ γ s )
L ( s )=G ( s ) P ( s ) = ( 1+ μ s )( 1+ γ s ) = 3.23
s ( 1+ s τ 1) ( 1+ s τ 2) ( 1+ s τ 3 ) ( 1+ s τ 1) ( 1+ s τ 2) ( 1+ s τ 3 )

La funzione di trasferimento disturbo-uscita in catena chiusa sarà:

Y (s ) 1 1 ( 1+ s τ 1 ) ( 1+s τ 2 ) ( 1+s τ 3 )
W ( s )= = = = 3.24
D ( s ) 1+ L ( s )
1+
K G K ( 1+ μ s )( 1+ γ s ) ( 1+ s τ 1 ) ( 1+ s τ 2 ) ( 1+ s τ 3 ) + K G K ( 1+ μ s ) (1+ γ s )
( 1+ s τ 1 )( 1+ s τ 2 )( 1+ s τ 3 )

Per conseguire il nostro obiettivo di ottenere tutti poli a parte reale negativa cerchiamo

di semplificare il denominatore annullando qualche polo con qualche zero. Possiamo ad

esempio imporre che:

μ=τ 2 γ =τ 3 3.25

Otteniamo quindi la funzione:

Y (s) ( 1+ s τ 1 ) ( 1+ s τ 1 )
= = 3.26
D ( s ) ( 1+ s τ 1 ) + K G K ( K G K +1 ) + s τ 1

La 3.24 può essere riscritta come:

Y (s ) 1 ( 1+ s τ 1) ' ( 1+ s τ 1 )
W ( s )= = =K 3.27
D ( s ) ( K G K +1 ) τ1 ( 1+ s τ ' )
1+ s
( K G K +1 )

' 1
Avendo posto nella 3.27 K =
( K G K +1 )

Dalla 3.25 si vede come la condizione necessaria e sufficiente affinché il sistema sia

stabile è che τ ' sia un valore positivo perciò è sufficiente imporre che:
91
 ' τ1
τ= >0 3.28
( K G K +1 )

Essendo τ 1 =−0.108 , la 3.26 implica che deve essere anche denominatore minore di

zero e cioè deve aversi:

1
K G K +1<0 ↔ K G ← =−0.99 3.29
K

Ricordando che K I =K G , scegliendo K G =−1 possiamo ricavare anche gli altri

guadagni del PID, tenendo presente le 3.21 e le 3.25, avremo:

 K I =K G =−1

 K P=K I α=−( μ +γ )=−( τ 2 + τ 3 )=−7.1096

 K D=K I β=−( μγ )=−( τ 2 τ 3 ) =−0.7479

Con questa configurazione dei parametri PID, se da un lato abbiamo garantito la

stabilità del sistema a controreazione dall’altra la risposta ad un disturbo costante, a

gradino, non è per niente soddisfacente come possiamo notare dalla figura che segue:

92
 FIGURA 42
Sappiamo dalle specifiche che l’errore a regime permanente dovrebbe essere inferiore a

2°, ovvero a 2π/180 = 0.0349 radianti. Notiamo che la funzione ad anello aperto L(s) è

del tipo 0, non presenta poli in zero in quanto tale polo dovuto all’integratore è stato

cancellato dallo zero della funzione di trasferimento del nostro sistema. Dalle 3.23,

considerate le 3.25 abbiamo che:

KG K
L ( s )=P ( s ) G ( s ) = 3.30
( 1+ s τ 1 )

Pertanto l’uscita a regime permanente, dato un ingresso (ovvero disturbo su θ) costante

(ovvero un gradino unitario), sarà pari a:

' (
1 1+ s τ 1 ) '
y ( ∞ )=lim y (t)=lim sY ( s )=lim s W ( s )=lim K =K 3.31
t →∞ s →0 s→0 s s→0 ( 1+s τ )'

Essendo K ' per come lo abbiamo definito pari a:

' −1
K =( K G K +1 )

E avendo scelto K G =−1

93
La risposta a regime permanente sarà:

−1
y ( ∞ )=( K G K +1 ) =( 1−1.0101 )=
−1 −1
=−99.01 3.32
0.0101

Volendo un valore della y ( ∞ ) entro le specifiche cioè un valore di θ inferiore a 2°,

ovvero a 2π/180 = 0.0349 radianti dobbiamo porre:

1
| y ( ∞ )|<0.0349 →|( K G K +1 )−1|<0.0349 →| K G K + 1|> 3.33
0.0349

Ricordiamo che le condizioni di stabilità trovate prima ci hanno imposto che

K G K +1<0 3.34

Pertanto dalla 3.33 dovrà essere:

−1 +1
< K K+ 1< 3.35
0.0349 G 0.0349

Ma tenuto conto della 3.34 in definitiva avremo che la condizione da rispettare sarà:

1
−( K G K +1 ) > 3.36
0.0349

Il che implica:

1 1.0349 −1.0349
−K G K >1+ = → KG< =−27.3319 3.37
0.0349 0.0349 K 0.0349

In definitiva scegliendo K G =−30 i parametri del controllore saranno:

 K I =K G =−30

 K P=−7.1096

94
  K D=−0.7479

Con questa configurazione dei parametri PID, riusciamo sia a soddisfare le condizioni di

stabilità del sistema che ad avere una risposta all’errore costante unitario che rispetta le

specifiche. Come mostrato dalla figura che segue:

FIGURA 43

3.2 Controllo mediante tecniche di Deep RL

3.2.1 Ambiente di simulazione

In questo paragrafo per prima cosa introdurremo brevemente il framework Bullet

Phisics utilizzato per creare e simulare l’ambiente cart-pole. Il problema della

95
simulazione di un ambiente reale è molto sentito. Molte volte è impossibile o

impraticabile sperimentare direttamente sul campo in quanto è necessario ad esempio

effettuare studi in assenza di gravità oppure la sperimentazione richiederebbe troppo

tempo e risorse) quindi la simulazione ci viene in aiuto per accelerare e rendere possibili

questi studi. Bullet è un modulo software che simula un modello fisico newtoniano

utilizzando variabili come massa, velocità, attrito alla resistenza del vento e altro. Il

motore, utilizzando questi dati e le leggi newtoniane, simula il comportamento degli

oggetti sottoposti alle forze del mondo (reale o immaginario).

Bullet è open source, realizzato in linguaggio C++ e la sua versione in

linguaggioPython su cui è basato il lavoro qui proposto è pyBullet. PyBullet viene

impiegato per la simulazione fisica di robot, giochi, effetti visivi e machine learning.

PyBullet offre la possibilità di utilizzare oggetti 3D in diversi formati e fornisce

meccanismi sofisticati come la simulazione dinamica forward, cinematica inversa,

collision detection, inoltre fornisce l’integrazione con Gym openAI, toolkit in Python

per gestire in maniera semplice ambienti simulati utilizzabili per implementare tecniche

di machine learning. Oltre alla simulazione, il framework fornisce supporto alla realtà

virtuale. Bullet sfrutta le API fornite da OpenGL “ [19] ” per il rendering del proprio

ambiente. OpenGL (Open Graphics Library) è un interfaccia software per il motore

grafico. È una libreria di grafica e modellazione 3D, molto veloce e performante. Sono

fornite implementazioni di OpenGL per le principali piattaforme e sistemi operativi

inclusi ovviamente Windows, Mac OS e Linux. OpenGL è progettato per essere

utilizzato con hardware dedicato alla visualizzazione e manipolazione di grafica 3D.

OpenGLutilizza un approccio procedurale anziché descrittivo. Ciò significa che invece

di descrivere la scena e come dovrebbe apparire, il programmatore scrive passo dopo

96
passo le operazioni necessarie per creare l’aspetto desiderato. Per la creazione di questo

ambiente sono state scelte ed utilizzate due tecnologie software: OpenAi Gym e

pyBullet. OpenAi Gym, come già accennato, è un toolkit nato per la ricerca in

Reinforcement Learning che, oltre ad includere una collezione in continua crescita di

ambienti, fornisce interfacce ed astrazioni perla definizione di nuovi ambienti. PyBullet

invece è un framework che mette a disposizione un motore grafico per la simulazione

3D di corpi solidi. Quindi l’ambiente in esame è stato creato utilizzando l’interfaccia

OpenAi Gym mentre pyBullet ha il compito di gestire le dinamiche e la fisica dei

componenti e dell’ambiente stesso. Il cart-pole problem rappresenta un classico

problema in letteratura in machine Learning e consiste nel controllare la posizione x di

un carrello (cart) affinché il palo (pole) montato sopra di esso rimanga il più possibile in

posizione verticale. Il sistema presenta due gradi di libertà. In questo modo il palo potrà

solamente cadere in avanti o indietro. La posizione del cart potrà solamente spostarsi in

avanti o indietro. Gli ambienti devono essere di natura episodica per cui deve essere

presente uno stato terminale. Ogni episodio deve terminare sia in caso di

raggiungimento dell’obiettivo sia in caso contrario. Se l’obiettivo viene raggiunto

parliamo di stato terminale di successo, mentre se viene raggiuntolo stato terminale

senza conseguimento dell’obiettivo parliamo di stato terminale di insuccesso. Nel caso

specifico l’obiettivo è il raggiungimento di 500 step consecutivi (nello stesso episodio).

Diamo quindi per raggiunto l’obiettivo di bilanciamento del pole se trascorre un certo

numero di step senza che il palo cada. Il limite viene posto per evitare che gli episodi

portino via troppo tempo in fase di learning. Il reward utilizzato in questi ambienti è un

reward cumulativo: ciò significa che ogni step di un determinato episodio ha come

reward in uscita sempre 1. In questo modo viene sommato ai reward all’interno dello

97
stesso episodio. Così facendo, più il reward è alto più il palo viene mantenuto stabile e

bilanciato. In questo ambiente dove il problema è quello di mantenere un certo stato il

più a lungo possibile (il bilanciamento) un reward unico e cumulativo può essere una

buona scelta. Definito come deve essere assegnato il reward è opportuno definire di

quali valori dovrà essere composto lo stato dell’ambiente. Lo stato è composto da un

vettore di parametri che descrivono l’ambiente nella sua condizione corrente. Nel cart-

pole problem l’ambiente è descritto da 4 stati: 2 stati che descrivono il cart ovvero

posizione (x) e velocità (x_dot) e 2 che descrivono il pole, ovvero angolo di

inclinazione (theta) e velocità angolare (theta_dot). I metodi forniti dagli ambienti, agli

algoritmi di learning che poi li utilizzeranno, prendono il nome di reset e step. Il

metodo reset ha il compito di resettare l’ambiente, portandolo nel suo stato iniziale.

Comprende le istruzioni per il loading di tutti gli elementi solidi che dovranno essere

caricati dal motore grafico e ritornano lo stato iniziale dell’ambiente. Il metodo step ha

il compito di eseguire un’azione e modificare di conseguenza lo stato dell’ambiente.

Questo metodo coincide quindi con uno step di esecuzione dato dall’algoritmo di

learning. Il metodo presenta al proprio interno un vettore contenente tutte le azioni

possibili come mostrato nel codice che segue:

La variabile deltav prende il valore dell’azione scelta dalla variabile action passata come

parametro al metodo step, essa viene poi utilizzata per modificare lo stato del corpo

solido all’interno della simulazione. L’ambiente cart-pole viene caricato all’interno del

metodo reset attraverso il comando loadURDF:

98
L’ambiente è composto da 2 file URDF: plane.urdf che ha il solo scopo di definire

l’appoggio ai corpi solidi della scena, e il file cartpole.urdf in cui è definito il cart.

3.2.2 Implementazione degli algoritmi

In questo paragrafo vengono presentati e descritti gli algoritmi di learning utilizzati

per l’apprendimento degli ambienti descritti nel paragrafo precedente. Degli algoritmi di

Q-Learning e DQN che sono stati introdotti teoricamente nel capitolo 1 di questa tesi,

verranno illustrate le implementazioni, con riferimenti al codice. Q-Learning con

utilizzo della forma tabellare prevede una Q-table in cui vengono rappresentate le

coppie stato-azione. A causa della natura di questo algoritmo, lo stato dell’ambiente

viene discretizzato in bucket. Il secondo metodo, DQN (Deep Q-Network) è un

algoritmo più avanzato che prevede l’utilizzo di una rete neurale al posto della Q-Table.

Lo pseudo-codice sopra riportato mostra la struttura su cui sono basati gli algoritmi

di learning implementati. La natura degli algoritmi prevede un ciclo iterativo ad episodi

nel quale l’agente dovrà apprendere. Ad ogni inizio episodio il metodo reset provvede a

99
resettare l’ambiente restituendo lo stato iniziale. All’interno di ogni episodio è presente

un altro ciclo che itera gli step t di simulazione dell’ambiente.

Il metodo render attua la simulazione a schermo mentre il metodo choose_action

sceglie un’azione sulla base dello stato iniziale che viene poi passata come parametro al

metodo step dell’environment che esegue lo step di simulazione sull’ambiente.

Successivamente le variabili state, state2, reward, action vengono utilizzate per il

passo di learning vero e proprio, che dipende dall’algoritmo utilizzato. Il metodo step

oltre a restituire il nuovo stato state2, restituisce anche il flag done utile a comprendere

se occorre resettare l’ambiente e passare all’episodio successivo, oppure continuare al

prossimo step di simulazione.

Algoritmo Q-Learning

Come già illustrato nel capitolo introduttivo, Q-Learning è un metodo temporal

difference off-policy per il reinforcement learning, ovvero aggiorna la funzione valore

ad ogni passo di step. L’approccio off-policy indica invece un procedimento che utilizza

due tipi di policy: una policy totalmente greedy che viene utilizzata per l’esplorazione

(behavior policy) delle coppie stato-azione in modo tale da non ricadere in ottimi locali,

e una policy di apprendimento vera e propria con politica ε-greedy chiamata anche

target policy. Attraverso un fattore di esplorazione (exploration rate) si spinge

l’algoritmo verso una scelta esplorativa piuttosto che di apprendimento. Con l’avanzare

degli episodi l’exploration rate viene decrementato per dare più peso alla policy di

apprendimento. Nella pratica quindi si cerca di mantenere una politica maggiormente

esplorativa all’inizio del training per poi spostare l’attenzione sul fattore di

apprendimento. La natura off-policy dell’algoritmo richiede in ingresso parametri

aggiuntivi oltre a quelli forniti dall’ambiente come dimensionalità dello stato o numero

100
di azioni eseguibili. Tre sono i parametri aggiuntivi: α, ε,ϒ che rappresentano

rispettivamente learning rate, exploration rate e discounting rate. I fattori di learning e

discount sono rappresentati nella formula 1.13 presentata nel capitolo1,e vengono

calcolati da funzioni che prendono in input il time step t:

max_exp_rate è il fattore massimo da cui parte l’algoritmo al time step 0 e viene

fissato a 0.8. Ciò significa che inizialmente la politica di esplorazione verrà scelta con

percentuale del 80% rispetto alla politica di learning. La formula descritta dal codice

permette il decremento del fattore di esplorazione e la velocità di tale decremento è data

dalla variabile decay_speed che viene richiesta come parametro di ingresso. Più

decay_speed assume valore prossimo allo zero, più lento sarà il decremento di ε.

Anche il fattore α (learning rate) decrementa all’aumentare del time step: il massimo

valore che può assumere è fissato a 0.5 mentre il valore minimo a 0.01. Il learning rate,

o tasso di apprendimento, determina con quale estensione le nuove informazioni

acquisite sovrascriveranno le vecchie informazioni. Un fattore 0 impedirebbe all’agente

di apprendere, al contrario un fattore pari ad 1 farebbe sì che l’agente si interessi solo

delle informazioni recenti. Risultati sperimentali dimostrano che il learning rate

dinamico utilizzato in questo algoritmo da risultati migliori rispetto ad un tasso di

apprendimento fisso. L’unico fattore fisso è il discount rate γ, esso determina

101
l’importanza delle ricompense future. Un fattore pari a 0 renderà l’agente "opportunista"

facendo sì che consideri solo le ricompense attuali, mentre un fattore tendente ad 1

renderà l’agente attento anche alle ricompense che riceverà in un futuro a lungo termine.

In letteratura è comune utilizzare discount rate prossimo ad 1 perciò è stato scelto γ=

0.99.

Il metodo choose_action permette la scelta dell’azione da intraprendere sulla base del

trade-off illustrato precedentemente tra esplorazione e apprendimento. Si va infatti a

scegliere la beauvoir policy greedy che consiste in una scelta randomica dell’azione,

oppure viene utilizzata la target policy che preleva l’azione con il Q-value maggiore

dalla tabella stato-azione.

L’update della Q-Table segue la formula 1.13 dove best_q è il valore maggiore ottenuto

per lo stato state e gamma è il discount rate.

Per utilizzare la tabella Q-table per la memorizzazione dei valori per le coppie stato-

azione è necessario discretizzare gli stati. La discretizzazione è stata realizzata

attraverso una tecnica a bucket. Fissato il numero di bucket per ogni parametro dello
102
stato si sfrutta una funzione che, preso in input lo stato in forma non discretizzata,

permette lo “smistamento” e quindi la discretizzazione restituendo il bucket a cui viene

assegnato.

La Q-Table è inizializzata come segue:

dove bucket_size è una tupla di n elementi dove n è la dimensionalità dello stato mentre

num_actions è la dimensionalità data dal numero delle azioni si ottiene quindi la forma

tabellare con coppie stato-azione.

Tutte le configurazioni dei vari parametri compreso il numero di bucket scelto per

ogni stato verrà discusso assieme ai risultati ottenuti nel paragrafo 3.2.4.

103
Algoritmo Deep Q-Network

Grazie all’algoritmo di Deep Q-Nework il problema di discretizzazione degli stati con

conseguente perdita di informazioni che potrebbero risultare importanti e decisive al

learning dell’ambiente può essere risolto. La Q-Table infatti viene sostituita da una rete

neurale la quale non necessita più di alcuna forma di discretizzazione che approssima la

funzione valore. La rete prende lo stato come input e produce una stima della funzione

valore per ogni azione. Il nome Deep Q-Network deriva dall’utilizzo di più livelli

nascosti nella composizione della rete. Purtroppo l’utilizzo di una rete neurale per

rappresentare la funzione valore non sempre produce risultati stabili. Per rispondere a

questo problema sono stati introdotte quindi alcune idee chiave per stabilizzare il

training.

Il primo concetto da illustrare è quello dell’experience replay. Il problema con gli

algoritmi di learning è quello di avere un alto livello di correlazione tra esperienze

successive. Per questo motivo, la rete potrebbe facilmente andare in overfitting con

conseguente fallimento nel creare un apprendimento generalizzato e quindi più genuino.

L’idea attraverso l’experience replay è quindi quella di salvare le esperienze in una

memoria chiamata replay memory e durante ogni passo di learning recuperare in

maniera randomica un campione di tali transazioni. Similmente a quanto

detto per Q-Learning, anche DQN utilizza metodologia off-policy per bilanciare la

componente esplorativa con quella di apprendimento. Oltre ai parametri richiesti in

input per il funzionamento dell’agente già citati nell’algoritmo Q-Learning come

dimensionalità dello stato, numero di azioni, decay_speed vengono richiesti altri

parametri. Che sono:

 num_input, numero di neuroni per l’input layer (valore fornito dall’ambiente);

104
  num_output, numero di neuroni per l’output layer (valore fornito

dall’ambiente);

 num_hidden, numero di neuroni per ogni hidden layer;

 MEM_CAPACITY, capacità della replay memory;

 learning rate, Learning rate per l’optimaizer RMSprop;

Per realizzare la rete neurale è stata utilizzata la libreria python Tensor-Flow [20],

framework opensource per il machine learning. In particolare della libreria TensorFlow

si utilizzano le API fornite da Keras [21] per la creazione della rete neurale, che

permette con poche righe di codice la creazione di una rete neurale in maniera molto

intuitiva tramite il codice mostrato di seguito:

Il metodo create_net sopra citato permette la creazione di una rete neurale con

tre livelli nascosti con funzione di attivazione ReLu mostrata nella figura4 del capitolo

1. Il livello finale consta invece di un numero di neuroni pari al numero di azioni

105
dell’environmentcon funzione di attivazione lineare. Il metodo add permette di

aggiungere sequenzialmente i layer alla rete. Questi layer sono di tipologia "Dense"

ovvero i neuroni sono fully connected con i neuroni del livello successivo. Invece di una

semplice funzione di gradient descent, viene utilizzato un algoritmo più sofisticato per

l’ottimizzazione ovvero RMSprop [22] e l’errore quadratico medio (mse) come

funzione

da minimizzare. Poichè la rete implementa una tecnica di regressione (e non di

classificazione) viene utilizzata come loss function l’errore quadratico medio invece di

cross entropy. Gli errori calcolati dalla loss function saranno propagati all’indietro nella

rete mediante un passo backward, seguendo la logica di discesa del gradiente con

l’intento di minimizzare l’errore. Una volta creata la rete viene lanciato il metodo Train

che contiene la logica di governo dell’environment:

106
La logica di funzionamento rispecchia quanto detto ad inizio capitolo. Il metodo

choose_action funziona similmente al metodo introdotto in Q-Learning: l’azione viene

scelta sulla base di una policy esplorativa e una policy di apprendimento.

L’environment esegue l’azione è ritorna un nuovo stato ed un reward. L’agente quindi

prende in osservazione la nuova tupla (s; a; r; s ’), la aggiunge in replay memory e

aggiorna ε, variabile che controlla la velocità di decadimento. Come ultimo step viene
107
aggiornata la rete e quindi eseguito il passo di learning vero e proprio. Nel codice

mostrato di seguito è descritto il metodo per l’aggiornamento dei pesi nella rete neurale:

Il metodo prende come parametri di input il fattore di discount (settato a 0.99 come per

Q-Learning) e la dimensione di batch da considerare. Vengono quindi selezionati

randomicamente, dalla replay memory, n elementi che comporranno il nostro batch.

Vengono quindi fatte le predizioni per tutti gli stati iniziali e finali del batch in un unico

step. La variabile no_state viene utilizzata come variabile dummy di stato quando lo
108
stato finale è None, questo perchè Keras non supporta lo stato None che in questo caso

viene sostituito con un array di zero. La variabile p ora contiene le predizioni per gli

stati iniziali è verrà usata come variabile target per il learning (variabile T

nell’algoritmo 3 mostrato nel paragrafo 4 del capitolo 1). La variabile p_ invece

contiene le predizioni degli stati finali e viene utilizzata nella parte finale della formula

maxa Q( s ' ; a) (algoritmo 3). Per ogni campione prelevatodalla replay memory vengono

salvate iterativamente le variabili target e stato in due vettori x e y che vengono poi dati

in input alla funzione fit che esegue uno step di gradient descend aggiornando la rete.

A conclusione, per completezza viene mostrato qui di seguito il codice della classe

Memory che implementa la replay memory:

Notiamo che essa è costituita da 2 metodi: il metodo add semplicemente aggiunge il

campione alla memoria, mentre il metodo pick_n ritorna un numero n di campioni presi

109
dalla memoria. Se la memoria risulta piena, add provvede ad eliminare il primo

campione

aggiunto per far posto al nuovo.

3.2.4 Risultati ottenuti

Nel seguito di questo paragrafo conclusivo vengono proposte le configurazioni e i

risultati ottenuti dai metodi Q-Learning e Deep Q-Network applicati all’ambiente cart-

pole.

Ogni episodio di training ha durata massima 700 step, posto come limite per non

allungare ulteriormente i tempi di learning, mentre il numero di step minimo per

considerare l’avvenuto learning di bilanciamento è di 500 step. L’episodio quindi

termina prima se il bilanciamento fallisce, altrimenti si considera l’oggetto bilanciato se

l’episodio dell’ambiente si protrae fino al 500esimo step o oltre. Il completamento della

fase di training prevede il salvataggio della Q-Table per Q-Learning e dei pesi della rete

neurale per DQN. Questi risultati vengono sottoposti a testing su 500 episodi per

ricavare l’indice di accuratezza delle coppie agenti-ambienti. Saranno riportati e

discussi i grafici ottenuti dagli algoritmi Q-Learning e Deep Q-Network. Infine saranno

confrontati i due metodi, riepilogando i valori di performance ottenuti.

La configurazione adottata per questo ambiente è riassunta nella tabella che segue:

110
 TABELLA 1 CONFIGURAZIONE PARAMETRI IN AMBIENTE CART-POLE

Per quanto riguarda l’algoritmo Q-Learning il parametro più complesso da settare è la

dimensionalità dei bucket per ogni stato dell’ambiente. Dopo varie configurazioni

provate, quella mostrata in tabella risulta essere la più performante per lo scopo

prefissato (raggiungere il bilanciamento nel numero minore possibile di episodi). La

velocità di decadimento fissata a 0.0001 permette ad ε un’esplorazione decrescente fino

ad arrivare agli ultimi episodi di training dove il valore è prossimo a 0.01. Nel seguito

viene riportato il grafico delle performance del metodo Q-Learning in fase di training:

111
 FIGURA 44 PERFORMANCE DELL’ALGORITMO Q-LEARNING

La misura delle perfomance degli agenti è stata calcolata attraverso l’indice di

accuratezza:

episodi completati correttamente

accuracy=
episodi totali

Dove si considerano gli episodi correttamente classificati quelli che superano la soglia

impostata di 500 step consecutivi. Il numero totale di episodi considerati per

112
calcolare questo indice è di 500. Il testing viene fatto utilizzando, per Deep QNetwork,

i pesi salvati in fase di learning delle reti neurali, e le Q-Table salvate per l’algoritmo Q-

Learning.

Il grafico riporta l’andamento del total reward medio ogni 100 episodi (arancione) e il

total reward massimo ogni 100 episodi. L’algoritmo si considera risolto quando

completa con successo 500 episodi consecutivi: si nota infatti come nel grafico gli

ultimi total reward registrati siano tutti sopra la soglia di vincita dell’algoritmo (linea

verde).

Per quanto riguarda invece l’algoritmo Deep Q-Network l’obiettivo non consiste

solamente nel raggiungere il reward più alto, ma consiste nel farlo nel minor numero di

episodi possibile. Per questo motivo e per la natura semplice dell’ambiente, è stato

possibile configurare la rete con un unico livello nascosto anzichè tre come proposto nel

precedente paragrafo. Anche la decay_speed è stata ridotta per permettere un

decadimento più veloce del parametro ε poiché vogliamo ottenere il bilanciamento in un

numero ridotto di episodi. Nel grafico che segue viene mostrato il risultato del learning.

113
 FIGURA 45 PERFORMANCE DELL’ALGORITMO DEEP Q-NETWORK

La differenza di episodi rispetto a Q-Learning è evidente: con agente DQN, l’ambiente

impara a bilanciare il pole in circa 2500 episodi, al contrario di Q-Learning dove ve ne

sono richiesti più di 20mila. Si può notare come l’algoritmo DQN non raggiunga per

tutti gli episodi il valore massimo stabilito dall’algoritmo di 700 step. Probabilmente ciò

114
è dovuto alla terminazione dell’algoritmo che necessita solamente di 500 episodi

consecutivi sopra i 500 step per episodio (soglia fissata dall’algoritmo).

Mettendo a confronto i due algoritmi adottati si può notare che l’algoritmo Q-Learning

ha buoni risultati, nonostante il passo di discretizzazione effettuato sugli stati, con una

accuracy del 100% che produce comunque un reward medio superiore alla soglia

minima di 500 step e questo è un limite di Q-Learning . Per quanto riguarda le

potenzialità di Deep-QNetwork le reti neurali create si sono dimostrate molto

performanti, sia in termini di risultati ottenuti, sia di memoria utilizzata, l’agente ha

mostato una accuracy del 99.60% con un reward medio di 697.262 comunque superiore

alla soglia minima.

Conclusioni

L’utilizzo di internet e in particolare dei Social Network ha oramai invaso le nostre vite

in maniera totalizzante e del tutto trasparente, inserendosi in maniera centrale nella

stragrande maggioranza di tutte le nostre attività giornaliere, siano esse lavorative o

ricreative. Tutto ciò ha spinto i diversi ambiti di ricerca ad affrontare sempre maggiori

problematiche e a svariare su diversi fronti. Negli ultimi anni è diventato di

fondamentale importanza l’utilizzo di tecniche di Intelligenza Artificiale, quindi di

“apprendimento automatico. Oggi l’Intelligenza Artificiale è sfruttata da molti colossi

informatici, tecnologici e non: Facebook la sfrutta per i propri algoritmi di tag, Google

per la ricerca delle foto, Amazon per indicare consigli sui prodotti e sugli acquisti e così

anche altre piattaforme social come Pinterest o Instagram; questi algoritmi riscuotono

grande successo nell’identificazione di visi umani oltre che di determinati oggetti in

immagini e video oltre che essere molto usate per il riconoscimento di tracce audio e

115
linguaggi naturali, e in un'ampia varietà di branche del sapere, dove è difficile o non

fattibile sviluppare algoritmi convenzionali per eseguire i compiti richiesti in medicina

ad per riconoscere ad esempio dati diversi sintomi come essi possono essere sintomi di

una determinata patologia piuttosto che un'altra . L’obiettivo dichiarato e verso cui si

sta puntando con decisione in ambito machine learning è pareggiare e in alcuni casi

superare i risultati che riesce ad ottenere l’essere umano. Nell'ambito dell’informatica

l’apprendimento automatico è una variante alla programmazione tradizionale, grazie

alla quale in una macchina si predispone l'abilità di apprendere qualcosa dai dati in

maniera autonoma, senza istruzioni esplicite . In generale nell’ambito dei controlli come

abbiamo cercato di mettere in evidenza in questa tesi, i limiti sono ancora visibili a

causa di tutta una serie di infrastrutture presenti nelle aziende che andrebbero cambiate

o quanto meno riadattate allo scopo di imparare a controllare i processi per ottimizzare

gli obiettivi predefiniti e imparare a predire lo stato successivo del processo che si sta

controllando. Nello specifico caso di studio che abbiamo preso in esame possiamo

concludere che i risultati ottenuti sono stati soddisfacenti con entrambe le tecniche di

controllo in quanto siamo riusciti, nel caso di controllo mediante PID a settare i

parametri del regolatore in modo da ottenere prestazioni soddisfacenti e riuscire a tenere

fede alle specifiche date sull’angolo θ, nel caso invece del bilanciamento del sistema

cart-pole tramite algoritmi di Deep Renforcement Learning ottimi risultati variare in

particolare del parametro ε usato dall’algoritmo nella fase di apprendimento.

In conclusione possiamo aggiungere che un aspetto da non sottovalutare è che

l’apprendimento automatico solleva una problematica per così dire etica in ragione

dell’innata varietà e talvolta ambiguità del linguaggio umano, al contrario della

116
macchina che manca di spirito critico e di conseguenza la raccolta responsabile dei dati

può diventare un aspetto problematico dell'apprendimento automatico.

Bibliografia

[1] P. Simon., Too Big to:The Business Case for Big Data., Wiley, 2013.

[2] Y. Li., Deep reinforcement learning: An overview., https://arxiv.org/abs/ 1810.06339,

2018..

[3] S. R. S. S. a. A. G. Barto, "Reinforcement Learning: An Introduction", 2018,2020: The MIT

Press Cambridge, Massachusetts.

[4] C. J. C. H. .Watkins, Learning from delayed rewards., London: PhD thesis, King’s College,
1989.

[5] J. M. a. K. M. Anil K Jain, «"Artificial neural networks:A tutorial".,» In Computer 3, 1996.

[6] R. C. N. M. Pasquale Rosati, Istologia, Milano: Edi.Ermes, 2006.

[7] “. S. t. d. u. c. n. v. p. i. p. Manuale MSD, “Figure: Struttura tipica di una cellula nervosa".

[8] G. Buttazzo, "Reti neurali in grado di apprendere.”,

http://retis.sssup.it/~giorgio/paps/2020/Ithaca20-Buttazzo.pdf,, 2020.

[9] S. A. E. M. H. a. D. T. M. H. Esfe, «“A well-trained artificial neural network for predicting

the rheological behavior of mwcnt–al2o3 (30–70%)/oil sae40 hybrid nanofluid,”,»
Scientific Reports,, Vol. %1 di %2vol. 11, , n. no. 1,, p. pp. 1–11, 2021..

[10] G. Gullo, “Deep learning svelato: ecco come funzionano le reti neurali artificiali..”,
https://medium.com/professionai/deep-learning-svelato-ecco-come-funzionano-le-reti-
neurali-artificiali-f7dced2, 2018.

[11] N. Manchev, “Convolutional neural networks with pytorch domino data lab..”,
https://www.dominodatalab.com/blog/gpu-accelerated-convolutional-neural-networks-
with-pytorch, 2022..

[12] A. V. Pratik Choudhari, “Understanding ‘convolution’ operations in cnn.",

https://medium.com/analytics-vidhya/understanding-convolution-operations-in-cnn-
1914045816d4, , 2020.

[13] K. K. D. S. A. G. I. A. D. W. V Mnih e M Riedmiller,, "Playing Atari with Deep Reinforcement

Learning",, DeepMind, 2013.

[14] R. S. N. S. P. Bolzern, Fondamenti di controlli automatici. II edizione, Mc Graw – Hill..

117
[15] G. F. P. R. G.A. Magnani, Tecnologie dei sistemi di controllo. II edizione, Mc Graw – Hill,
2020.

[16] G. Marro., Controlli automatici. V edizione, Bologna.: Zanichelli editore.

[17] A. D. Carli, Sulla scelta di una modalità di controllo, Collana Editoriale Universitaria
eCampus.

[18] R. C. D. R. H. Bishop, Controlli Automatici, Pearson.

[19] O. https://www.opengl.org/.

[20] TensorFlow. https://www.tensorflow.org/.

[21] Keras. https://keras.io/.

[22] R. K. Shubhendu Trivedi, «Optimization for Deep Neural,» University of Chicago, vol.
Lecture 6, 2017.

[23] J. M. a. K. M. ". n. n. Anil K Jain, "Artificial neural networks:A tutorial"., In Computer 3

(1996)..

118