Memory_Networks

Senza titolo

Spark y Machine Learning (MLlib)

Autor: Antonio Berti

En este tutorial vamos a aprender el uso de la libreria de Apache Foundation para el Machine Learning llamada MLlib.

MLIB forma parte de las API de Spark y es interoperable con NumPy de Python así como las librerias de R. implementado con Spark es posible utilizar cualquier tipo de datos de cualquier origen o de la plataforma Hadoop como por ejemplo HDFS, HBase, las fuentes  datos provenientes de database relacionadas o fuentes de datos locales, como documentos de texto.

Spark sobresale en los procesos de cálculos iterativo permitiendo que los procesos escritos en las librerias MLlib se ejecuten rápidamente permitiendo su uso y tambien  sobre todo a nivel industrial.

MLlib proporciona muchos tipos de algoritmos, así como numerosas funciones de utilidad. ML incluye algoritmos de clasificación, regresión, árboles de decisión, algoritmos de recomendación, agrupamiento. Entre las utilidades más utilizados puede incluir las características de las transformaciones, la estandarización y normalización, funciones estadísticas y álgebra lineal.

 

Primero que todo cargamos la base de datos

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

 

El conjunto de datos se divide en una parte utilizada para entrenar el modelo (60%) y otra parte para las prueba (40%).

 

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

val training = splits(0).cache()

val test = splits(1)

Se ejecuta el modelo en la base de datos de prueba.

val model = new LogisticRegressionWithLBFGS()
.setNumClasses(10)&nbsp
.run(training)

Se entrena el algoritmo y se costruye el modelo

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

 val prediction = model.predict(features)

  (prediction, label)}

De esta forma, se obtiene la métrica del modelo y la precisión del pronóstico.

val metrics = new MulticlassMetrics(predictionAndLabels)

val accuracy = metrics.accuracy

println("Accuracy = $accuracy")

Es posible guardar el modelo recién entrenado y volver a cargarlo en la memoria para su uso posterior.

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

val sameModel = LogisticRegressionModel.load(sc,

               "target/tmp/scalaLogisticRegressionWithLBFGSModel")

 

Referencias

documentación spark – http://spark.apache.org

documentación mllib – http://spark.apache.org/docs/latest/ml-guide.html

dataset de ejemplos mllib – https://github.com/apache/spark/tree/master/data/mllib

codigo de ejemplo  – https://github.com/apache/spark/tree/master/examples/src/main/scala/org/apache/spark/examples

 

Métodos para la reducción de la dimensionalidad manifold-based: el caso ISOMAP

Autor: Matteo Alberti

 

 

 

 

Entre metodologías principales  que hay en la  reducción lineal de dimensionalidad, tenemos las PCA o los componentes principales,estas son ciertamente las principales herramientas del Statistical Machine Learning.

Nos enfocamos muy a menudo en instrumentos que capturan el componente no lineal, el análisis de los componentes principales es el punto de partida para muchos análisis (y como una herramienta de preprocesamiento) y su conocimiento se vuelve imperativo en caso  que las condiciones en la linealidad sean satisfactorios.

En este tutorial vamos a presentar a nivel matemático la formación de los principales componentes de forma clara y concisa, como se implementa en python pero sobre todo su interpretación

“La idea básica es encontrar un sistema de referencia que maximice la varianza de las variables representadas”

Esto se hace dividiendo la varianza total en un número igual de variables de inicio, pero será posible reducir el número en función de la contribución que cada PC proporciona en la construcción de nuestra varianza total.

Nos gustaría recordarle que la aplicación de Análisis de Componentes Principales es útil cuando las variables de inicio no son independientes

 

Dado un conjunto de p variables cuantitativas X1, X2 ,. . . , Xp (variables centradas o estandarizadas) queremos determinar un nuevo conjunto de k variables t.c k≤p indicadas con Ys (s = 1,2, … k) que tienen las siguientes propiedades:

 

