Introduzione ai Metodi di riduzione della Dimensionalità ed elementi di Algebra lineare: Parte 1

Autore: Matteo Alberti

 

 

  1. Metodi lineari per la riduzione: Parte 1
    1. Identificazione attraverso l’individuazione di sottospazi
    2. Approssimazioni Matriciali per la riduzione
    3. Casi di applicazione base: Decomposizione in Valori Singolari (SVD)
  2. Norme Matriciali: Parte 2
    1. Norme vettoriali
    2. Norme indotte
    3. Norme di Schatten
    4. Norma di Frobenius
  3. Casi di applicazione base: Analisi dei Cluster
    1. Definizione di metrica
    2. Distanze di Minkowski (Manhattan, Euclidea, Lagrange)

 

Lo scopo di questo primo tutorial è di introdurre le nozioni base di riduzione della dimensionalità dal punto di vista matematico (spazi, sottospazi, mappe lineari) e di riprendere gli elementi necessari di algebra lineare (norme, isometria, isomorfismo…) per ogni algoritmo di machine learning.

Metodi lineari per la riduzione:

Andiamo dunque ad introdurre con termini generali la logica dei processi di riduzione lineare della dimensionalità andando in prima fase ad identificare sottospazi “ottimali”

Identificazione attraverso l’individuazione di sottospazi

Abbiamo un insieme di vettori k-dimensionali \( x_1,… ,x_n \) (n unità statistiche su k covariate) dove vogliamo individuare un sottospazio p-dimensionale \(V_p\) in \( R^k \) ed una mappa lineare \( φ(·) \) da \( R^k \) a \( V_p \) tale per cui le relative immagini \( φ(x_i) \) approssimino in maniera sufficiente i nostri vettori k-dimensionali di input (in riferimento a qualche metrica che andremo a definire)
Riscriviamo come:

\( φ∶ R^k→V_p \)
\(∶ x_i→ φ(x_i ) \)

 

Elementi di algebra:

Spazio vettoriale
Si definisce spazio vettoriale su R un insieme V, i cui elementi sono detti vettori con le seguenti proprietà:
Esiste in V un’operazione definita Addizione vettoriale che associa ad ogni \( x,y ∈V \) il vettore \( x+y ∈V \)

  • Addizione vettoriale è commutativa, associativa
  • Esiste in V un vettore, indicato con 0 e definito origine
  • Ogni vettore \( x ∈V \) ha un suo opposto, indicato con \( –x t.c. x + (-x) =0 \)

Esiste in V un’operazione definita moltiplicazione per gli scalari che associa ad ogni \( x ∈V \) ed ad ogni \( α ∈V \) il vettore \( αx∈V \) in modo che:

  • Moltiplicazione fra scalari è associativa
  • 1x=x,∀x ∈V

Inoltre vale anche:

  • Moltiplicazione scalare è distributiva rispetto all’addizione vettoriale

Sottospazio vettoriale
Si definisce S un insieme non vuoto dello sottospazio di V se per ogni \( x-x=0 ∈S \) ed ogni loro combinazione lineare \( αx+ βy ∈S \)

 

Nucleo ed immagine
Siano V e W due spazi vettoriali e sia L∶ V → W un’applicazione lineare.
Si dice nucleo di L l’insieme dei vettori di V la cui immagine è il vettore nullo di W.
Tale insieme si indica con ker L.
\( ker(L) = {v ∈ V | L(v) = 0 }. \)
Si dice immagine di L l’insieme dei vettori di W che sono immagini di qualche vettore appartenente al dominio V, cioè:
\( Im(L) = {w ∈ W | w = L(v), v ∈ V } \)

Mappa Lineare
Una mappa (o applicazione) lineare\(  f∶ V -> W \) fra spazi vettoriali reali è una funzione per cui valgano le proprietà:
\( f( u ⃗ + v ⃗ ) = f( u ⃗) + f( v ⃗ ) \)
\( f(λ · u ⃗) = λ · f( u ⃗) \)

per ogni \( u ⃗,v ⃗ ∈ V \) e \(λ ∈ R \)
Andiamo a definire solo i casi di principale rilevanza:
Sia \(f∶ V -> W \) una mappa lineare. Allora f è detta:
• un monomorfismo se è iniettiva
• un epimorfismo se è suriettiva
• un isomorfismo se è biiettiva (iniettiva + suriettiva)
• un endomorfismo se V = W
• un automorfismo se V = W ed è biettiva.
• di rango r se \( r = dim f(V) \)

Supponiamo a questo punto di aver individuato un sottospazio (specificato successivamente) \( V_p \) che risulti sufficientemente “approssimante” e sia \( b_1,…,b_p \) una base di \( V_p \) (Nota: la base è formata da vettori k-dimensionali in quanto \( V_p \) è sottospazio di \( R^k \))
La mappa lineare \( φ(∙) \) associa all’input x_i l’elemento \( φ(x_i) \) di \( V_p \), avente le seguente forma:
\(φ(x_i )= ∑_(j=1)^p▒〖α_ij b_j 〗\)
\( α_ij \) scelti opportunatamente.
L’errore di approssimazione da \(  R^k→V_p \) quindi da \( x_1..x_n \) a \( φ(x_1 )..φ(x_n) \) consisterà nell’opportuna norma vettoriale:
\(Errore= ∑_(i=1)^n▒‖x_i- φ(x_i) ‖ \)

Fissata la nostra base \( b_1,…,b_p \) i nostri vettori \( φ(x_i) \) possono essere trovati direttamente dalle coordinate \( α_ij \)
Data la mappa \( φ(∙) \) che associa al generico vettore \( φ(x_i) \) il suo vettore di coordinate \( α_ij \) e componiamo con la mappa \( φ(∙) \) otteniamo una mappa che associa ai vettori di input le coordinate delle loro immagini in \( V_p: ϑ(∙)=(φ∘φ)(∙) \)

