Come trovare lavoro in qualità di data scientist?

Autore: Favio Vázquez

Traduttrice: Sabrina Sala

 

 

1 1

Questo articolo è il frutto di 3 post che ho recentemente pubblicato in LinkedIn. Li potete trovare qui: parte 1parte 2, e parte 3.

Questa è una domanda che ricevo spesso dalle persone che conosco e da quelle appartenenti alla mia rete di LinkedIn.

Vi parlerò della mia esperienza. Sto lavorando come Data Scientist ormai da un po’ ma nello specifico vi racconterò come ho ottenuto il mio attuale lavoro a BBVA Data & Analytics.

L’anno scorso ho finito il master in fisica, specializzandomi in cosmologia e machine learning bayesiano. Poco prima di laurearmi, mi sono fermato a riflettere su ciò che avrei voluto fare e ho capito di essere attratto dal data science.

Ho mandato circa 125 candidature, ricevendo solo una trentina di risposte, di cui tante erano solo gentili “no, grazie”. Non ero assolutamente preparato ad una tale quantità di rifiuti. Quindi ho partecipato a 15 colloqui e ho tratto lezioni preziose da ognuno di essi; ho studiato tanto, programmato ogni giorno, letto innumerevoli articoli e post, ognuno dei quali mi ha aiutato a migliorare.

Arriviamo perciò alla fatidica domanda, come ho ottenuto questo lavoro?

 

 

2.jpg 1

Con tanta pazienza. Non è stato facile ma al settimo colloquio ho finalmente realizzato che:

  • Molte persone non avevano la minima idea di cosa fosse il data science.
  • Il selezionatore è il vostro migliore amico durante il tempo del colloquio, ciò che vuole è solo aiutarvi a mettervi a vostro agio. Quindi abbiate fiducia, lasciatevi aiutare e non abbiate timore a fare domande.
  • Le persone sono molto più interessate a come riuscite a risolvere un problema e a come vi rapportate alla diverse situazioni, piuttosto che alla vostra conoscenza tecnica.

All’epoca ero molto preparato a rispondere a qualsiasi domanda riguardante algoritmi, machine learning, Python, Spark, ecc. ma non ad altre che mettevano alla prova la mia capacità di problem solving.

All’ottavo colloquio ho tratto le fila di tutto ciò che avevo fatto come Data Scientist, come ingegnere informatico, come fisico, ma anche come persona. Ero ormai in grado di rispondere a qualsiasi domanda mi fosse posta: come gestire situazioni difficili o nuovi dati e informazioni, come spiegare concetti complessi a dirigenti e così via.

Ciò mi ha permesso di migliorare notevolmente e di parlare con calma e serenità. Sapevo ormai che i selezionatori volevano aiutarmi a entrare in azienda e che quello non era affatto un interrogatorio.

Quindi ecco alcuni personali consigli su come ottenere una posizione in qualità di Data Scientist:

  • Siate calmi. Dovrete probabilmente affrontare centinaio di colloqui prima di ottenere un lavoro.
  • Preparatevi, non solo studiando concetti e teoria, e ricordate che sarete un pezzo importante dell’azienda in cui entrerete a far parte e nella quale dovrete confrontarvi con molteplici persone e situazioni. Siate pronti a rispondere a domande sul vostro comportamento in possibili scenari lavorativi.
  • Create un portfolio con alcuni vostri progetti e con dati reali, che potete comodamente pubblicare su GitHub. A parte le competizioni Kaggle, trovate qualcosa che vi interessi, un problema da risolvere e applicatevi tutta la vostra conoscenza.
  • Il selezionatore è vostro amico, ha le migliori intenzioni e può darvi consigli preziosi.
  • Non abbiate paura di fare domande ad altre persone, chiedete di cosa si occupano e come vi sono arrivati. Personalmente, vi consiglio di leggere il post di Matthew Mayo “A day in the life of a Data Scientist” per avere un idea più precisa del lavoro che andrete a fare.
  • Se cercate uno stage, mettete in luce le vostre esperienze accademiche.

Vi auguro di avere tanto successo.

Seguitemi a: https://www.linkedin.com/in/faviovazquez/.

 

Paradigmi di apprendimento nel machine learning

Autore: Matteo Alberti

 

 

 

Tradizionalmente abbiamo tre tipi di apprendimento differenti nel machine learning:

  • Apprendimento Supervisionato
  • Apprendimento Non-Supervisionato
  • Apprendimento per Rinforzo

 

Apprendimento Supervisionato

L’apprendimento supervisionato ha come obiettivo quello di dedurre una data funzione dai dati di addestramento.

Tali dati consistono in una coppia costituita da un vettore di input ed un valore di output desiderato.

Si possono aver due differenti situazioni:

  • Classificazione: quando la variabile output desiderata è categorica (qualitativa nominali o ordinale)

Un tipico esempio in ambito di marketing può essere quello di classificare buoni/cattivi clienti mentre nell’ambito medico quello di predire da una radiografia la presenza o meno di una malattia dati i sintomi

  • Regressione: quando la variabile output desiderata è quantitativa

Tipico problema della statistica classica in cui dato un insieme di variabili vogliamo andar a prevedere il valore della nostra variabile oggetto dell’analisi

 

