Caught in the Net (Posts about Genetic algorithm)

Capire il Machine Learning (parte 3)

Francesco Mecca — Tue, 15 Nov 2016 00:00:00 GMT

Riconoscimento delle immagini

Il machine learning viene utilizzato anche per il riconoscimento delle immagini. La tipologia di rete neurale utilizzata per questa applicazione è chiamata rete neural a convoluzione ( convolutional neural networks), abbreviata CNN.

Innanzitutto consideriamo che ogni immagine può essere codificata come una matrice di valori

Vediamo ora quali sono le operazioni compiute da una CNN per riconoscere delle immagini.

Convoluzione

Durante la fase di apprendimento, la rete neurale analizza moltissime immagini (categorizzate) utilizzando dei "filtri", ovvero delle funzioni che mescolate all'input originale permettono di evidenziare dei pattern nell'immagine. Questi pattern corrispondono alle caratteristiche proprie di un oggetto (quali possono essere ad esempio per un uccello il becco, le piume, le ali) e nel caso queste sono presenti, possiamo riconoscere l'immagine.

In questo esempio l'immagine di Wally é mescolata (l'operazione si chiama convoluzione) con un filtro "a cerchio" che risponde molto bene a caratteristiche come quella di possedere degli occhi.

La convoluzione é un'operazione che ha la proprietà di essere indipendente dalla posizione. Non importa la posizione degli occhi, quando applichiamo la convoluzione su un'immagine con un filtro "a cerchio" notiamo che gli occhi sono presenti.

Subsampling

Ogni segnale contiene del "rumore", ovvero degli elementi che la allontanano dal comportamento ideale.

Attraverso il subsampling possiamo ridurre il rumore e rendere il nostro algoritmo meno suscettibile a queste piccole variazioni; benché l'immagine abbia una risoluzione minore, i pattern rimangono.

Connessione completa

Alla fine dell'analisi tutte le caratteristiche estrapolate vengono considerate nell'insieme e in questo modo possiamo capire a quale categoria appartiene l'immagine.

Questo procedimento a livello algoritmo si esplicita con una connessione completa fra tutti i nodi della rete neurale che possono poi restituire l'output (probabilità che l'immagine appartenga ad una determinata categoria).

Fase di rinforzo

Durante il training é presente un'ultima fase (o strato), chiamato più propriamente loss layer. Questo strato provvede a dare un feedback alla rete neurale analizzando l'output in relazione ai dati di partenza (ovvero le immagini già categorizzate).

Capire il Machine Learning (parte 2)

Francesco Mecca — Fri, 11 Nov 2016 00:00:00 GMT

Nel precedente post abbiamo preso in considerazione una rete neurale molto basica. Proviamo ora ad approfondire il concetto aggiungendo una proprietà fondamentale, la memoria.

Memoria e Stati

La rete neurale che abbiamo modellato non ha alcun tipo di memoria. con gli stessi dati di input, l'output è (quasi certamente) lo stesso. Possiamo ampliare il nostro modello introducendo il concetto di stato.

Poniamo il problema della vendita delle auto in questo modo: immaginiamo di avere un algoritmo di machine learning che valuti le auto e faccia delle offerte di vendita che conseguentemente vengono valutate da delle persone e accettate oppure rifiutate. Ogni volta che una proposta viene accettata la teniamo in memoria e nell'aggiustare i pesi per la seguente offerta, teniamo in considerazione la validità dei pesi usati in precedenza. In altre parloe, in ogni operazione di valutazione dell'auto salviamo lo stato dell'offerta precedente (rifiutata o accettata) e la consideriamo quando vogliamo proporre l'offerta successiva. Abbiamo in questo modo una recurrent neural network (RNN) dove ogni stato precedente viene utilizzato per modificare l'output dell'algoritmo.

Generazione di testo attraverso le RNN

Immaginiamo di voler creare un algoritmo che utilizzando una RNN possa generare del testo o prevedere quale sarà il prossimo carattere inserito (come nel caso del T9).

Inizialmente dobbiamo permettere alla RNN di analizzare almeno qualche sample del nostro testo. La RNN analizza carattere dopo carattere e costruisce un grande grafo dove collega ogni carattere al suo successivo. Inizialmente l'output della nostra RNN non ha alcun valore: in questo esempio, abbiamo l'output di una RNN allenata attraverso Guerra e Pace:

tyntd-iafhatawiaoihrdemot  lytdws  e ,tfti, astai f ogoh eoase rrranbyne 'nhthnee e 
plia tklrgd t o idoe ns,smtt   h ne etie h,hregtrs nigtike,aoaenns lngty

L'output prodotto dalla RNN, benchè non abbia nessun valore per un umano, viene analizzato dalla RNN per arricchire il grafo costituito inizialmente dai caratteri (e le loro relazioni) di Guerra e Pace. Questo procedimento continua all'infinito. Ogni volta che la RNN produce dell'output lo salva e lo riutilizza come input in maniera ricorsiva per generare nuovo output.

Dopo 300 iterazioni abbiamo un output di questo tipo:

"Tmont thithey" fomesscerliund
Keushey. Thom here
sheulke, anmerenith ol sivh I lalterthend Bleipile shuwy fil on aseterlome
coaniogennc Phe lism thond hon at. MeiDimorotion in ther thize."

Dopo quasi mille:

Aftair fall unsuch that the hall for Prince Velzonski's that me of
her hearly, and behs to so arwage fiving were to it beloge, pavu say falling misfort 
how, and Gogition is so overelical and ofter.

Duemila:

"Why do what that day," replied Natasha, and wishing to himself the fact the
princess, Princess Mary was easier, fed in had oftened him.
Pierre aking his soul came to the packs and drove up his father-in-law women.

Possiamo notare come l'output migliori visibilmente.

Nel prossimo post tratterò una variante di rete neurale utilizzata per classificare e riconoscere immagini.

Capire il Machine Learning (parte 1)

Francesco Mecca — Thu, 10 Nov 2016 00:00:00 GMT

Questo è il primo di una serie di post che hanno l'obbiettivo di fornire una breve e generale introduzione al mondo del machine learning e delle intelligenze artificiali più in generale. Mi auguro che questa breve introduzione al mondo dell'apprendimento automatico sia una sorta di vaccino contro il sensazionalismo mediatico e la disinformazione che negli ultimi anni fanno da contorno al progresso in questo settore.

Non c'è risultato senza algoritmo

Nelle scienze informatiche un algoritmo è un insieme di istruzioni che partendo da uno stato iniziale (input) permette di arrivare ad uno stato finale (output) attraverso una serie di step logici. Ogni algoritmo utilizza una logica propria e specifica per il problema di cui si occupa. Nel caso del machine learning l'algoritmo non viene progettato in base al tipo di problema bensì vengono utilizzati algoritmi generici adattabili attraverso dei parametri. L'algoritmo di machine learning analizza i vari parametri e i dati che riceve "in pasto" al fine di raggiungere lo stato di output ottimale. L'output ottimale è la migliore approssimazione di un risultato teorico che si raggiunge nella fase di "training".

La macchina impara

Nella fase di allenamento o di apprendimento, il "training", si possono adottare due tecniche differenti: apprendimento con supervisione ( supervised learning ) e apprendimento senza supervisione ( unsupervised learning ).

Supervised Learning

Immaginiamo di dover valutare il prezzo di un'automobile usata senza essere esperti in materia. Noi abbiamo questi dati:

PREZZO ORIGINALE	Km percorsi	stato di usura	PREZZO FINALE
50 000	120 000	lieve	40 000
30 000	150 000	notevole	8 000
20 000	80 000	lieve	15 000
20 000	120 000	notevole	...

Dalla tabella possiamo dedurre la caratteristica fondamentale del supervised learning: abbiamo due vettori (serie di dati) di input (prezzo originale) e di output (prezzo finale) che hanno una correlazione certa e valida.

Possiamo dedurre intuitivamente quale sarà il prezzo dell'ultima auto se analizziamo i dati precedenti. Questo è quello che succede nel caso del supervised learning. Un algoritmo di machine learning che utilizza il supervised learning estrapolerà la relazione fra i vari dati e in questo modo potrà ottenere un determinato output partendo dai dati di input. Possiamo capire già da ora che nel caso ci fossero dati che "inquinano" il nostro data set, come ad esempio il colore dell'auto, l'algoritmo non sarà capace di fare un'analisi corretta.

La precisione della soluzione dipende dalla quantità di dati e dall'influenza che questi hanno nella situazione reale.