sin correlación, reproducir la mayor parte posible de la varianza restante después de la construcción de los primeros s-1 componentes, construido en orden creciente con respecto al porcentaje de varianza total que se reproducen, En promedio, no son nada

Como resultado, la combinación lineal será:

Por lo tanto, debemos encontrar los coeficientes v t.a.c que satisfacen nuestras propiedades.Este es un problema de restricción máxima donde la primera restricción se llama normalización:

Nuestro sistema es así:

Donde la varianza se puede expresar de la siguiente manera:

Y se resuelve mediante el método multiplicador de Lagrange:

Cálculo del gradiente de L1 y su cancelación obteniendo:

Donde   Este sistema admite infinitas soluciones (que respetan la restricción) al disminuir el rango de la matriz de coeficientes del sistema:

que corresponden a λs llamados valores propios de Σ.

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:

De manera similar, para la construcción del segundo PCA (y para todos los demás), se agrega a nuestro sistema la Restricción de Ortogonalidad, le perdimos nuestra solicitud a los PC que estan sin correlación,podemos dar un ejemplo  de la siguiente manera:

Entonces al establecer la lagrangiana en p + 2 variables obtenemos:

De donde obtenemos el segundo valor propio de Y2 donde recordamos que se aplica la siguiente propiedad:

Propiedades de computador:

a) Cada valor propio de Σ tiene un papel en varianza respectiva del computador.

su valor es positivo

Varianza total

Varianza General

 

CRITERIOS DE SELECCIÓN:

Para la elección del número k (con k <p) de PC que se mantendrá en el análisis no existe un criterio universalmente aceptado y válido. Por lo tanto, es una buena práctica usarlos de forma conjunta y siempre tener en cuenta las necesidades del análisis. Expodremos los principales:

  1. a) Porcentaje acumulado de la varianza total reproducida:

 

                                                                                   

medida absoluta                           Normalización                                     Porcentaje acumulado

 

Establezca un umbral T en el porcentaje acumulado y mantenga el primer kPC en análisis que garantice que excede el umbral

 

b) Screen-Plot

Representa los valores propios con respecto al número de orden del componente

Donde se selecciona el primer k PC basado en la reducción de pendiente (también llamado criterio de codo). En este caso específico, los PC que se mantendrán en análisis serían los dos primeros.

 

c) Criterio Kaiser

También conocido como criterio de valor proprio mayor que 1 (válido solo para variables estandarizadas)

 

 

Vamos a implementar:

Importamos los paquetes necesarios de scikit-learn

import numpy as np

from sklearn.decomposition import PCA

La clase tiene los siguientes atributos:

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

Comentemos los principales parámetros:

  • n_components = número de componentes a analizar. Aconsejamos en una fase de elección no establecer este valor y evaluar en función de los criterios anteriores.
  • svd_solver = nos da algunas de las alternativas principales (arpack, randomized ..) queremos recordar que PCA no admite datos dispersos (para lo cual deberá cargar TruncatedSVD)

Vamos a probarlo en nuevos datos reales, por ejemplo, en los datos de Wine que se pueden importar a través del comando

from sklearn import datasets

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

from sklearn import decomposition

En este punto vamos a implementar PCA y hacer 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()

Este será el gráfico que obtendremos:

Por lo tanto, vamos a seleccionar solo las primeras 3 variables de referencia

Apache Scala y Machine Learning (MLlib)

Autor: Antonio Berti

En este tutorial vamos a aprender el uso de la libreria de Apache Foundation para el Machine Learning llamada MLlib.

MLIB forma parte de las API de Spark y es interoperable con NumPy de Python así como las librerias de R. implementado con Spark es posible utilizar cualquier tipo de datos de cualquier origen o de la plataforma Hadoop como por ejemplo HDFS, HBase, las fuentes  datos provenientes de database relacionadas o fuentes de datos locales, como documentos de texto.