L’idea di base è quella di trovare un insieme di pesi che siano in grado di predire correttamente l’output desiderato dato qualsiasi valore di input dei dati, generalizzando da dati di apprendimento a situazioni differenti.

Dei tipici esempi di algormitmi per apprendimento supervisionato sono:

  • Regressione lineare, alberi decisionali, .. per problemi di regressione
  • Logistica, alberi decisionali, ANN per problemi di classificazioni

 

1 2

 

Apprendimento Non-Supervisionato

Nell’apprendimento non supervisionato abbiamo unicamente i dati di input senza alcun output desiderato. L’obiettivo è quello di modellizzare la sottostante distribuzione dei dati, andando per esempio a preservare la locale geometria del dato, riducendo il numero di dimensioni per condurre ulteriori analisi o riducendo alle due singole dimensioni riducendoci ai metodi grafici.

Gli algoritmi di apprendimento non supervisionato possono essere suddivisi in tre differenti situazioni:

  • Clustering: L’obiettivo è quello di scoprire raggruppamenti nei dati
  • Analisi delle associazioni: Vogliamo andare a scoprire le regole che meglio riescono a descrivere la maggior porzione di dati possibile
  • Quantile estimation

 

Esempi comuni di apprendimento non supervisionato sono:

  • Algoritmo delle k-medie
  • Algoritmi Apriori per problemi di analisi delle associazioni
  • Analisi delle componenti principali

 

2.jpg 4

 

Apprendimento Semi-Supervisionato

Nell’apprendimento semi-supervisionato solo una parte dell’informazione è presente, ci troviamo dunque in un caso al limite fra il supervisionato e non supervisionato.

Un esempio tipico può esser il riconoscimento di oggetti da immagini

 

 

Apprendimento per Rinforzo:

L’apprendimento per Rinforzo pone come obiettivo come classificare differenti situazioni al fine di intraprendere un’azione.

Il principale campo di applicazione consiste nell’applicazione alla robotica dove, il nostro agente è posizionato all’interno di un ambiente (environment) ed in ogni step possiamo ricevere una ricompensa data da un’azione positiva. Un esempio comune sono simulatori e bot nei videogiochi

 

3 1

3 1

Metodi Lineari per la Riduzione della Dimensionalità: Analisi delle Componenti Principali

Autore: Matteo Alberti

 

 

Fra le metodologie per la riduzione lineare della dimensionalità le PCA o Componenti Principali sono certamente fra gli strumenti principe dello Statistical Machine Learning.

Sebbene vi si concentri molto spesso su strumenti in grado di catturare la componente non lineare l’analisi delle componenti principali risulta esser la base di partenza per molte analisi (e come strumento di preprocessing) e la loro conoscenza diventa improrogabile nel caso in cui le condizioni sulla linearità risultano soddisfatte.

In questo tutorial andremo ad introdurre a livello matematico la formazione delle componenti principali in maniera chiara e coincisa, la loro implentazione in python ma soprattutto la loro interpretazione

 

“L’idea alla base è quella di trovar un sistema di riferimento tale che la varianza delle variabili rappresentate ne risulti massimizzata”

 

Ciò avviene dividendo la varianza totale in un numero uguale di variabili di partenza dove però sarà possibile ridurre il numero in base al contributo che ciascuna PC fornisce nella costruzione della nostra varianza totale.

Vogliamo ricordare che l’applicazione della Principal Component Analysis risulta utile quando le variabili di partenza non risultano esser indipendenti

Vediamo di introdurle con il corretto formalismo matematico:

 

Dato un insieme di p variabili quantitative  X1,X2, . . . , Xp (variabili centrate o standardizzate) vogliamo determinare un nuovo insieme di k variabili t.c  k≤p indicate con Ys (s=1,2,…k)  che godano delle seguenti proprietà:

 

