Spark y Machine Learning (MLlib)
/en Frameworks ES, Senza categoria /por Matteo AlbertiAutor: 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
/en Senza categoria /por AndreaBacciu2018Autor: 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:
- 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)
/en Senza categoria, spagnolo /por AndreaBacciu2018Autor: 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;nbsp.run(training)
Se ejecuta el modelo en la base de datos de prueba.
val predictionAndLabels = test.map {case LabeledPoint(label, features) =&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")
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
/en Senza categoria, spagnolo /por AndreaBacciu2018
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.
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/