\( ϑ∶R^k→R^p \)
\( ∶x_i→ ϑ(x_i )= α_ij \)

Attraverso la nostra mappa i vettori k-dimensionali di input vengono rappresentati in vettori di p-dimensionali ossia come elementi di \( R^p. \)
A questo punto risulta immediato che si può procedere con ulteriori analisi in \( R^p. \)

Andiamo dunque ad indagare in che modo questa riduzione della dimensionalità va a mantenere ed a perdere in particolare:
Da \( R^k→V_p \)
Da \( V_p→R^p \)

\( R^k→V_p \)
Naturalmente passare da k a p dimensioni con p Ciò comporta che tutte le norme, prodotti scalari e distanze non vengono preservate

Esempio:
\( V_p \) sottospazio dimensionale
\( V_p^⊥ \) complemento ortogonale di \( R^k \)
Ogni vettore \( x ∈R^k \) può esser decomposto in una somma di vettori (\( x ∈V_p \) e di un vettore \( x ∈ V_p^⊥ \))
In generale, presi i due vettori u,v ∈R^k abbiamo:
\( 〈u,v〉= 〈u ̂+ u ̂^⊥,v ̂+ v^⊥ 〉≠ 〈u ̂ ,v ̂ 〉 \)
Come si può constatare il prodotto scalare non è conservato.

 

Elementi di algebra:
complemento ortogonale
Sia \( S ⊆V \) un sottospazio di V, definiamo complemento ortogonale di D in V indicandolo con \( S^⊥ \) il sottoinsieme di V definito da:
\( S^⊥ ∶={v ∈V t.c v ∙s=0 ∀s∈S} \)
Ossia un sottoinsieme di tutti i vettori di V ortogonali a tutti i vettori di S

\( V_p→R^p \)

La mappa lineare \( φ(·)  \) è un isomorfismo gli spazi vettoriali \( V_p \) e \( R^p \), ciò comporta che non vi sarà alcuna perdita di informazioni .
Volendo chiarire ulteriormente questo concetto:
consideriamo il prodotto euclideo e supponiamo che la base \( b_1…b_p \) sia ortonormale e siano h,w due vettori di \( V_p \) con i relativi vettori di coordinate: \( a^h={a_i^h} \) e \( a^w={a_i^w} \) allora risulta vera la seguente condizione:
\( 〈u,v〉= ∑_(i,j=1)^p▒〖a_i^h a_j^w 〈b_i,b_j 〉 〗= \) \(  ∑_(i=1)^p▒〖a_i^h a_i^w=〈a^h,a^w 〉 〗\)
Significa che il prodotto scalare tra h,w è identico al prodotto scalare dei rispettivi vettori di coordinate iniziali (giusto specificare che i due prodotti scalari sono definiti in spazi differenti sebbene siano stati scritti allo stesso modo)
Se la base non fosse ortonormale i fattori \( 〈b_i,b_j 〉 \) non si ridurrebbero a 0.
Nel primo caso il prodotto scalare fra i vettori di coordinate è dato da: \( [a^h ]^T I a^w \) mentre nel secondo caso sarebbe data da \( [a^h ]^T G a^w \), con G matrice di Gram ne consegue quindi che matrici costruite nel secondo modo ed associate a basi differenti sono fra loro diverse (dovendo riadattare il calcolo dei prodotti scalari, norme, distanze indotte …)

 

Elementi di algebra:
ortonormale:
Una base si definisce ortonormale quando è composta da vettori di norma unitaria e fra loro ortogonali

Approssimazioni Matriciali per la riduzione

Vogliamo dare una seconda visione sulla riduzione alla dimensionalità basata sull’approssimazione matriciale (ciò che verrà utilizzata in pratica in ogni linguaggio di programmazione)
Data:
Matrice \( A_nxp \) di rango p che abbia per righe i vettori di coordinate a_i con i=1…n
Matrice \( B_pxk \) di rango p con i vettori di coordinate \( b_i \) con i=1…p
Matrice \( θ_nxk \) di rango p con i vettori di coordinate \( φ(x_i ) \) con i=1…n
Matrice X matrice di rango k che ha come righe i vettori \( x_i  \) con i=1..n

Allora possiamo riscriverlo come:
\( X ≈ θ=A ∙B \)

Le righe di θ sono date dalle combinazioni lineari delle righe di B ossia dalla nostra base, con i coefficienti dati dalle righe di A, le coordinate sulla base scelta.
Il nostro problema di riduzione della dimensionalità corrisponde quindi ad individuare un sottospazio vettoriale di dimensione p (p<k) la nostra base scelta (B) e delle relative coordinate date dalla matrice A.

Nell’analisi dei dati, dove il nostro punto di partenza è la matrice dei dati, le diverse tecniche di riduzione si differenziano in base al tipo di approssimazione, decomposizione e scelta fra le tante basi possibili.

Casi di applicazione base: Decomposizione in Valori Singolari (SVD)

Andiamo ad implementare in Python una semplice decomposizione in valori singolari (SVD) ossia andiamo a suddividere la nostra matrice X di partenza nelle due matrici A e B viste in precedenza:

 

import numpy as np
X = np.array([3,2,4],[3,6,7],[2,1,4])
autoval, autovett = np.linalg.eig(X)

Spark e Machine Learning (MLlib)

Autore: Antonio Berti

In questo tutorial verrà illustrato l’uso della libreria di Apache Foundation per il Machine Learning chiamata MLlib.