Per costruzione le nostre PC sono incorrelate, a media nulla e che riproducano (in ordine crescente la maggior quota di varianza possibile.

Ne risulta che la combinazione lineare sarà:

Dobbiamo quindi trovare dei coefficienti v t.c soddisfino le nostre proprietà. Si tratta di un problema di massimo vincolato dove il primo vincolo è detto di Normalizzazione:

Il nostro sistema diventa cosi:

Dove la prima equazione risulta esser la nostra funzione obiettivo mentre la seconda il nostro primo vincolo.

E si risolve tramite il Metodo dei moltiplicatori di Lagrange:

Calcolo del gradiente di Le del suo annullamento ottenendone:

Ne risulta un sistema lineare omogeneo.

ammette infinite soluzioni (che rispettano il vincolo) abbassando il rango della matrice dei coefficienti del sistema:

che corrispondono a λs dette Autovalori di ∑.

Analogamente per la costruzione della seconda PCA (e cosi per tutte le altre) subentra al nostro sistema il Vincolo di Ortogonalità, dato dalla nostra richiesta che le PC siano incorrelate, esprimibile nel seguente modo:

Quindi impostando la lagrangiana in p+2 variabili otteniamo:

Da cui otteniamo il secondo autovalore Y2  dove ricordiamo vale la seguente proprietà:

Proprietà delle PC:

 

Ogni autovalore di ∑ ha un ruolo nella varianza della rispettiva PC

semidefinite positiva

Varianza Totale

Varianza Generalizzata

 

CRITERI DI SCELTA:

Per la scelta del numero k (con k<p) di PC da mantenere in analisi non esiste un criterio universalmente accettato e valido. Risulta di buona prassi dunque utilizzarli congiuntamente e tener sempre in riferimento le necessità dell’analisi.

Vogliamo esporre i principali:

(1)

                                                                                   

Misura assoluta                Normalizzazione varianza spiegata                  % cumulata

 

(2)

Screen-Plot

Vengono selezionate la prime k PC in base  alla riduzione della pendenza (anche detto criterio del gomito). In questo caso specifico le PC da mantenere in analisi sarebbero le prime due.

 

(3)

Criterio di Kaiser

Anche noto come il criterio dell’autovalore maggiore di 1 (valido unicamente per variabili standardizzate)

 

 

Andiamo a questo punto ad implementare le nostre PCA:

Importiamo i pacchetti necessari da scikit-learn

 

import numpy as np

from sklearn.decomposition import PCA

La classe presenta i seguenti attributi:

Sklearn.decomposition.PCA(n_components=None, copy=True, whiten=False, svd_solver=’auto’, tol=0.0, iterated_power=’auto’, random_state=None)

Andiamo a testarlo su nuovi dati reali, prediamo per esempio sui dati Wine importabili attraverso il comandoAndiamo a commentare i parametri principali:
• n_components= numero di component da tenere in analisi. Consigliamo in una fase di scelta di non settare questo valore e di valutare in base ai criteri sopra esposti
• svd_solver= ci mette a disposizione alcune fra le principali alternative (arpack, randomized..) vogliamo ricordare che PCA non supporta sparse data (per il quale occorrerà caricare TruncatedSVD)

from sklearn import datasets

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

from sklearn import decomposition

A questo punto andiamo ad implementare PCA ed a farne un plot

np.random.seed(123)
wine = datasets.load_wine()

X = wine.data

y = wine.target



fig = plt.figure(1, figsize=(5, 4))

plt.clf()

ax = Axes3D(fig, rect=[1, 0, 1, 0.9], elev=30, azim=222)



plt.cla()

pca = decomposition.PCA(n_components=None)

pca.fit(X)

X = pca.transform(X)





for name, label in [('Setosa', 0), ('Versicolour', 1), ('Virginica', 2)]:

ax.text3D(X[y == label, 0].mean(),

X[y == label, 1].mean() + 1.5,

X[y == label, 2].mean(), name,

bbox=dict(alpha=.5, edgecolor='b', facecolor='w'))

# Reorder the labels to have colors matching the cluster results

y = np.choose(y, [1, 2, 0]).astype(np.float)

ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=y, cmap=plt.cm.spectral,

edgecolor='r')



ax.w_xaxis.set_ticklabels([])

ax.w_yaxis.set_ticklabels([])

ax.w_zaxis.set_ticklabels([])



plt.show()

Questo sarà il grafico che andremo ad ottenere:

Metodi per la riduzione della dimensionalità basati sulla Varietà differenziabile: il caso ISOMAP

Autore: Matteo Alberti


 

In questo tutorial andiamo ad aprire una mini serie dedicata ai metodi di riduzione della dimensionalità basati su una struttura matematica chiamata Varietà differenziabile (Manifold)

Andiamo dunque a capire che cosa sia una Varietà differenziabile, quando risulta utile e come applicarlo senza però entrare nel dettaglio sulla struttura e sulle proprietà matematiche.

“Manifold non è altro che uno spazio matematico dove localmente viene a ricrearsi uno spazio euclideo (di una specifica dimensione) ma non a livello globale”

Quindi quando e come andremo ad applicare questa serie di metodi?

La risposta è semplice: Quando i metodi lineari falliscono

 

Andiamo ad indagare in maniera più approfondita:


 

Esempio:

Nei metodi lineari (come PCA, MDS, SVD) i nostri dati possono essere ridimensionati solo attraverso combinazioni lineari delle nostre features, ciò comporta che strutture più complesse e non lineari non vengono scovate e dunque discriminate.

Riportiamo un esempio grafico:

 

Metodi Lineari ci ridurrebbero i dati perdendo la struttura geometrica. Come mostra in figura i punti X1 ed X2 risulterebbero avvicinati (e cosi tutta la struttura risulterebbe “appiattita”)

Metodi basati sulla Varietà differenziabile contrariamente ci riescono. I principali sono:

  • ISOMAP
  • Local Linear Embedding (LLE)

 

Vogliamo ricordare che il nostro obiettivo è “preservare la geometria locale”


 

Questa idea di base ci permette di risolvere molti problemi non solo in fase di pre-processing (Nella computer Vision per esempio ci permette di risolvere problemi di: Stima della posizione, compressione dei dati, riduzione del rumore nell’immagine ed interpolazione di dati mancanti)

 

 

ISOMAP

Iniziamo dunque con il primo strumento:

L’algoritmo si compone di tre fasi:

  • Determinare il numero di vicini (neighbors) sul Manifold (basandola sulle distanze Euclidea)