Spark sobresale en los procesos de cálculos iterativo permitiendo que los procesos escritos en las librerias MLlib se ejecuten rápidamente permitiendo su uso y tambien  sobre todo a nivel industrial.

MLlib proporciona muchos tipos de algoritmos, así como numerosas funciones de utilidad. ML incluye algoritmos de clasificación, regresión, árboles de decisión, algoritmos de recomendación, agrupamiento. Entre las utilidades más utilizados puede incluir las características de las transformaciones, la estandarización y normalización, funciones estadísticas y álgebra lineal.

 

Primero que todo cargamos la base de datos

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

El conjunto de datos se divide en una parte utilizada para entrenar el modelo (60%) y otra parte para las prueba (40%).

val splits = data.randomSplit(Array(0.6, 0.4), seed=11L)
val training = splits(0).cache()
val test = splits(1)

Se entrena el algoritmo y se costruye el modelo

val model = new LogisticRegressionWithLBFGS().setNumClasses(10)&amp;amp;nbsp.run(training)

Se ejecuta el modelo en la base de datos de prueba.

val predictionAndLabels = test.map {case LabeledPoint(label, features) =&amp;gt; 
 val prediction = model.predict(features)
  (prediction, label)}

De esta forma, se obtiene la métrica del modelo y la precisión del pronóstico.

val metrics = new MulticlassMetrics(predictionAndLabels)
val accuracy = metrics.accuracy
println("Accuracy = $accuracy")

Es posible guardar el modelo recién entrenado y volver a cargarlo en la memoria para su uso posterior.

model.save(sc, "target/tmp/scalaLogisticRegressionWithLBFGSModel") 
val sameModel = LogisticRegressionModel.load(sc, 
               "target/tmp/scalaLogisticRegressionWithLBFGSModel")

 

Referencias
documentación spark – http://spark.apache.org

documentación mllib – http://spark.apache.org/docs/latest/ml-guide.html

dataset de ejemplos mllib – https://github.com/apache/spark/tree/master/data/mllib

codigo de ejemplo  – https://github.com/apache/spark/tree/master/examples/src/main/scala/org/apache/spark/examples

Long-term memory neural network 1 – Introducción

Autor: Daniele D’armiento
Las habilidades cognitivas como el reconocimiento, la predicción, la elección de respuestas y las acciones implican la recuperación de información previamente almacenada.
El desafío para desarrollo de la inteligencia artificial es crear un modelo que pueda almacenar mucha información y que pueda rescatarse rápidamente.
Pero no es una novedad que las computadoras ya puedan almacenar grandes cantidades de datos (se estima que todos los datos almacenados hasta la fecha superan los ZettaByte, o 1021 bytes) incluso estos datos están indexados en un database de varios tipos, disponibles y recuperables con lenguajes potentes como SQL.
Además, el cerebro humano tiene una memoria que no estable como aquella del silicio, pero en esta “brecha” reside el potecial de procesar datos como intuitivamente sabemos, asi poder vencer la maldición de la llamada dimensionalidad.

 

Ninguna investigación ha revelado completamente los secretos del cerebro humano, sin embargo no comprendiendo completamente el funcionamiento de nuestra inteligencia, el desarrollo de estos últimos años  a sido gracias al  Deep Learning (que tiene sus orígenes enraizados en la biología de las redes neuronales) nos permite acercarnos a este modelo de inteligencia, que aprende a reconocer señales codificadas en imágenes y sonidos, clasificarlas, construir representaciones internas para organizar estos pilares de datos, recuperar rápidamente la información que se almacena de forma distribuida en todos los nodos de la red (por lo tanto, en cada neurona, y no en direcciones de memoria precisas), todo en modo automático, sin instrucciones algorítmicas secuenciales.