MLib fa parte delle API di Spark ed è interoperabile con NumPy di Python oltre che con le librerie di R. Implementato con Spark è possibile utilizzare ogni tipo di origine dati della piattaforma Hadoop come per esempio HDFS, HBase,  fonti dati provenienti da database relazionali o sorgenti dati locali come documenti di testo.

Spark eccelle nella computazione iterativa consentendo ai processi scritti con le librerie di MLlib di essere eseguite molto velocemente consentendone l’utilizzo anche e soprattutto a livello industriale.

MLlib fornisce molti tipi di algoritmi oltre che numerose funzioni di utilità. ML include algoritmi di classificazione, regressione, alberi decisionali, algoritmi di raccomandazione, clustering. Fra le utilità più utilizzate si possono annoverare le trasformazioni delle caratteristiche, standardizzazione e normalizzazione, funzioni statistiche e di algebra lineare.

Nel codice seguente verrà illustrato come implementare un semplice modello di regressione logistica con MLlb.

 

Innanzitutto viene caricato il dataset.

val data =MLUtils.loadLibSVMFile(sc, "data/mllib/sample_libsvm_data.txt")

Il dataset viene diviso in una parte utilizzata per addestrare il modello (60%) e in un’altra per il test (40%).

val splits = data.randomSplit(Array(0.6, 0.4), seed=11L)

val training = splits(0).cache()

val test = splits(1)

Si addestra l’algoritmo e si costruisce il modello.

val model = new LogisticRegressionWithLBFGS()

   .setNumClasses(10)

   .run(training)

Si esegue il modello sul dataset di test.

val predictionAndLabels = test.map {case LabeledPoint(label, features) =>

 val prediction = model.predict(features)

  (prediction, label)}

In questo modo si ottiene la metrica del modello e l’accuratezza della previsione.

val metrics = new MulticlassMetrics(predictionAndLabels)

val accuracy = metrics.accuracy

println("Accuracy = $accuracy")

E’ possibile salvare il modello appena addestrato e ricaricarlo nuovamente in memoria per un ulteriore uso.

model.save(sc, "target/tmp/scalaLogisticRegressionWithLBFGSModel")

val sameModel = LogisticRegressionModel.load(sc,

               "target/tmp/scalaLogisticRegressionWithLBFGSModel")

Riferimenti:

documentazine spark – http://spark.apache.org

documentazione mllib – http://spark.apache.org/docs/latest/ml-guide.html

codice d’esempio – https://github.com/apache/spark/tree/master/examples/src/main/scala/org/apache/spark/examples

dataset d’esempio mllib – https://github.com/apache/spark/tree/master/data/mllib

 

Incrustación estocástica de vecinos (SNE) y su corrección en t-SNE

Autor: Matteo Alberti

Traducido per Carlos Alfaro


 

 

 

Incrustación estocástica de vecinos (SNE) y su corrección en t-SNE

 

En este tutorial nos disponemos a enfrentar el problema de reducción de la dimensionalidad, con una herramienta significativa:

 

Stochastic Neighbor Embedding o “SNE”, como es normalmente conocido.

 

La definición del problema es:

 

“Tenemos un gran conjunto de datos y queremos encontrar una forma de reducir su dimensionalidad, tanto para el pre-procesamiento como para la clasificación/visualización”.

 

Podrían existir elementos ambiguos. Por lo tanto, la primera pregunta que nos planteamos es: ¿Qué queremos decir con ambigüedad?

 

Ejemplo: Estamos tratando con un problema de clasificación de texto y abordamos la siguiente palabra: bank.

 

Nos concentramos en asociar esta palabra a otras como ‘finance’ o ‘money’ pero podría estar relacionada con ‘river’ (riverbank/orilla del río) al mismo tiempo.

 

Dentro de las herramientas más populares para la reducción de la dimensionalidad, se encuentran:

 

* Multidimensional scaling (MDS).

* PCA (Principal Component Analysis).

* Local Geometry preserved tools (Local Linear Embedding).

 

 

Dado que, cada objeto de un espacio de alta dimensionalidad puede ser asociado con un solo objeto dentro de un espacio de baja dimensionalidad. El SNE trata de mapear objetos de alta dimesionalidad en objetos de poca dimensionalidad, preservando la estructura de parentesco de la vecindad, sin importar el intercambio que resulta de una clasificación incorrecta alrededor de objetos lejanos. El SNE no tiene nada que ver con las medidas de disimilaridad pero está basado en dos conceptos: Entropy y Probability Divergences.

 

La idea principal es centrar una distribución gaussiana para cada valor de entrada (a lo largo del espacio de alta dimensionalidad) a fin de usar su densidad para definir una distribución de probabilidad de todos los vecinos. El objetivo es aproximar esta distribución de probabilidad tanto como sea posible replicando la estructura de parentesco en un espacio de baja dimensionalidad.

 

 

Presentando el formalismo matemático apropiado:

 

Dado X1,…, Xn E R^K, intentamos construir una función (phi) E R^2.

Vamos a centrar una distribución gaussiana para cada valor y asociarle una probabilidad.

 

De esta manera, se espera tener un vistazo en lo que ocurre durante la transición de R^k a R^2:

Esta relación ocurre cada que {P1,…, Pk} y {Q1,…, Qn} son lo más similares posible. Con esto, nuestra función objetivo (K-L) es minimizar:


Nota explicativa:

Kullback-Leibler Divergence o Cross-Entropy:

Dado dos funciones de probabilidad:

Pi,…, Pk y Qi,…,Qk definimos la entropía cruzada, como:

Con las siguientes propiedades:

  1.     D(P||Q) ≥ 0
  2.     D(P||Q) = 0                 ↔ Q=P
  3.     D(P||Q) ≠ D(Q||P)      No simétrica