Unsupervised Learning

Nel caso di unsupervised learning ci troviamo di fronte agli stessi dati ma senza la possibilità di conoscere il prezzo finale.

PREZZO ORIGINALE	Km percorsi	stato di usura
50 000	120 000	lieve
30 000	150 000	notevole
20 000	80 000	lieve
20 000	120 000	notevole

Non siamo capaci di stabilire il prezzo finale attraverso l'unsupervised learning, ma possiamo stabilire dei pattern fra i vari dati. Non c'è nessun tipo di feedback (il prezzo finale) che possa aiutarci a capire se il risultato sia giusto ma possiamo analizzare le notevoli relazioni fra i dati.

Machine Learning e intelligenza

Concentriamoci sul supervised learning. Nel caso della vendita dell'automobile, abbiamo un semplice problema con una soluzione lineare di questo tipo: prezzo finale = prezzo originale + km percorsi + stato di usura

Ovviamente ogni incognita nella nostra equazione influisce diversamente sul prezzo finale e quindi possiamo riscriverla come: prezzo finale = A prezzo originale + B km percorsi + C * stato di usura

Se pensiamo ad un algoritmo possiamo ragionare in questo modo:

funzione: calcola_prezzo_auto:
    parametri: prezzo_originale, km_percorsi, stato_usura
    variabili: prezzo_finale = 0

    prezzo finale = prezzo_originale * 0.804246
    prezzo finale = prezzo_finale + km_percorsi * -0.000125
    prezzo finale = prezzo_finale + stato_usura * -2500

I valori di quelle costanti, stabilite casualmente nell'esempio, sono chiamate pesi e servono a stimare il prezzo finale. Una volta stabiliti i pesi, il nostro algoritmo di supervised learning applica questi pesi ai dati originali e ne valuta l'errore:

PREZZO ORIGINALE	Km percorsi	stato di usura	PREZZO FINALE	PREZZO STIMATO
50 000	120 000	lieve	40 000	374888
30 000	150 000	notevole	8 000	16000
20 000	80 000	lieve	15 000	13492
20 000	120 000	notevole	...	10988

Una volta valutato l'errore e la distanza dal prezzo finale, l'algoritmo di machine learning modifica i pesi di conseguenza e ripete la procedura fino ad arrivare al risultato che più si avvicina ai dati iniziali. Ci sono varie funzioni che stimano l'errore e permettono di correggere i pesi o metodi che restringono lo spazio di ricerca fino a convergere alla soluzione, ovvero i pesi cercati.

Reti Neurali

Ora, come possiamo immaginare, il prezzo di un'auto ha molti fattori che si aggiungono a quelli elencati nell'esempio. Non solo, ma molti problemi non hanno una soluzione lineare, ovvero una soluzione che si può semplicemente esprimere attraverso una funzione che aggiunge e moltiplica i valori una sola volta.

Possiamo arricchire l'esempio dell'automobile immaginando di avere più set di pesi e di ripetere il procedimento più volte:

|---------------------------------------------------|
| PREZZO_ORIG * peso A1 ----->                      |
| KM_PERCORSI * peso B1 ----->                      |
| STATO_USURA * peso C1 ----->                      |
|                            PREZZO FINALE STIMATO 1|
|---------------------------------------------------|

| --------------------------------------------------|
| PREZZO_ORIG * peso A2 ----->                      |
| KM_PERCORSI * peso B2 ----->                      |
| STATO_USURA * peso C2 ----->                      |
|                            PREZZO FINALE STIMATO 2|
|---------------------------------------------------|

| --------------------------------------------------|
| PREZZO_ORIG * peso A3 ----->                      |
| KM_PERCORSI * peso B3 ----->                      |
| STATO_USURA * peso C3 ----->                      |
|                            PREZZO FINALE STIMATO 3|
|---------------------------------------------------|

E ora immaginiamo di combinare ogni PREZZO FINALE STIMATO in un'ultimo risultato:

| --------------------------------------------------|
| PREZZO_1 * peso X  ----->                         |
| PREZZO_2 * peso Y  ----->                         |
| PREZZO_3 * peso Z  ----->                         |
|                            PREZZO FINALE DEF      |
|---------------------------------------------------|