En los años previos al advenimiento del Deep Learning la velocidad del cálculo era muy limitada, y no hace falta decir que, si los procesos son lentos, lleva mucho tiempo procesarlos y memorizarlos. Es obvio pero no trivial, porque nadie había intentado experimentar con un modelo de red la cual habría requerido años para ser utilizada, pero la clave para descubrir este mundo ya existía. Dado que el modelo de aprendizaje que todavía se utiliza en la actualidad es Backpropagation, junto con Gradient Descent para lograr que no haya ningún error, se requirió muchos pasos de actualización de los pesos de la red, y muchos datos como ejemplos para el cual poder aprender. Todo esto hace que el proceso de aprendizaje sea muy difícil con los cálculos.

Como resultado, los viejos modelos tenían que ser livianos, y no explotaban la enorme cantidad de datos necesarios, se limitaban a arquitecturas “shallow” es decir, no profundas o con menos parámetros de entrenamiento, uno o dos niveles de neuronas feed-forward. Pero para abstraer una representación válida de la realidad observada, es decir, memorizar datos en estructuras complejas capaces de preservar el mayor número de características observadas, y al mismo tiempo generalizar, es decir, reconocer esas características incluso en objetos nuevos nunca antes observados, se necesita un modelo más complejo.
Necesitas memorizar más datos, memorizar pero no “como máquina”, (dicen todos aquellos nacidos antes del advenimiento de la singularidad, (si alguna vez pasara … ¡cuando la realidad supera  toda ciencia ficción!), Eso no es como cuando aprendemos un poema de memoria, pero al contrario, es como cuando enciendes una lámpara y entiendes una estructura de cosas que unifica varias facetas de una sola entidad que anteriormente parecía no estar relacionada con ningún enlace.

Cuando un modelo de aprendizaje profundo nos sorprende con su capacidad para reconocer objetos en imágenes, o para comprender las palabras que estamos pronunciando, o para responder de manera sensata a una pregunta escrita, significa que el modelo ha capturado la información necesaria para resolver ese problema en particular, a partir de los datos a los que se han enviado. No memorizó todos los datos en una base de datos clásica, pero los filtró, resumiendo un “concepto”, de una manera que se acerca a la manera en que pensamos nosotros los conceptos.

Esto es posible gracias a la estructura “deep” de los modelos actuales, que permite, de una manera que todavía no se entiende del todo, almacenar más información y conceptos en la red, en comparación con los modelos anteriores.

En cuanto a los modelos lingüísticos para las traducciones, la conversación y todas las aplicaciones NLP y NLU, ha habido un marcado aumento en el rendimiento gracias a Deep Learning.

Estas actuaciones se pueden medir estadísticamente, pero también es intuitivo comprender cómo un cierto modelo puede realizar un chatbot decente o una buena traducción. Si lo hace, significa que la red neuronal tiene una memoria capaz de hacer que las conexiones semánticas sean más complejas que una simple tabla de referencia. Esto requiere una memoria a largo plazo, que pueda vincular palabras o frases o referencias semánticas que tengan sentido, y así generar una representación interna de un contexto, en lugar de crear estadísticas simples de palabras en n-gramas tales como sucedia años atras.

En el siguiente análisis veremos un modelo muy interesante, las redes (DMN) Dynamic Memory Network, que están formadas en elementos compuestos de frases de entrada, preguntas y respuestas, cuyo potencial radica en la llamada memoria Episodica, capaz de realizar un procesamiento de múltiples pasos de las frases de entrada, a partir de las cuales elabora un contexto e intenta extraer la información solicitada.

 

Bibliografía

https://blogs.cisco.com/gov/internet-traffic-continues-to-explode-no-end-in-sight

https://thoughtsahead.com/2017/01/27/machine-learning-series-introduction-to-machine-learning-linear-regression-and-gradient-descent/

https://www.quora.com/What-is-the-difference-between-deep-and-shallow-neural-networks

https://research.googleblog.com/2017/05/using-machine-learning-to-explore.html

https://yerevann.github.io/2016/02/05/implementing-dynamic-memory-networks/