¿Qué significa esto?

 

  •  Si Pi incrementa, el objeto está más próximo.
  •  Si Qi aumenta mientras Pi disminuye, estamos aproximando dos objetos lejanos en R^k (lo cual no es bueno). Pero es un error despreciable porque nuestro Qi-ésimo elemento está ponderado por Pj|i. De esta forma el SNE preserva la estructura del vecino local sin importar la estructura global.

 

¿Cómo cambia C, mientras nos movemos a lo largo del espacio? ¿Cómo nos podemos mover?

Esto se puede realizar, al estudiar las derivadas parciales:

 

Primero, recordemos que la densidad de los puntos está dada por ‘sigma’ (Gaussian dilation y Smoothing parameter). Esto define si nuestros valores buscan más lejos o más cerca dentro del espacio.

 

¿Cómo podemos elegir ‘sigma‘?

Tenemos que definir un nuevo objeto llamado perplejidad:

Perplejidad: 2H(Pi). Donde:

Si la perplejidad es constante entonces nos permite cambiar los vecinos al mutar la única sigma.

 

Problema: En caso de alta dimensionalidad, los valores lejanos son acumulados en un ‘bloque periférico’. Este deslizamiento se debe a nuestra disposición de representar de manera adecuada la estructura del vecino.

 

Resolución: Su correción en t-SNE

Por lo tanto, nos disponemos a corregir esta concentración de clasificaciones erróneas. Para hacerlo, operaremos en la estructura general de la distribución gaussiana. La idea principal es muy simple, intenamos elevar las colas de la distribución. Al hacer esto, los puntos originalmente cerrados (cercano a uno) se deslizarán en un factor insignificante. Por otro lado, los valores lejanos experimentarán un deslizamiento considerable, distanciándolos unos de otros.


 

Hagamos uso de él con Python.

Únicamente tenemos que llamar a la biblioteca Scikit, en donde está implementado:

from sklearn.manifold import TSNE

Respecto a t-SNE, vamos a discutir los parámetros más relevantes:

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: por defecto (igual a 2), es el número de dimesiones finales.
  • perplejidad: es el parámetro principal. Cuanto mayor sea la perplejidad, mayor será la cantidad de vecinos. Una buena regla es ajustarlo entre 5 y 50.

 

¡Atención!

Si la perplejidad es demasiado pequeña, no capturaremos suficientes vecinos: al contrario, un número excesivo acercará valores demasiado lejanos. Con grandes conjuntos de datos se recomienda mejorar este parámetro.

 

* learning_rate : sugerimos un rango entre 10 y 1000.

 

Pero, ¿cómo deberíamos de inicializarlo de manera correcta en un rango tan grande?

Consideremos dos casos:

 

  • Los datos se concentran en un espacio casi equidistante el uno del otro, esto significa, que emerge un valor demasiado grande.
  • La conenctración fuerte de datos con solo algunos valores atípicos. El parámetro está ajustado muy bajo.

 

 

Ahora, queremos aplicarlo a los datos reales.

El conjunto de datos MNIST, consiste de más de 60 mil imágenes de digitos escritos a mano.

 

Importamos los paquetes y datos requeridos:

 %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 

 

Hacemos una primera reducción de dimensionalidad con un análisis de componentes principales (PCA): útil cuando existen muchos datos comprimidos, a diferencia de cuando existen datos de sobra, en donde SVD puede ser la mejor alternativa.

 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]] 

 

Empecemos a usar el t-SNE. La perplejidad ha sido definida como 40, después de algunos intentos.

 

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

 

Representando nuestros resultados:

 

 

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) < 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)

 

El t-SNE obtuvo el resultado en 17.51s.

 

Si queremos comprararlo con otras ténicas de reducción de la dimensionalidad (como se mencionó antes), hay dos cuestiones fundamentales a explicar:


  1. Habilidad discriminatoria efectiva.

Establecer los parámetros de manera adecuada no siempre es fácil. Por lo tanto, aquí hay un enlace que muestra cómo modificar los parámetros principales y mostrar el diseño de datos en tiempo real. Hay que recordar que los datos que se encuentran en el enlace son simulados y provienen de un ambiente controlado.

 

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

 

  1. Tiempo de ejecución:

A diferencia de otras herramientas, el t-SNE requiere un número elevado de tiempo y recursos. Como se puede ver, mientras el PCA toma aproximadamente 0.01, el t-SNE es 17s más lento. Tenemos que considerar esto, si  consideramos el lapso de tiempo como un factor crucial.

 

Sin embargo, es posible proporcionar algunas ideas sobre cómo abordar este problema. Aquí hay dos artículos del Departamento de Ciencias de la Computación de la Universidad de 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

 

 

 

References:

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

http://www.cs.toronto.edu/~fritz/absps/sne.pdf (documentation about SNE)

http://www.cs.toronto.edu/~hinton/absps/tsne.pdf (documentation about t-SNE)

 

Stochastic Neighbor Embedding (SNE) and its correction in t-SNE

Author: Matteo Alberti

 

In this tutorial we are willing to face with a significant tool for the Dimensionality Reduction problem:

Stochastic Neighbor Embedding or just “SNE” as it is commonly called.

The problem definition is:

“We have a large dataset, and we want to find a way to reduce the dimensionality,  both for pre-processing and classification/visualization”. However we have a constraint:

There might exist ambiguous elements.

Therefore, the first question is:

What do we mean by ambiguity?

 

Example We are dealing with a text classification problem and we address with the following word:

Bank.

We are focused on binding this word to others like “finance” or “money” but it might arise that it is related to “river” (namely, bank river) in the same time.