Questa é, seppur molto basica, una rete neurale. Proviamo a visualizzarla in un'immagine dove i box arancioni sono i nodi di input e i rossi sono i nodi "nascosti" e temporanei.

In una rete neurale (neural networks) abbiamo:

i neuroni: la funzione di stima e i set di pesi;
le catene: i collegamenti fra neuroni che permettono di valutare il prezzo più volte.

Nel prossimo post cercherò di approfondire il concetto di rete neurale con degli esempi di applicazioni concrete.

Interpolation using a genetic algorithm

Francesco Mecca — Sun, 15 May 2016 00:00:00 GMT

This weekend I was in Milan to get a visa and I had the opportunity to work with a friend, Michele, on genetic algorithms. It was the first time I dig up in such field and it was very exciting. In this post I want to explain some bits of our work.

A brief introduction to GA

A genetic algorithm is a search/optimization algorithm that uses an heuristic approach to reduce the search space and evolve gradually to a solution.

Population

It is an algorithm that has its root in the theory of natural selectioni by Charles Darwin. The main components of a GA are:

the population, that concentrate all the available solutions at a given time;
the fitness function, that gives an approximation of the quality of the solution codified by a given member of the population.

In a GA the first thing to do is to generate a population.

A population is a group of objects with given attributes, usually a string, and they contains in some form the solution (usually inside a string); the first population is randomly generated and contains a big number of solutions, but not every solution (this is not a bruteforce approach).

After this step the fitness functions evaluates the quality of every solution that a given member carries: the evaluation should be considered from a bottom up point of view.

Reproduction

Now, as in Darwin's theory of evolution, the member of the population are going to "reproduce": two members are going to be coupled to generate a new member of the second generation and every child member will contain a solution that is the product of the original genes of their parent members.

This time the reproduction of the population into a second one is not entirely random. The fitness function gives us an approximation of the quality of every gene that a member carries and by the rule of the "survival by the fittest" the probability that a member is going to reproduce with another one is proportional to the quality of its genes.

When we have a second generation of members we can recur on our GA and generate a third generation. From this point we can recur until we converge to a solution that is common to every member, or at least that is suited to our needs.

Mutation

Actually, in some cases, a mutation function can be added, so that, like in real world, some times the genes are "scrambled" indipendently from the fitness function.

There is more to a GA, for example we could talk about possible ways of storing the genes inside a member or when to use mutation, anyway I want to stop here and continue with an analysis of my problem.

Interpolating a function using a GA

Me and Michele decided to spend some time developing a little python script to explore GA capabilities and we decided to interpolate some points on a cartesian plane.

Our program, that is available here uses a class to define the various members of the population and a string for the genes, a class as well for the points on the plane.

The fitness function is not as precise as it should be because this is only a proof of concept:

.. code:: python

mutationProbability = 0.1
rangeLimit = 5
def fitness(item, pointList, n):
    value = 0
    for p in pointList:
        y = 0
        for i in range(n):
           y += item.gene[i] * pow(p.x, i)
        result = 1 - (abs (p.y - y) / rangeLimit)
        if result < 0:
            result = 0
        value += result
    return value / n

item is just a member of the population, poinList is the list of points and n is the number of points (n - 1 is the grade of the function).

for i in range(n):
    y += item.gene[i] * pow(p.x, i)

this piece of code gives us the value of the function encoded in the genes in the points of pointList;

result = 1 - (abs (p.y - y) / rangeLimit)
    if result < 0:
        result = 0

while here the script stores 1 - the previous result because if the GA has yield a good result there should be distance = 0 from the function evaluated and the points; If this is the case, the fitness function should attribute the highest possible reproduction probability for that member. At the end the fitness function returns the total value over the number of points evaluated.

As you can see this fitness function is by no means an optimal one. The reproduction probability is higher for functions that crosses some points and are really distant from others rather than for functions that are closer to every point but crosses none. Anyway for simple cases the GA yields good results, as an example for points (0 0), (1 4), (2 9) one of the member with the highest reproduction probability has this function in its genes:

-0.0487839869993989 * x^0 + 4.600339125358671 * x^1 + -0.2780958075230644 * x^2

that crosses this points: (0 -0.0488), (1 4.2735), (2 8.0395) given 80 iterations, initial population of 600 members and a two digit approximation.

For a more precise computation a higher population size and a really high number of iterations should be used.