Per ogni punto andremo a mappare i vicini (determinati in base al numero di vicini fissato come nell’algoritmo K-NN o in base ad un raggio fissato)

 

  • In questo step andremo a stimare la Geodetica. Andremo dunque a calcolare la distanza di ogni coppia di punti ma non lavorando in uno spazio Euclideo esso corrisponderà al percorso più breve fra tutti i possibili percorsi per collegare due punti nel manifold. Un esempio di comune utilizzo può esser l’algoritmo di Djkstra, molto comune nel calcolo di della navigazione stradale.
  • In questo ultimo step andremo ad applicare una MDS (multidimensional scaling) alla matrice di distanze della geodetica al fine di ricostruirlo in uno spazio Euclideo che manterrà la stessa struttura geometrica. I vettori di coordinate nello spazio euclideo sono scelti per minimizzare la seguente funzione di costo:


Dy corrisponde alla matrice di distanze Euclidee

L2 corrisponde alla radice quadrata della somma degli elementi

τ non è altro che una funzione di conversione (le distanze vengono sostituite in prodotti interni) al fine di utilizzare algoritmi di ottimizzazione efficienti.


 

 

Andiamo ad implementarlo in Python:

Prima di tutto importiamo i pacchetti necessari di scikit-learn

import numpy as np

import matplotlib.pyplot as plt

from sklearn import manifold

 

La nostra classe sarà cosi articolata:

DATA= manifold.Isomap(n_neighbors=N, n_components=C, eigen_solver=’auto’, tol=0, max_iter=None, path_method=’auto’, neighbors_algorithm=’auto’, n_jobs=1)

Andiamo ad analizzare i parametri principali:

  • n_ neighbors= Numero intero, corrisponde al numero di vicini
  • n_ components= Numero intero, generalmente impostato di default su 2. Corrisponde al numero di coordinate nello spazio del Manifold
  • path_ method= di default ’auto’, FW per Floyd-Warshall, D per l’algoritmo di Djkstra imposta in che modo calcolare le distanze nel grafo.

 

 

Se vogliamo andare a stampare un grafico con i relativi tempi di esecuzione:

 

 

from time import time

t0=time()

ISOMAP_DATA= manifold.Isomap(n_neighbors, n_components=2).fit_transform(OUR_DATA)

t1=time()

print("%s: %.2g sec" % ('ISO' t1-t0))