The most popular common dimensionality reduction tools Givesuch as:

  • Multidimensional scaling (MDS)
  • PCA (Principal Component Analysis).
  • Local Geometry preserved tools (Local Linear Embedding)

Given that, every object from an high-dimensional space, can be associated with only one object within a low-dimensional space.

SNE tries to map high-dimensional into low-dimensional objects by preserving the neighbourhood relationship structure in spite of a trade-off consisting of a misclassification around the far objects. SNE has nothing to do with  non-dissimilarity measures but it is grounded on the concept of Entropy and Probability Divergences.

The main idea is to centre a Gaussian distribution for each input value (within the high dimensional space) in order to use its density to define a probability distribution of all neighbours. The aim is to approximate this probability distribution as much accurately as possible replicating the relations structure in a low dimensional space.

Let us introduce the appropriate mathematical formalism:

Given X1….Xn ∈ RK , we intend to to build a mapping function (𝛗) ∈ R2.

We are going to centre a Gaussian distribution for each value and associate a probability to them.

X_{i}\rightarrow\{P_{j|i}\}_{j\neq i}}= \frac{ exp-\{{\frac{\left[|X_{i}-X_{j}|]^2}{2\sigma i^2}}\}} {\sum_{i\neq j} exp-\{{\frac{\left[|X_{i}-X_{j}|]^2}{2\sigma i^2}}\}}}

 

This way, we wish to have a look at what we see during the transition from Rk to Ras much as possible.

 

R^k \{X_1, ... , X_k\} \frac{\varphi}{\rightarrow} \{Y_1, ... , Y_k\} \in R^2 \\ ... \\ R^k \{P_1, ... , P_k\} \leftrightarrow \{Q_1, ... , Q_k\} \in R^2

 

 

This relation occurs whenever {P1…Pk} and {Q1…Qn} are as similar as possible.

From this, our goal function (K-L) is to minimize:

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

Explanatory note:


 Kullback-Leibler Divergence or  Cross-Entropy:

Given two probability distribution :

Pi… Pk  and Qi…Qk

We define Kullback-Leibler Divergence as:

With the following properties:

1.      D(P||Q) ≥ 0

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

3.      D(P||Q) ≠ D(Q||P)      Not symmetrical


 

What is the meaning?

  •  If Pi increases the object is closer
  • If Qi increases while Pi decreases means approaching two far objects in Rk (not good!) But it’s a negligible error because our Qi is weighted by Pj|i. This is way SNE preserve local neighbour structure despite global one.

How does c change while we move within the space? How can we move?

This can be done by a study of partial derivatives:

Firstly, let us remind that the density of points is given by σ (Gaussian dilation and Smoothing parameter). This means that our values look further or closer.

 

How can we choose σ?

We have to define a new object called Perplexity:

 Perplexity: 2H(Pi)

Where H(P)=-\sum_{i=1}^{k} P_i ln ({P_i}) Entropy

If Perplexity is constant then it enables us to vary the neighbours by mutating the only σ.

 

Problem: In case of high-dimensionality, far values are accumulated in a “block around”. This slippage is due to our willingness to adequately represent the neighbour’s structure.

 

Resolution: its correction in t-SNE

Therefore, we are willing to remedy this concentration of miss-classification error. In order to do so, we will operate on the overall structure of the Gaussian distribution. The main insight is very simple. We intend to raise the queues of the distribution. By doing so, the originally close points (next to one) will be slipped away in a negligible factor. On the other hand, far values will undergo a considerable sliding, distancing them from each other.

 

  

 

 

 

Let us make use of it with Python

We just have to recall Scikit library where it is implemented:


from sklearn.manifold import TSNE</span></td>

 

t-SNE  (we are going to discuss the most relevant parameters)



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: default (equal to 2), it is the number of the ending dimensions.
  • Perplexity: It is the main parameter. The higher perplexity, the more the the number of neighbours. A good rule is setting it up between 5-50.

Pay attention!

If Perplexity is too small we will not capture enough neighbours; on the contrary, an excessive number will approach values too far. With large datasets, an enhancement of this parameter is recommended.

 

  • learning_rate: we suggest a range between 10 and 1000.

BUT how should we initialize it correctly in such a huge range?

Let us consider two cases:

 Former: Data concentrates in an almost equidistant space from each other. That means that an overly large value arises.

 Second: Strong Data concentration with only some outliers. The parameter is set too low.

 

Now we want to apply it to real data:

Dataset MNIST, consisting of over 60,000 images of handwritten digits.

 

Le us import the required packages and data.





%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

 

We make a first dimension reduction with PCA: useful when there are many compressed data, whereas, by spare data, SVD can be the best choose.


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]]

Le us start t-SNE, perplexity has been set at 40 after some attempts.



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

 

 

Now let us depict our results:

 


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) < 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)


 

t-SNE got in 17.51s

 

If we want to compare it with other dimensionality reduction techniques (as mentioned earlier), there are two critical issues to explain:

 

  1. Effective discrimination ability

Of course setting parameters correctly is not always easy. Hence, here you have a link showing how to modify the main parameters and display the data layout in real time: remind that the data you will find here are simulated and well known.

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

 

  1. Execution time:

In spite of other tools, t-SNE requires a greater number of time and resources. As you can see, while PCA takes about 0.01, t-SNE is 17s slower. We have to evaluate this issue if we coondised “time-lapse” as a crucial factor.

However, it is possible to provide some insights about how to tackle this problem. Here you are with two articles from the Computer Science Department at the University of 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

 

 

 

References:

 

Una breve mirada al Aprendizaje Profundo y el Aprendizaje Automático

Autores: Matteo Testi & Francesco Pugliese

 

