273 lines
22 KiB
XML
273 lines
22 KiB
XML
<?xml version="1.0" encoding="utf-8"?>
|
|
<?xml-stylesheet type="text/xsl" href="../assets/xml/rss.xsl" media="all"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Caught in the Net (Posts about reti neurali)</title><link>francescomecca.eu</link><description></description><atom:link href="francescomecca.eu/categories/reti-neurali.xml" rel="self" type="application/rss+xml"></atom:link><language>en</language><copyright>Contents © 2020 <a href="mailto:francescomecca.eu">Francesco Mecca</a> </copyright><lastBuildDate>Wed, 29 Jan 2020 10:04:35 GMT</lastBuildDate><generator>Nikola (getnikola.com)</generator><docs>http://blogs.law.harvard.edu/tech/rss</docs><item><title>Capire il Machine Learning (parte 3)</title><link>francescomecca.eu/blog/2016/11/15/machine-learning-parte3/</link><dc:creator>Francesco Mecca</dc:creator><description><div><h3>Riconoscimento delle immagini</h3>
|
|
<p>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 ( <strong>convolutional neural networks</strong>), abbreviata CNN.</p>
|
|
<p>Innanzitutto consideriamo che ogni immagine può essere codificata come una matrice di valori</p>
|
|
<p><img alt="pixel" src="francescomecca.eu/wp-content/uploads/2016/8.jpg"></p>
|
|
<p>Vediamo ora quali sono le operazioni compiute da una <strong>CNN</strong> per riconoscere delle immagini.</p>
|
|
<h5>Convoluzione</h5>
|
|
<p>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.</p>
|
|
<p>In questo esempio l'immagine di Wally é mescolata (l'operazione si chiama <strong>convoluzione</strong>) con un filtro "a cerchio" che risponde molto bene a caratteristiche come quella di possedere degli occhi.</p>
|
|
<p><img alt="waldoblue" src="francescomecca.eu/wp-content/uploads/2016/bluefilter.png"></p>
|
|
<p>La <strong>convoluzione</strong> é un'operazione che ha la proprietà di essere indipendente dalla posizione. Non importa la posizione degli occhi, quando applichiamo la <strong>convoluzione</strong> su un'immagine con un filtro "a cerchio" notiamo che gli occhi sono presenti.</p>
|
|
<h5>Subsampling</h5>
|
|
<p>Ogni segnale contiene del "rumore", ovvero degli elementi che la allontanano dal comportamento ideale. </p>
|
|
<p><img alt="ideal" src="francescomecca.eu/wp-content/uploads/2016/ideal.jpg"></p>
|
|
<p><img alt="real" src="francescomecca.eu/wp-content/uploads/2016/real.jpg"></p>
|
|
<p>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.</p>
|
|
<p><img alt="waldosub" src="francescomecca.eu/wp-content/uploads/2016/sub.png"></p>
|
|
<h5>Connessione completa</h5>
|
|
<p>Alla fine dell'analisi tutte le caratteristiche estrapolate vengono considerate nell'insieme e in questo modo possiamo capire a quale categoria appartiene l'immagine.</p>
|
|
<p>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).</p>
|
|
<h5>Fase di rinforzo</h5>
|
|
<p>Durante il training é presente un'ultima fase (o strato), chiamato più propriamente <strong>loss layer</strong>. Questo strato provvede a dare un <strong>feedback</strong> alla rete neurale analizzando l'output in relazione ai dati di partenza (ovvero le immagini già categorizzate).</p></div></description><category>AI</category><category>algoritmi genetici</category><category>Genetic algorithm</category><category>Neural networks</category><category>PesceWanda</category><category>programming</category><category>reti neurali</category><guid>francescomecca.eu/blog/2016/11/15/machine-learning-parte3/</guid><pubDate>Tue, 15 Nov 2016 00:00:00 GMT</pubDate></item><item><title>Capire il Machine Learning (parte 2)</title><link>francescomecca.eu/blog/2016/11/11/machine-learning-parte2/</link><dc:creator>Francesco Mecca</dc:creator><description><div><p>Nel precedente <a href="francescomecca.eu/pescewanda/2016/11/10/machine-learning-intro/">post</a> abbiamo preso in considerazione una rete neurale molto basica.
|
|
Proviamo ora ad approfondire il concetto aggiungendo una proprietà fondamentale, la memoria.</p>
|
|
<h3>Memoria e Stati</h3>
|
|
<p>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 <em>stato</em>.</p>
|
|
<p>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 <em>recurrent neural network</em> (RNN) dove ogni stato precedente viene utilizzato per modificare l'output dell'algoritmo.</p>
|
|
<h5>Generazione di testo attraverso le RNN</h5>
|
|
<p>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).</p>
|
|
<p>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:</p>
|
|
<pre class="code literal-block"><span></span>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
|
|
</pre>
|
|
|
|
|
|
<p>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.</p>
|
|
<p>Dopo 300 iterazioni abbiamo un output di questo tipo:</p>
|
|
<pre class="code literal-block"><span></span>"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."
|
|
</pre>
|
|
|
|
|
|
<p>Dopo quasi mille:</p>
|
|
<pre class="code literal-block"><span></span>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.
|
|
</pre>
|
|
|
|
|
|
<p>Duemila:</p>
|
|
<pre class="code literal-block"><span></span>"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.
|
|
</pre>
|
|
|
|
|
|
<p>Possiamo notare come l'output migliori visibilmente.</p>
|
|
<p>Nel prossimo post tratterò una variante di rete neurale utilizzata per classificare e riconoscere immagini.</p></div></description><category>AI</category><category>algoritmi genetici</category><category>Genetic algorithm</category><category>Neural networks</category><category>PesceWanda</category><category>programming</category><category>reti neurali</category><guid>francescomecca.eu/blog/2016/11/11/machine-learning-parte2/</guid><pubDate>Fri, 11 Nov 2016 00:00:00 GMT</pubDate></item><item><title>Capire il Machine Learning (parte 1)</title><link>francescomecca.eu/blog/2016/11/10/machine-learning-intro/</link><dc:creator>Francesco Mecca</dc:creator><description><div><p>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.</p>
|
|
<h3>Non c'è risultato senza algoritmo</h3>
|
|
<p>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".</p>
|
|
<h3>La macchina impara</h3>
|
|
<p>Nella fase di allenamento o di apprendimento, il "training", si possono adottare due tecniche differenti: apprendimento con supervisione ( <strong>supervised learning</strong> ) e apprendimento senza supervisione ( <strong>unsupervised learning</strong> ).</p>
|
|
<h5>Supervised Learning</h5>
|
|
<p>Immaginiamo di dover valutare il prezzo di un'automobile usata senza essere esperti in materia.
|
|
Noi abbiamo questi dati:</p>
|
|
<table>
|
|
<thead>
|
|
<tr>
|
|
<th>PREZZO ORIGINALE</th>
|
|
<th align="center">Km percorsi</th>
|
|
<th align="center">stato di usura</th>
|
|
<th align="right">PREZZO FINALE</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>50 000</td>
|
|
<td align="center">120 000</td>
|
|
<td align="center">lieve</td>
|
|
<td align="right">40 000</td>
|
|
</tr>
|
|
<tr>
|
|
<td>30 000</td>
|
|
<td align="center">150 000</td>
|
|
<td align="center">notevole</td>
|
|
<td align="right">8 000</td>
|
|
</tr>
|
|
<tr>
|
|
<td>20 000</td>
|
|
<td align="center">80 000</td>
|
|
<td align="center">lieve</td>
|
|
<td align="right">15 000</td>
|
|
</tr>
|
|
<tr>
|
|
<td>20 000</td>
|
|
<td align="center">120 000</td>
|
|
<td align="center">notevole</td>
|
|
<td align="right">...</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
<p>Dalla tabella possiamo dedurre la caratteristica fondamentale del <strong>supervised learning</strong>: abbiamo due vettori (serie di dati) di input (prezzo originale) e di output (prezzo finale) che hanno una correlazione certa e valida.</p>
|
|
<p>Possiamo dedurre intuitivamente quale sarà il prezzo dell'ultima auto se analizziamo i dati precedenti.
|
|
Questo è quello che succede nel caso del <strong>supervised learning</strong>.
|
|
Un algoritmo di machine learning che utilizza il <strong>supervised learning</strong> 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.</p>
|
|
<p>La precisione della soluzione dipende dalla quantità di dati e dall'influenza che questi hanno nella situazione reale.</p>
|
|
<h2>Unsupervised Learning</h2>
|
|
<p>Nel caso di unsupervised learning ci troviamo di fronte agli stessi dati ma senza la possibilità di conoscere il prezzo finale.</p>
|
|
<table>
|
|
<thead>
|
|
<tr>
|
|
<th>PREZZO ORIGINALE</th>
|
|
<th align="center">Km percorsi</th>
|
|
<th align="right">stato di usura</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>50 000</td>
|
|
<td align="center">120 000</td>
|
|
<td align="right">lieve</td>
|
|
</tr>
|
|
<tr>
|
|
<td>30 000</td>
|
|
<td align="center">150 000</td>
|
|
<td align="right">notevole</td>
|
|
</tr>
|
|
<tr>
|
|
<td>20 000</td>
|
|
<td align="center">80 000</td>
|
|
<td align="right">lieve</td>
|
|
</tr>
|
|
<tr>
|
|
<td>20 000</td>
|
|
<td align="center">120 000</td>
|
|
<td align="right">notevole</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
<p>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.</p>
|
|
<h2>Machine Learning e intelligenza</h2>
|
|
<p>Concentriamoci sul <strong>supervised learning</strong>.
|
|
Nel caso della vendita dell'automobile, abbiamo un semplice problema con una soluzione lineare di questo tipo:
|
|
<em>prezzo finale</em> = <em>prezzo originale</em> + <em>km percorsi</em> + stato di usura</p>
|
|
<p>Ovviamente ogni incognita nella nostra equazione influisce diversamente sul prezzo finale e quindi possiamo riscriverla come:
|
|
<em>prezzo finale</em> = A <em><em>prezzo originale</em> + B </em><em>km percorsi</em> + C * stato di usura</p>
|
|
<p>Se pensiamo ad un algoritmo possiamo ragionare in questo modo:</p>
|
|
<pre class="code literal-block"><span></span><span class="n">funzione</span><span class="o">:</span> <span class="n">calcola_prezzo_auto</span><span class="o">:</span>
|
|
<span class="n">parametri</span><span class="o">:</span> <span class="n">prezzo_originale</span><span class="o">,</span> <span class="n">km_percorsi</span><span class="o">,</span> <span class="n">stato_usura</span>
|
|
<span class="n">variabili</span><span class="o">:</span> <span class="n">prezzo_finale</span> <span class="o">=</span> <span class="mi">0</span>
|
|
|
|
<span class="n">prezzo</span> <span class="n">finale</span> <span class="o">=</span> <span class="n">prezzo_originale</span> <span class="o">*</span> <span class="mf">0.804246</span>
|
|
<span class="n">prezzo</span> <span class="n">finale</span> <span class="o">=</span> <span class="n">prezzo_finale</span> <span class="o">+</span> <span class="n">km_percorsi</span> <span class="o">*</span> <span class="o">-</span><span class="mf">0.000125</span>
|
|
<span class="n">prezzo</span> <span class="n">finale</span> <span class="o">=</span> <span class="n">prezzo_finale</span> <span class="o">+</span> <span class="n">stato_usura</span> <span class="o">*</span> <span class="o">-</span><span class="mi">2500</span>
|
|
</pre>
|
|
|
|
|
|
<p>I valori di quelle costanti, stabilite casualmente nell'esempio, sono chiamate <em>pesi</em> 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:</p>
|
|
<table>
|
|
<thead>
|
|
<tr>
|
|
<th>PREZZO ORIGINALE</th>
|
|
<th align="center">Km percorsi</th>
|
|
<th align="center">stato di usura</th>
|
|
<th align="center">PREZZO FINALE</th>
|
|
<th align="right">PREZZO STIMATO</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>50 000</td>
|
|
<td align="center">120 000</td>
|
|
<td align="center">lieve</td>
|
|
<td align="center">40 000</td>
|
|
<td align="right">374888</td>
|
|
</tr>
|
|
<tr>
|
|
<td>30 000</td>
|
|
<td align="center">150 000</td>
|
|
<td align="center">notevole</td>
|
|
<td align="center">8 000</td>
|
|
<td align="right">16000</td>
|
|
</tr>
|
|
<tr>
|
|
<td>20 000</td>
|
|
<td align="center">80 000</td>
|
|
<td align="center">lieve</td>
|
|
<td align="center">15 000</td>
|
|
<td align="right">13492</td>
|
|
</tr>
|
|
<tr>
|
|
<td>20 000</td>
|
|
<td align="center">120 000</td>
|
|
<td align="center">notevole</td>
|
|
<td align="center">...</td>
|
|
<td align="right">10988</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
<p>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.
|
|
<img alt="rete1" src="francescomecca.eu/wp-content/uploads/2016/reteneurale1.jpg">
|
|
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.</p>
|
|
<h3>Reti Neurali</h3>
|
|
<p>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.</p>
|
|
<p>Possiamo arricchire l'esempio dell'automobile immaginando di avere più set di pesi e di ripetere il procedimento più volte:</p>
|
|
<pre class="code literal-block"><span></span>|---------------------------------------------------|
|
|
| PREZZO_ORIG * peso A1 -----&gt; |
|
|
| KM_PERCORSI * peso B1 -----&gt; |
|
|
| STATO_USURA * peso C1 -----&gt; |
|
|
| PREZZO FINALE STIMATO 1|
|
|
|---------------------------------------------------|
|
|
|
|
| --------------------------------------------------|
|
|
| PREZZO_ORIG * peso A2 -----&gt; |
|
|
| KM_PERCORSI * peso B2 -----&gt; |
|
|
| STATO_USURA * peso C2 -----&gt; |
|
|
| PREZZO FINALE STIMATO 2|
|
|
|---------------------------------------------------|
|
|
|
|
| --------------------------------------------------|
|
|
| PREZZO_ORIG * peso A3 -----&gt; |
|
|
| KM_PERCORSI * peso B3 -----&gt; |
|
|
| STATO_USURA * peso C3 -----&gt; |
|
|
| PREZZO FINALE STIMATO 3|
|
|
|---------------------------------------------------|
|
|
</pre>
|
|
|
|
|
|
<p>E ora immaginiamo di combinare ogni PREZZO FINALE STIMATO in un'ultimo risultato:</p>
|
|
<pre class="code literal-block"><span></span>| --------------------------------------------------|
|
|
| PREZZO_1 * peso X -----&gt; |
|
|
| PREZZO_2 * peso Y -----&gt; |
|
|
| PREZZO_3 * peso Z -----&gt; |
|
|
| PREZZO FINALE DEF |
|
|
|---------------------------------------------------|
|
|
</pre>
|
|
|
|
|
|
<p>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.</p>
|
|
<p><img alt="rete2" src="francescomecca.eu/wp-content/uploads/2016/reteneurale2.jpg"></p>
|
|
<p>In una rete neurale (<em>neural networks</em>) abbiamo:</p>
|
|
<ul>
|
|
<li>
|
|
<p>i neuroni: la funzione di stima e i set di pesi;</p>
|
|
</li>
|
|
<li>
|
|
<p>le catene: i collegamenti fra neuroni che permettono di valutare il prezzo più volte.</p>
|
|
</li>
|
|
</ul>
|
|
<p>Nel prossimo <a href="francescomecca.eu/pescewanda/2016/11/11/machine-learning-PARTE2">post</a> cercherò di approfondire il concetto di rete neurale con degli esempi di applicazioni concrete.</p></div></description><category>AI</category><category>algoritmi genetici</category><category>Genetic algorithm</category><category>Neural networks</category><category>PesceWanda</category><category>programming</category><category>reti neurali</category><guid>francescomecca.eu/blog/2016/11/10/machine-learning-intro/</guid><pubDate>Thu, 10 Nov 2016 00:00:00 GMT</pubDate></item></channel></rss> |