plot.embedding(ISOMAP_DATA, "ISOMAP ottenuto in " % (t1-t0)

plot.show()

Facciamo due ultime considerazioni di utilizzo pratico:

 

ISOMAP risulta esser uno strumento di riduzione molto efficace che ci permette di bypassare molti problemi legati alla linearità ma il poter preservare una struttura geometrica locale naturalmente è a discapito di alcuni fattori, in particolare:

  • Sensibile ad outliers
  • Pochi parametri liberi

Questo perché la funzionalità dell’algoritmo dipende principalmente dalla scelta di pochi parametri (la scelta del numero dei vicini) infatti anche solo pochi valori outliers possono in qualche modo avvicinare porzioni di dati che dovrebbero contrariamente venir discriminati.

Per questo motivo ISOMAP è altamente consigliato quando abbiamo già qualche idea sulla struttura dei dati anche perché rispetto ad altri metodi lineari risulta computazionalmente più intensivo.

 

Nel Prossimo tutorial andremo ad affrontare LLE, il secondo dei nostri metodi basati sul Manifold.

 

Riferimenti

http://scikit-learn.org/stable/index.html (Official Website of Scikit libraries)

http://web.mit.edu/cocosci/Papers/sci_reprint.pdf  (documentazione su ISOMAP)

Stochastic Neighbor Embedding (SNE) e la sua correzione in t-SNE

Autore: Matteo Alberti


 

 

Vogliamo affrontare un importante metodo di riduzione della dimensionalità:

Stochastic Neighbor Embedding; anche conosciuto come SNE.

Il punto di partenza:

Abbiamo un large dataset (con molti dati) e vogliamo trovare uno strumento in grado di ridurci la dimensionalità (sia come strumento di pre-processing, sia come strumento di classificazione o di visualizzazione) ma abbiamo un vincolo da rispettare:­

abbiamo oggetti ambigui?

La prima domanda risulta quindi essere:

Cosa intendiamo per ambiguo?

 

Esempio Stiamo facendo classificazione di documenti ed incorriamo nella seguente parola:

Calcio.

È nostro interesse che la parola calcio venga associata a parole come pallone, sport ma al tempo stesso anche a vocabili come sale minerale, potassio, salute.

I più comuni metodi di riduzione di dimensionalità come :

  • Multidimensional scaling (MDS)
  • PCA (Principal Component Analysis).
  • Metodi che preservano una geometria locale (Local Linear Embedding)

richiedono che ogni oggetto “high-dimensional “ sia associato ad una sola posizione in uno spazio con poche dimensioni (“low-dimensional space”).

 

Questo rende difficile spiegare mappature in cui un singolo oggetto appartiene a differenti posizioni in uno spazio a poche dimensioni.

SNE si pone questo obiettivo: mappare gli oggetti in spazi low-dimensional preservando la struttura dei vicini anche a costo di mal classificare oggetti distanti attraverso misure di entropia (quindi su “divergenze in probabilità”) piuttosto che misure di dissimilarità.

L’idea è quella di centrare una Gaussiana per ogni valore iniziale (ossia nello spazio a high-dimensional di origine) così da utilizzare le relative densità per definire una distribuzione di probabilità di tutti i potenziali vicini (neighbors). L’obiettivo risulta quindi esser di approssimare quanto più correttamente questa distribuzione di probabilità al fine di replicarla in uno spazio low-dimensional.

 

 

Introducendo l’adeguato formalismo matematico:

Sia X1….Xn ∈ RK vogliamo creare una mappa (𝛗) ∈ R2.

 

 

Costruiamo una Gaussiana in ogni punto, in questo modo stiamo associando ad ogni valore una probabilità.

Vogliamo che cio che vedo in

 R^k\{x_1, ... , x_k\} \frac{\varphi} {\to} \{Y_1, ..., Y_n\} \in R^2 \\ ... \\ R^k\{x_1, ... , x_k\} \leftrightarrow \{Q_1, ..., Q_n\} \in R^2

 

risulti esser quanto più possibile simile in R2.

 

Questo avviene quando {P1…Pk} e  {Q1…Qn} sono il più possibili simili.

Espresso con altri termini ciò significa  minimizzare la seguente funzione (che chiameremo funzione obiettivo di K-L)

C= \sum_{i=1}^k D(P_i||Q_i) = \sum_{i,j} P_{i|j}ln(\frac{P_{j|i}}{Q_{j|i}})

 

Piccola nota:


 Divergenza di Kullback-Leibler o di Cross-Entropia:

Abbiamo due distribuzioni di probabilità :

Pi… Pk  e Qi…Qk

Definiamo Divergenza di K-L:

Che gode delle seguenti proprietà:

1.      D(P||Q) ≥ 0

2.      D(P||Q) = 0                 ↔ Q=P

3.      D(P||Q) ≠ D(Q||P)      Non è simmetrica


 

Cosa significa ciò?

  •  All’aumentare di Pi il l’oggetto risulta essere vicino
  • Se Q viene reso grande al decrescere di P significa avvicinare due punti distanti in Rk. Ma ne risulta un errore trascurabile in quanto vengono pesate dalle Pj|i. In questo modo SNE tende, come definito nella fase di introduzione a preservare le strutture di vicinanze a discapito delle lontananze

 

Come cambia c mentre lo spostiamo nel piano? Lo studiamo attraverso le derivate parziali:

Da notare che la densità dei punti è data da σi dove il parametro mi dilata o restringe la gaussiana facendo sembrar i valori siano più distanti o più vicini.

 

Come assegnamo σ?

Definiamo un nuovo oggetto:

Perplessità: 2H(Pi)

Se la Perplessità risulta costante: ci permette di far variare l’intorno considerando la distanza dagl’altri punti facendo variare unicamente σ.

 

Problema: Con alta dimensionalità i valori lontani vengono accumulati in un “intorno a blocchi”. Questo slittamento è dovuto al nostro voler rappresentare adeguatamente la struttura dei vicini.

 

Risoluzione: La correzione t-SNE

Vogliamo dunque rimediare a questo concentramento di valori distanti mal classificati, per far ciò andremo ad agire sulla struttura della nostra Gaussiana. L’idea è in se molto semplice. Vogliamo alzare le code delle distribuzioni. Così facendo, i punti originariamente vicini (prossimi ad 1) verranno dilatati ma di un fattore che riterremo “trascurabile” in compenso i punti più lontani subiranno uno slittamento maggiore tanto è maggiore la loro distanza. La t che precede l’SNE corrisponde alla t-student

 

 

 

 

Implementiamolo con Python

Non dobbiamo far altro che richiamare dalle librerie Scikit:

from sklearn.manifold import TSNE

Dove TSNE presenta i seguenti parametri (obbligatori ed opzionali) di cui esamineremo i più rilevanti:

TSNE(n_components=2, perplexity=30.0, early_exaggeration=12.0, learning_rate=200.0, n_iter=1000, n_iter_without_progress=300, min_grad_norm=1e-07, metric=’euclidean’, init=’random’, verbose=0, random_state=None, method=’barnes_hut’, angle=0.5)

  • n_components: di default settato a 2, rappresenta il numero di dimensioni finali

 

  • perplexity: è il parametro principale del nostro metodo; più è grande maggiore sarà il numero di vicini che prendermo in esame. È buona norma utilizzare dei parametri fra 5 e 50 per testare.

Attenzione!

 

Una perplessità troppo piccola rischia di non catturare sufficienti vicini, contrariamente un intorno eccessivo fa avvicinare valori che in realtà sono distanti, Si consiglia con large dataset di aumentare il parametro perplessità.

 

 

  • learning_rate: (dovrebbe variare da 10 a 1000) per settare correttamente questo parametro bisogna tener conto dei casi estremi:

Se i dati si concentrano in una forma quasi equidistante significa che è stato impostato un valore eccessivamente grande e bisogna ridurlo.

Contrariamente al verificarsi di un forte concentramento dei dati con qualche outliers è buona norma aumentare il grado di learning rate.

 

 

Applichiamolo su dati reali:

Dataset MNIST, costituito da oltre 60.000 immagini di numeri scritti a mano

Importiamo i pacchetti ed i dati necessari

%pylab inline
from sklearn.datasets import fetch_mldata
from sklearn.decomposition import PCA

# Load MNIST dataset
mnist = fetch_mldata("MNIST original")
X, y = mnist.data / 255.0, mnist.target

A questo punto facciamo una prima riduzione di dimensionalità con la PCA (utile quando vi sono molti dati addensati, contrariamente SVD con dati sparsi)

indices = arange(X.shape[0])
random.shuffle(indices)
n_train_samples = 5000
X_pca = PCA(n_components=50).fit_transform(X)
X_train = X_pca[indices[:n_train_samples]]
y_train = y[indices[:n_train_samples]]

Facciamo dunque partire il nostro t-SNE impostando come livello di perplessità un 40, dopo vari tentativi

X_train_embedded = TSNE(n_components=2, perplexity=40, verbose=2).fit_transform(X_train)

Vogliamo a questo punto plottare i nostri dati cosi ottenuti

matplotlib.rc('font', **{'family' : 'sans-serif',
                         'weight' : 'bold',
                         'size'   : 18})
matplotlib.rc('text', **{'usetex' : True})

def plot_mnist(X, y, X_embedded, name, min_dist=10.0):
    fig = figure(figsize=(10, 10))
    ax = axes(frameon=False)
    title("\\textbf{MNIST dataset} -- Two-dimensional "
          "embedding of 70,000 handwritten digits with %s" % name)
    setp(ax, xticks=(), yticks=())
    subplots_adjust(left=0.0, bottom=0.0, right=1.0, top=0.9,
                    wspace=0.0, hspace=0.0)
    scatter(X_embedded[:, 0], X_embedded[:, 1],
            c=y, marker="x")

    if min_dist is not None:
        from matplotlib import offsetbox
        shown_images = np.array([[15., 15.]])
        indices = arange(X_embedded.shape[0])
        random.shuffle(indices)
        for i in indices[:5000]:
            dist = np.sum((X_embedded[i] - shown_images) ** 2, 1)
            if np.min(dist) &amp;amp;amp;amp;lt; min_dist:
                continue
            shown_images = np.r_[shown_images, [X_embedded[i]]]
            imagebox = offsetbox.AnnotationBbox(
                offsetbox.OffsetImage(X[i].reshape(28, 28),
                                      cmap=cm.gray_r), X_embedded[i])
            ax.add_artist(imagebox)
plot_mnist(X[indices[:n_train_samples]], y_train, X_train_embedded,"t-SNE", min_dist=20.0)

Il risultato che otteremo sarà il seguente:

t-SNE ottenuto in 17.51s

 

Confrontandolo con altri strumenti di Riduzione di dimensionalità è possibile constatare due grosse tematiche:

 

  1. l’effettiva capacità discriminante

Naturalmente settare correttamente questa serie di parametri non è sempre facile.

Per questo motivo vogliamo riportare un link dove si può “giocare” a modificar i principali parametri visualizzando in tempo reale la disposizione del dato (tenendo a mente che i dati sono simulati e quindi conosciuti a priori)

https://distill.pub/2016/misread-tsne/

 

 

  1. I tempi di esecuzione

Contrariamente ad altri metodi t-SNE assorbe un quantitativo di tempo e risorse maggiore. Occorre valutare quindi quale se nelle analisi in gioco il fattore tempo risulti una variabile significativa.

Vogliamo comunque dar degli spunti per superare in parte questo problema proponendo due articoli provenienti dai dipartimenti di Computer Science dell’università della California

 

Fast Optimization for t-SNE, Laurens van der Maaten (University of california)

http://cseweb.ucsd.edu/~lvdmaaten/workshops/nips2010/papers/vandermaaten.pdf

Accelerating t-SNE using Tree-Based Algorithms, Laurens van der Maaten (University of california)

http://lvdmaaten.github.io/publications/papers/JMLR_2014.pdf

 

 

 

Riferimenti

Una panoramica introduttiva su Deep Learning e Machine Learning

Autori: Francesco Pugliese & Matteo Testi

 

Negli ultimi anni, è emersa una nuova parola alla moda nel campo dell’ Intelligenza Artificiale: Deep Learning”. Di recente, c’è un grande interesse in questo tipo di ricerche, in special modo tra tutte quelle aziende che attuano una vera e propria “caccia al tesoro” al fine di trovare esperti che spaziano dal Machine Learning fino al Deep Learning. I ruoli associati a queste due aree vengono sempre più spesso associati alla figura del cosiddetto “Data Scientist” (Scienziato dei Dati).

Possiamo per esempio dare un rapido sguardo all’andamento dello sviluppo della parola “Deep Learning” su Google Trends, nell’intervallo di tempo che va dal 2011  al 2017.

 

Da quando il celebre software di DeepMind “Alpha-Go” ha sconfitto il campione Sud-Coreano Master Lee Se-dol nel noto gioco da tavolo Go all’inizio dello scorso anno, il termine “Intelligenza Artificiale” (IA) ha acquisito una popolarità esponenziale. Il modo in cui il Motore di Deep Learning di Alpha-GO funziona è basato sulla combinazione di un algoritmo tradizionale di Visita e Ricerca in una struttura ad Albero chiamato “Monte-Carlo Tree Search” (MTS) con le “profonde” reti neurali conosciute come “Reti Neurali Convolutive” (CNN). Fino ad allora, MTS era lo standard de-facto-standard nella costruzione dello stato dell’arte dei programmi in grado di giocare al gioco del Go. Tuttavia, le funzioni di valutazione su metodi euristici disegnati “a mano”. La novità introdotta da Deep Mind era che la funzione di valutazione veniva “dedotta” automaticamente delle CNN a addestrate in una prima fase a partire da un insieme d’addestramento Supervisionato fatto di milioni di mosse note. Successivamente, un Sistema di “Policy Gradients Deterministico” basato cioè su un modello di apprendimento per Rinforzo tipo “Attore-Critico” fu messo davanti al compito di giocare contro differenti versioni di se stesso per molto tempo. Il risultato è stato un “giocatore” di GO artificiale, ancora imbattuto. DeepMind ha descritto dettagliatamente tutto il sistema Alpha-GO nel noto articolo scientifico apparso su Nature e intitolato “Mastering the game of Go with deep neural networks and tree search”.

 

 

Il seguente diagramma illustra le differenze tra Intelligenza Artificiale, Machine Learning e Deep Learning.

 

Machine Learning

Machine Learning (ML) è essenzialmente una forma di statistica applicata mirata ad utilizzare i computer per stimare statisticamente una funzione complessa. Mitchell nel 1997 fornì la seguente definizione di Machine Learning: “Un algoritmo apprende dall’esperienza E riguardanti una classe di problemi T con una misura pari a P, se la sua performance sui problemi T, misurata tramite P, aumenta con l’esperienza E”. In sostanza, il ML è un insieme di tecniche che permettono alla macchine di “imparare” dai dati e in seguito prendere decisioni o fare una predizione su di essi. Un sistema di Machine Learning può essere applicato ad una base di “Conoscenza” proveniente da sorgenti multiple per risolvere diversi compiti: classificazione facciale, riconoscimento del parlato, riconoscimento di oggetti, ecc. A differenza degli algoritmi euristici, ossia quegli algoritmi che seguono un insieme specifico di istruzioni per risolvere un dato problema, il Machine Learning abilita un computer ad apprendere come riconoscere “configurazioni percettive” da solo e fare predizioni su di esse.

 

 

 

Il Machine Learning può essere adattato a tre differenti tipi di compiti:

  • Classificazione
  •  Clustering
  • Predizione

Una delle applicazioni più popolari di Machine Learning è stata la Computer Vision One, per molti anni. La maggior parte degli algoritmi di Machine Learning possono essere divisi nelle due categorie di Apprendimento Supervisionato e Apprendimento Non Supervisionato a seconda del fatto che l’insieme di addestramento sia supervisionato (ossia con un informazione di target associata dall’addestratore, detta etichetta o label) o non supervisionato.

Nell’ Apprendimento Supervisionato, le etichette sono create dall’addestratore per rendere la macchina capace di scoprire relazioni tra input ed etichette.

 

 

Nell’ Apprendimento Non Supervisionato invece, le etichette non sono disponibili. In questa situazione, stiamo chiedendo alla macchina di trovare dei gruppi o “cluster” all’interno dei dati.

 

 

Tipici algoritmi di Machine learning sono: Random Forest, Regressione Lineare / Logistica, Alberi di Decisione, Support Vector Machines, PCA, K means, ICA, Naive Bayes, ecc.

Deep learning

Il Deep Learning è una sotto-area del Machine Learning che fa uso delle “Reti Neurali Profonde” (Deep Neural Network), ossia dotate di molti strati e di nuovi algoritmi per il pre-processamento dei dati per la regolarizzazione del modello: word embeddings, dropout, data-augmentation, ecc. Il Deep Learning trae istpirazione dalle Neuroscienze dal momento che le Reti Neurali sono un modello dell’attività neuronale del cervello. A differenza del cervello biologico, dove qualsiasi neurone può connettersi a qualsiasi altro neurone sotto alcuni vincoli fisici, le Reti Neurali Artificiali (ANN) hanno un numero finito di strati e connessioni, e infine hanno una direzione prestabilita della propagazione dell’informazione. Finora, le Reti Neurali Artificiali sono state ignorate sia dalla comunità della ricerca che dall’industria  I principale problema il loro costo computazionale.

Tuttavia, tra il 2006 e il 2012, il gruppo di ricerca guidato da Geoffrey Hinton dell’Università di Toronto è stato in grado finalmente di parallelizzare gli algoritmi per le ANN su architetture parallele. Il principale risultato è stato un notevole incremento del numero di strati, neuroni e parametri del modello in generale (anche oltre i 10 milioni di parametri) permettendo alle macchine di computare una quantità massiccia di dati addestrandosi su di essi.

 

 

Pertanto, il primo requisito per l’addestramento di un modello di Deep learning è avere a disposizione train-set molto grandi. Questo rende il Deep Learning molto adatto ad affrontare l’era dei Big Data.

 

 

Le ragioni sottostanti la popolarità del Deep Learning sono l’avvento dei Big Data e delle GPU (Graphic Processing Unit ). Adottando una quantità massiccia di dati, la rete “apprende”, attraverso l’algoritmo di addestramento, come raggiungere obiettivi.

 

 

Un algoritmo di Deep Learning potrebbe essere, ad esempio, un classifcatore per “apprendere” cosa sono i cani. Questo algoritmo dovrebbe pertanto essere sottomesso ad un massiccio quantitativo di dati delle immagini di cani per comprendere le “caratteristiche” (feature) che identificano un cane lo distinguono da un lupo. Dovremmo tenere bene in mente che il Deep Learning è molto sensibile ai cosiddetti “bias”. Per esempio, in un modello supervisionato, se le etichette sono create erroneamente, il modello apprenderà dai dati errati.

Quando il sistema di riconoscimento facciale di Google fu avviato, esso etichettà alcune facce di uomini africani come gorilla.

“Questo è un classico esempio di che cosa accade se non ha un numero sufficiente di facce di africani americani nel tuo insieme di addestramento”

Sostiene Anu Tewary, chief data officer presso Mint at Intuit.

Deep Learning per il Business

Deep learning ha influenzatto le applicazioni industriali come mai era successo prima al Machine Learning. Infatti esso è in grado di trattare un enorme quantità di dati – milioni di immagini, per esempio – e riconoscere alcune caratteristiche discriminative. Le ricerche basate su testo, l’individuazione di frodi o spam,  il riconoscimento delle scritte, la ricerca delle immagini, il riconoscimento del parlato, i recommendation system, la Street View detection e la traduzione di lingue, sono solo alcuni dei compiti che il Deep Learning è in grado di affrontare. In Google, le reti deep hanno già rimpiazzato decine di “sistemi a regole”. Oggi il Deep Learning per la Computer Vision già mostra di avere capacità super-umane, e che variano dal riconoscimento di figure comuni come cani e gatti fino all’individuazione di noduli cancerosi in immagini tomografiche polmonari.

Conclusioni

La teoria del Machine Learning sostiene che questi algoritmi di possono generalizzare molto bene a partire da un numero finito di esempi di addestramento. Questo tuttavia contraddice le basi della logica: derivare regole generali da un insieme limitato di esempi non è un’affermazione logicamente valida. In altre parole, per inferire una regola che descriva ogni membro di un insieme, dovremmo avere informazioni circa ogni membro dell’insieme. In parte, il ML affronta questo problema con regole probabilistiche piuttosto che alcune regole di ragionamento logico. Purtroppo, ciò non risolve il problema completamente. Infatti secondo il Teorema “No Free Lunch” (David Wolpert and William Macready, 1997): mediando su tutte le possibili distribuzioni generanti i dati, ogni algoritmo di classificazione possibile mostra lo stesso tasso d’errore sui dati non osservati, ossia presenta lo stesso errore di generalizzazione (sull’insieme di test). Questo significa che non può esistere il miglior algoritmo di Machine Learning: pertanto il nostro obiettivo deve essere comprendere che tipi di distribuzioni sono rilevanti per il “mondo reale” e che tipo di algoritmi di ML presentano migliori prestazioni rispetto ad altri una volta che lavorano sui dati estratti dalle distribuzioni su cui noi ci stiamo focalizzando.In soldoni, anche il Deep Learning (che è una parte del Machine Learning) non può avere prestazioni universalmente migliori del Machine Learning, ma tutto dipende dal dominio del task che vogliamo affrontare. Anche se sembra che, nel futuro prossimo, il Deep Learning risolverà molti dei problemi che ogni giorno abbiamo nel dominio dei computer, business, IA, marketing, ecc.

Come dice Andrew Yan-Tak Ng, scienziato capo presso Baidu, dove dirige il Team di Intelligenza Artificiale:

“L’IA è la nuova elettricità”.

Noi ci permettiamo che il Deep Learning è la nuova lampadina.

Approfondiremo il Deep Learning nei prossimi tutorials, restate sintonizzati…

 

Bibliografia

Silver, D., Huang, A., Maddison, C. J., Guez, A., Sifre, L., Van Den Driessche, G., … & Dieleman, S. (2016). Mastering the game of Go with deep neural networks and tree search. Nature529(7587), 484-489.

https://www.geospatialworld.net/blogs/difference-between-ai%EF%BB%BF-machine-learning-and-deep-learning/

http://www.machinedesign.com/industrial-automation/what-s-difference-between-ai-and-machine-learning

https://www.kairos.com/blog/the-best-explanation-machine-learning-vs-deep-learning

http://www.kdnuggets.com/2016/12/deep-learning-radically-different-machine-learning.html

http://www.techrepublic.com/article/understanding-the-differences-between-ai-machine-learning-and-deep-learning/

https://www.analyticsvidhya.com/blog/2017/04/comparison-between-deep-learning-machine-learning/

https://www.quora.com/What-is-the-difference-between-deep-learning-and-usual-machine-learning

https://blogs.nvidia.com/blog/2016/07/29/whats-difference-artificial-intelligence-machine-learning-deep-learning-ai/

https://deepmind.com/research/alphago/

https://mapr.com/blog/apache-spark-machine-learning-tutorial/