En los últimos años la palabra en boga dentro del área de la inteligencia artificial era el aprendizaje profundo, más conocido por sus siglas en inglés como Deep Learning. Hay un gran interés en esta clase de área. En ambito lavorativo las compañías están llevando a cabo una búsqueda exhaustiva para encontrar expertos en aprendizaje automático (en inglés, Machine Learning), aprendizaje profundo (en inglés, Deep Learning) y también Ciencia de los Datos (en inglés, Data Scientist)

Veamos a continuación un ejemplo del desarrollo de la palabra “Deep Learning” usados con la herramienta Google Trends, podemos ver desde el 2011 hasta el 2017.

Desde el momento en que el celebre software de DeepMind´s AlphaGo derrotó al Master Sur Coreano Lee Se-dol en el juego de mesa Go a principios de este año, el termino “Aprendizaje profundo” ha venido popularizándose aún más. La forma en que el sistema de Deep Learning funcionaba era a través de una combinación entre un algoritmo tradicional de visita y búsqueda en una estructura de árbol llamada “Monte-Carlo Tree Search” (MTS)conocidas redes neuronales convolucionales (CNN). Hasta entonces, MTS   era uno de los programas mas utilizado y capacitados para jugar el juego de Go.  La novedad introducida por Deep Mind fue que la función de evaluación venia deducida automáticamente de las CNN a los entrenados en una primera fase a partir de un conjunto de entrenamiento supervisado formado por millones de movimientos conocidos. Posteriormente, un Sistema de “Deterministic Policy Gradients” basado en un tipo de modelo de aprendizaje de refuerzo, este tipo de modelo funciona como un “jugador critico” al cual se le dio la tarea de jugar contra versiones diferentes de sí mismo durante un largo tiempo. El resultado fue un “jugador” de GO artificial, aún invicto. DeepMind describió en detalle todo el sistema Alpha-GO en el conocido artículo científico publicado en Nature y titulado “Mastering the game of Go with deep neural networks and tree search”.

El siguiente diagrama ilustra las diferencias entre Inteligencia Artificial, Aprendizaje Automático y Aprendizaje Profundo.

 

Aprendizaje Automático (Machine Learning)

El aprendizaje automático (Machine Learning, ML) es esencialmente una forma de estadísticas aplicadas destinadas a usar computadoras para estimar estadísticamente una función compleja. Mitchell en 1997 proporcionó la siguiente definición de Machine Learning: “Un algoritmo aprende de la experiencia E con respecto a una clase de problemas T con una medida igual a P, sì su desempeño en problemas T, medido por P, aumenta con la experiencia E “. En esencia, ML es un conjunto de técnicas que permiten a las máquinas “aprender” de los datos y luego tomar decisiones o hacer una predicción sobre ellos. Un sistema de aprendizaje automático se puede aplicar a una base de “conocimiento” de múltiples fuentes para resolver diferentes tareas: clasificación facial, reconocimiento de voz, reconocimiento de objetos, etc. A diferencia de los algoritmos heurísticos, es decir, los algoritmos que siguen un conjunto específico de instrucciones para la solución de un problema dado, la máquina de aprendizaje permite a una computadora para aprender a reconocer las “configuraciones perceptivas” solo y hacer predicciones sobre ellos.

El Machine Learning está dividido en tres áreas:

  • Clasificación
  • Agrupamiento (Clustering)
  • Predicción

Una de las aplicaciones más populares de Machine Learning ha sido Computer Vision One, durante muchos años. La mayoría de los algoritmos del Aprendizaje automático se pueden dividir en dos categorías de Aprendizaje supervisado y Aprendizaje no supervisado, dependiendo de si el conjunto de entrenamiento está supervisado (es decir, con una información del target asociada con el capacitador, llamada etiqueta o etiqueta) o no supervisado.

– En el aprendizaje supervisado, las etiquetas (labels) están hechas por el humano para permitir que la maquina comprenda la relación entre la entrada (input) y la etiqueta.

– En el aprendizaje no supervisado, las etiquetas no están disponibles. En esta situación, le pedimos a la máquina que encuentre grupos o “clusters” dentro de los datos.

Es entonces como en el Machine Learning elimina la necesidad de alguien estar continuamente codificando y analizado los datos para resolver una solución o presentar un razonamiento. Corta una gran parte y hace la vida un poco más fácil.  El Machine Learning puede estar hecho con un grupo de diversos algoritmos como: Regresiones Lineales/Lógicas, Árbol de decisión, Bosques Aleatorios (Random Forest), Maquinas de vectores de soporte, Análisis de componentes principales (APC, en inglés PCA), K-means, Análisis de componentes independientes (ACI, en inglés ICA), Clasificador Bayesiano ingenuo (en inglés Naive Bayes) etc.

 

Aprendizaje Profundo (Deep Learning)

El aprendizaje profundo o Deep Learning es una subárea del Aprendizaje Automático que usa la “redes Neuronales profundas”, es decir, equipado con muchas capas y nuevos algoritmos para el procesamiento previo de datos para la regularización del modelo: incrustaciones de palabras, abandonos, aumento de datos, etc. El aprendizaje profundo se inspira en la neurociencia ya que las redes neuronales son un modelo de actividad neuronal cerebral. A diferencia del cerebro biológico, donde cualquier neurona se puede conectar a cualquier otra neurona bajo ciertas restricciones físicas, las Redes Neuronales Artificiales (ANN) tienen un número finito de capas y conexiones, y finalmente tienen una dirección predeterminada de propagación de la información. Hasta ahora, las redes neuronales artificiales han sido ignoradas tanto por la comunidad investigadora como por el principal problema de la industria, su costo computacional.

Sin embargo, entre 2006 y 2012, el equipo de investigación dirigido por Geoffrey Hinton, de la Universidad de Toronto fue finalmente capaz de paralelizar los algoritmos para la ANN en arquitecturas paralelas. El resultado principal fue un aumento significativo en el número de capas, neuronas y parámetros del modelo en general (incluso más de 10 millones de parámetros) que permite a las máquinas calcular una cantidad masiva de datos entrenándose en él.

Entonces, el primer requerimiento para entrenar un modelo de Deep Learning es una base de datos muy cuantiosa para que él mismo se entrene. Por esto es importante la figura del Bigdata.

 

Esto es porque existe un gran número de parámetros que necesitan ser entendidos por un algoritmo de aprendizaje, el cual inicialmente puede producir muchos falsos-positivos. La razón tras la popularidad del Deep Learning son el Big Data y la Unidad de procesamiento grafico (en inglés, Graphic Processing Unit (GPUs). Usando una gran porción de datos, los algoritmos y la red aprenden a cómo conseguir metas y mejorar sobre el proceso.

Ahora bien, tenemos que tener en cuenta que el Deep Learning es altamente susceptible al sesgo. Por lo tanto, del modo en el que el modelo de Deep Learning pueda aprender mejor que los humanos en un mismo sentido, puede estar equivocado. En un modelo supervisado si las etiquetas (lables) son establecidas de una manera incorrecta, el modelo va a aprender de los errores.

Cuando el sistema de reconocimiento facial de Google fue inicialmente dado a conocer, por ejemplo, tageó muchas caras negras cómo gorilas.

“Esto es un ejemplo de lo que sucede si no existen caras Afro Americanas en tu colección de entrenamiento”

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

El Aprendizaje Profundo para negocios

El Deep Learning también tiene aplicaciones cuando se habla de negocio. Puede tomar una gran cantidad de datos —millones de imágenes, por ejemplo — y reconocer ciertas características. Búsquedas basadas en textos, detección de fraude, detección de spam, reconocimiento de escritura manuscrita, búsqueda de imágenes, reconocimiento de voz, Street View y traducción son todas las tareas que pueden ser desarrolladas mediante el Deep Learning. En Google, la red de Deep Learning ha reemplazado muchos “sistemas artesanales basados en reglas”, por ejemplo. Hoy en día, el reconocimiento de imágenes por maquinas entrenadas utilizando el Deep Learning en algunos escenarios es mejor que los humanos  por ejempo va desde el reconocimiento de imagines comunes como perro y gatos, hasta indicadores que dectectan el cáncer en la sangre, tumores detectados en imágenes de resonancia Magnética (IRM) .

Conclusiones

La teoría del aprendizaje automático sostiene que estos algoritmos pueden generalizarse muy bien a partir de un número finito de ejemplos de entrenamiento. Sin embargo, esto contradice los principios básicos de la lógica: derivar reglas generales de un conjunto limitado de ejemplos no es una afirmación lógicamente válida. En otras palabras, para inferir una regla que describa a cada miembro de un conjunto, deberíamos tener información sobre cada miembro del conjunto. En parte, ML aborda este problema con reglas probabilísticas en lugar de algunas reglas de razonamiento lógico. Desafortunadamente, esto no resuelve completamente el problema. De hecho, de acuerdo con el Teorema “No Free Lunch” (David Wolpert y William Macready, 1997): un promedio de todas las posibles distribuciones de la generación de los datos, cada algoritmo de clasificación se puede mostrar la misma tasa de errores en los datos observados, que tiene el mismo error de generalización (en el conjunto de pruebas). Esto significa que el mejor algoritmo de Aprendizaje Automático no puede existir: por lo tanto, nuestro objetivo debe ser comprender qué tipos de distribuciones son relevantes para el “mundo real” y qué tipo de algoritmos ML tienen un mejor rendimiento que otros una vez que funcionan en datos extraídos de las distribuciones en el que estamos focalizzando. incluso el aprendizaje profundo (que es una parte de la máquina de aprendizaje) no pueden tener el mejor rendimiento de la máquina de aprendizaje universalmente, pero todo depende del dominio de la tarea que nos enfrentamos. Aunque parece que, en un futuro cercano, Deep Learning resolverá muchos de los problemas que tenemos todos los días en el dominio de las computadoras, los negocios, la IA, el marketing, etc.

Como dice Andrew Yan-Tak Ng, científico jefe de Baidu, donde dirige el Equipo de Inteligencia Artificial:

Tal y como Andrew Yan-Tak Ng, ex jefe científico en Baidu, donde lideró el grupo de Inteligencia Artificial de la compañía, dijo:

“[Deep learning] IA es la nueva electricidad”.

 

Vamos a profundizar en los próximos tutoriales    el aprendizaje profundo, estad atento

Referencias

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/

 

 

A gentle overview on the Deep Learning and Machine Learning

Authors: Francesco Pugliese & Matteo Testi

 

During the last years, a buzz word arose in the field of Artificial Intelligence: Deep Learning”. Recently, there is a great interest in this kind of research, especially amongst business companies which are truly performing a “scavenger hunt” in order to find experts from Machine Learning and Deep Learning areas. These roles are increasingly being associated with the figure of the Data Scientist.

We can simply have a look at the development of “Deep Learning” by Google Trends, in time-slot ranging from 2011 to 2017.

 

Since the time DeepMind’s “Alpha-Go” software defeated South Korean Master Lee Se-dol in the board game Go earlier last year, the term “Artificial Intelligence” (AI) has become exponentially popular. The way the Deep Learning Engine within Alpha-Go worked consisted in combining the traditional Tree Navigation algorithm called “Monte-Carlo Tree Search” (MTS) with very deep “Convolutional Neural Networks” (CNN). Until then, MTS was a de-facto-standard for building record-breaking programs able to play Go game. However, the value-functions was still based on heuristic hand-crafted heuristic methods. The novelty introduced by DeepMind was the value-function inferred by a CNN trained on a Supervised Training Set before of million moves. Successively, a Deterministic Policy Gradients System based on an Actor-Critic Model was addressed to play against different versions of him-self for a long time. The result was a still unbeaten artificial GO player. In the popular Nature article named “Mastering the game of Go with deep neural networks and tree search,” DeepMind carefully describe all the Alpha-Go system.

 

 

The following diagram explains the difference in the Artificial Intelligence, Machine Learning and Deep Learning.

 

Machine Learning

Machine Learning (ML) is essentially a form of applied statistics meant to use computers to statistically estimate complex function. Mitchell in 1997 provides the following definition of Machine Learning: “A computer is said to learn from experience E concerning some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E.” Basically, ML is a set of techniques able to “learn” from data, and then make a decision or prediction about them. A Machine Learning system can be applied to “knowledge” from multiple sources to solve diverse tasks: facial classification, speech recognition, object recognition, etc. Unlike hard-coded algorithms, namely algorithms with specific instructions to solve a problem, Machine Learning enables a computer to learn how to recognize patterns on its own and make predictions.

 

 

The Machine Learning can be adapted for three different types of tasks:

  • Classification
  •  Clustering
  • Prediction

One of the most popular applications of machine learning has been Computer Vision, for many years. Most machine learning algorithms can be divided into the categories of supervised learning and unsupervised learning according to the training set comes supervised (with trainer’s external information or labels) or not supervised.

In Supervised Learning, labels are made by human to enable the machine to find out the relationship between input and labels

 

 

In Unsupervised learning, there are no labels available. In this situation, we are asking the computer to find clusters within the data.

 

 

Typical Machine learning algorithms are Random ForestLinear / Logistic Regression, Decision Tree, Support Vector Machines, PCA, K means, ICA, Naive Bayes etc.

Deep learning

The Deep Learning is a subarea of the Machine Learning that makes use of Deep Neural Networks (with many layers) and specific novel algorithms for the pre-processing of data and regularization of the model: word embeddings, dropout, data-augmentation. Deep Learning takes inspiration from Neuroscience since Neural Networks are a model of the neuronal network within the brain. Unlike the biological brain, where any neuron can connect to any other under some physical constraints, Artificial Neural Networks (ANNs) have a finite number of layers, connections, and fixed direction of the data propagation. So far, ANNs have been ignored by the research and business community. The problem is their computational cost.

Between 2006 and 2012 the research group led by Geoffrey Hinton at the University of Toronto finally parallelized the ANNs algorithms to parallel architectures. The main breakthroughs are the increased number of layers, neurons, and model parameters in general (even over than 10 million) allowing to compute massive amounts of data through the system to train it.

 

 

Therefore, the first requirement for training a Deep learning Model is having available a massive train-set. This makes Deep Learning a good fit for the Big Data age.

 

 

The reasons behind the popularity of Deep Learning are Big Data and Graphic Processing Unit (GPUs). Using a massive amount of data the algorithm and network learn how to accomplish goals and improve upon the process.

 

 

A deep learning algorithm could be instructed to “learn” what a dog looks like. It would take a massive data set of dog’s images to understand “features” that identify a dog and distinguish it from a wolf. We should keep in mind that, the Deep learning is also highly susceptible to bias. For example, in a supervised model, if the labels are made wrong, the model is going to learn from the mistakes.

When Google’s facial recognition system was initially rolled out, for instance, it tagged many black faces as gorillas.

“That’s an example of what happens if you have no African American faces in your training set” 

Said Anu Tewary, chief data officer for Mint at Intuit.

Deep Learning for Business

Deep learning affected business applications as never happened in Machine Learning before. It can deal with a huge amount of data—millions of images, for example—and recognise certain discriminative characteristics. Text-based searches, fraud detection, spam detection, handwriting recognition, image search, speech recognition, Street View detection, recommendation systems and translation are only some of the tasks that can be tackled by Deep Learning. At Google, Deep Networks have already replaced tens of “handcrafted rule-based systems”. Today, Deep Learning for Computer Vision already displays super-human capabilities, and that ranges from recognising common pictures like dog & cats to identifying cancer nodules in lung ct-scans.

The Take-Away

Machine Learning theory claims that an ML algorithm can generalise very well from a finite training set of examples. This contradicts the basic of logic: inferring general rules from a limited set of examples is not logically valid. In other words, to infer a rule describing every member of a set, we should have information about every member of that set. In part, ML addresses this problem with probabilistic rules rather than certain rules of logical reasoning. Unfortunately, this does not resolve the problem. According to the “No Free Lunch Theorem” (David Wolpert and William Macready, 1997): averaged over all possible data generating distributions, every classification algorithm shows the same error rate on unobserved data (test set). This means that the best ML algorithm cannot exist: so our goal must be to understand what kinds of distributions are relevant for the “real world” and what kind of ML algorithms perform well on the data drawn from distributions we focus on. In other words, Deep Learning is not universally better than Machine Learning, but it depends on the task domain. However, it seems that, in the future, Deep Learning will be likely solving many of our everyday computer, business, AI, marketing, etc.

As Andrew Yan-Tak Ng, former chief scientist at Baidu, where he led the company’s Artificial Intelligence Team says,

“AI is the new electricity”. 

We add: Deep Learning is the new light bulb.

We will deepen Deep Learning in the next tutorials, stay tuned…

 

References

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/

 

 

Computational BIM

Introduction to Tensorflow