Aprendizaje profundo con Apache Spark — Parte 1

Autor: Favio Vázquez

Este artículo representa la primera parte de una discusión sobre Distributed Deep Learning con Apache Spark. Analizaremos principalmente qué es Spark y los conceptos básicos de Spark + DL. Puedes encontrar la segunda parte aquí: Deep Learning With Apache Spark — Part 2.

  Introducción de  Apache Spark

 

apache spark

 

Apache Spark TM

Spark sus creadores lo definen como una tecnología rápida y genérica para el procesamiento de datos a gran escala.

Rápido en comparación con los enfoques anteriores en la gestión de grandes volúmenes de datos, como el clásico MapReduce. El secreto de Spark radica en la memoria (RAM) que hace que el procesamiento sea más rápido que el realizado en el disco

Generica significa, que se puede usar para múltiples funciones tales como: ejecución de SQL distribuido, creación de canalizaciones de datos, asimilación de datos en bases de datos, ejecución de algoritmos de aprendizaje automático, trabajo con estructuras gráficas, etc.

 

 

RDD

 

 

 

image 1

Imagen sacada de PySpark-Pictures de Jeffey Thompson

El punto de partida de Apache Spark es el Resilient Distributed Dataset (RDD), un set de datos dividido en particiones.

Un RDD es un conjunto de elementos, con tolerancia a fallas (fault-tolerant) , que se pueden ejecutar en paralelo. Puede crearlos paralelizando una colección que ya tienen en su programa driver o haciendo referencia a un dataset en un sistema de memoria externo como HDFS, HBase o cualquier fuente de datos que ofrezca un formato de entrada Hadoop.

 

rdd

 

Una cosa para recordar acerca de Spark es que en todas las transformaciones los resultados no se contaran de inmediato, sino que se aplica una estructura de gráfico. Las transformaciones se calculan solo cuando se define el gráfico.

 

Por defecto, cada RDD se puede recalcular cada vez que se realiza una acción en él. Sin embargo, también puede mantener un RDD en la memoria utilizando el método de caché, y en este caso Spark mantendrá los elementos alrededor del clúster en la memoria para un acceso futuro más rápido. También ofrece soporte para almacenar RDD en un disco o replicarlos en múltiples nodos

 

Si desea obtener más información sobre las transformaciones y acciones de RDD en Spark, consulte en la documentación oficial:

RDD Programming Guide – Spark 2.3.0 Documentation
Spark 2.3.0 programming guide in Java, Scala and Pythonspark.apache.org

Dataframe

image 2

 

Imagen sacada de PySpark-Pictures de Jeffey Thompson

Comenzando con la versión Spark 2.0.0 DataFrame, el dataset está organizado en columnas con nombre. Conceptualmente es equivalente a una base de datos relacional o un data frame en R / Phyton, pero con sistemas de optimización más sofisticados.

En este artículo no profundizaremos sobre el dataset, pero digamos que lo podemos definir como una colección distribuida de datos que pueden derivarse del  JVM object y luego manipularse mediante transformaciones funcionales. También están disponibles en Scala y Java.

Los dataframe se pueden se puede obterner de una variedad de fuentes tales como: datos estructurados, tabla en Hive, bases de datos externas o RDD existentes.

image 3

 

https://aspgems.com/blog/big-data/migrando-de-pandas-spark-dataframes

En resumen, el dataframe API es el medio utilizado por los desarrolladores de Spark para facilitar el trabajo con datos en el framwork. Es muy similar a los de Pandas y R pero con muchas ventajas. En primer lugar es que pueden distribuirse alrededor de los clusters, para que puedan trabajar con muchos datos; en segundo lugar  es que están optimizados.

Este fue definitivamente el paso más importante, que hizo que el uso de Spark fuera mucho más rápido con Java o Scala.

 

 

image 4

 

 

La persona responsable de esta optimización es Catalyst. Este último toma set de queries y crea un plan optimizado y distribuido para el cálculo.

 

 

 

 

 

 

image 5

Deep Learning y Apache Spark

 

image 6

https://becominghuman.ai/building-an-image-classifier-using-deep-learning-in-python-totally-from-a-beginners-perspective-be8dbaf22dd8

Si quiere saber más sobre el aprendizaje profundo, lea primero los siguientes artículos:

 

A “weird” introduction to Deep Learning

My journey into Deep Learning

¿Por qué utilizar Deep Learning en Apache Spark?

  1. Apache Spark es un framework  para el cálculos distribuido en un clúster.
  2. Hay partes del aprendizaje profundo que son computacionalmente pesadas y la distribución de estos procesos es problemática; Apache Spark es una gran solución.

Hay varias maneras de utilizar el aprendizaje profundo con Apache Spark, los enumeramos a continuación:

  1. Elephas: Distributed DL con Keras e PySpark:

maxpumperla/elephas

  1. Yahoo! Inc.: TensorFlowOnSpark lleva los programas de Tensorflow a los clusters de Apache Spark:

yahoo/TensorFlowOnSpark

 

  1. CERNDistributed DL con un enfoque en distributed training usando Keras y Apache Spark:

cerndb/dist-keras

  1. Qubole el aprendizaje profundo ha demostrado producir modelos altamente efectivos de aprendizaje automático en diferentes áreas (tutoriales Keras + Spark):

Distributed Deep Learning with Keras on Apache Spark | Qubole

  1. Intel Corporation: BigDL (Distributed Deep Learning Library for Apache Spark)

intel-analytics/BigDL

Deep Learning Pipelines

 

 

 

 

image 7

 

 

Databricks

En lo que nos enfocaremos en estos dos artículos  Deep Learning Pipelines.

databricks/spark-deep-learning
spark-deep-learning – Deep Learning Pipelines for Apache Sparkgithub.com

Deep Learning Pipelines es una biblioteca de código abierto creada por Databricks que proporciona API de alto nivel para el aprendizaje profundo escalable en Phyton con Apache Spark.

No pasará mucho tiempo antes de que se convierta en una API oficial, así que vale la pena echarle un vistazo.

Algunas de las ventajas de esta biblioteca, en comparación con las enumeradas anteriormente, son:

  • Proporciona API listas para usar que permiten el uso de aprendizaje profundo con unas pocas líneas de código.
  • Se centra en la integración de fácil uso sin sacrificar el rendimiento.
  • Esta creado por los desarrolladores de Apache Spark, por lo que es más probable que surja como una API oficial.
  • Está escrita en Python, por lo que se integra con las librerias más importantes y utiliza la potencia del Tensorflow y Keras, son dos de los más utilizados en el el aprendizaje profundo.

En la siguiente parte nos enfocaremos completamente en la DL pipelines library  y cómo usarlas. Veremos en particular algunos temas tales como: transfer learning en una simple pipelibe, cómo usar modelos pre entrenados para trabajar con una cantidad “pequeña” de datos y hacer predicciones, etc.

 

Si desea obtener más información sobre Pipeline en Data Science con Python, eche un vistazo a estos artículos de Matthew Mayo:

Managing Machine Learning Workflows with Scikit-learn Pipelines Part 1: A Gentle Introduction

Managing Machine Learning Workflows with Scikit-learn Pipelines Part 2: Integrating Grid Search

Managing Machine Learning Workflows with Scikit-learn Pipelines Part 3: Multiple Models, Pipelines…

 

Para Pipeline en Spark, mire aquí:

 

ML Pipelines – Spark 2.3.0 Documentation

 

Como usar PySpark en el computador

Autor Favio Vázquez

 

spark 2

 

 

https://www.mytectra.com/apache-spark-and-scala-training.html

Supongamos que ya sabe de Apache Spark y PySpark, pero si desea ver una breve introducción la puede encontrar aquí.

El simbolo $ esta ejecutando el comando en el shell, por lo que no tienen que copiarlo.

 

Ejecutar PySpark in Jupyter

 

jupiter

 

  1. Instalar Jupyter Notebook

$ pip install jupyter

  1. Instalar PySpark

 

Comprueben si tienen Java 8 o versiones posteriores en su computadora. También necesitarás Python. (aconsejamos Python 3.5 de Anaconda).

Ahora vayan a la  pagina download di Spark. Seleccione la última versión, un paquete predeterminado para Hadoop, descárguelo.

Si quieren un apoyo Hive o si lo desea, tendrá que crear la distribución de spark usted mismo. Para hacerlo, vaya aquí.

Abra el archivo zip y muévalo a la carpeta directory / opt:

$ tar -xzf spark-2.3.0-bin-hadoop2.7.tgz
$ mv spark-2.3.0-bin-hadoop2.7 /opt/spark-2.3.0

Crea un enlace simbólico que te permita tener múltiples versiones de Spark:

$ ln -s /opt/spark-2.3.0 /opt/spark̀

Finalmente, insértalo en su  shell bash (o zsh ecc.) donde encuentre Spark de esta manera: configuren sus variables $PATH agregando las siguientes líneas en su archivo ~/.bashrc (o ~/.zshrc):

export SPARK_HOME=/opt/spark
export PATH=$SPARK_HOME/bin:$PATH

Ahora, para realizar  PySpark in Jupyter, necesitan actualizar las variables de entorno a PySpark. agregando las siguientes líneas en su archivo ~/.bashrc (or ~/.zshrc):

export PYSPARK_DRIVER_PYTHON=jupyter
export PYSPARK_DRIVER_PYTHON_OPTS=’notebook’

Reiniciar la terminal y lanzar PySpark:

$ pyspark

Este comando debería reiniciar Jupiter Notebook en su browser. Luego crea un nuevo notebook haciendo click ‘New’ > ‘Notebooks Python [default]’. Entonces les aparecera SparkContext y SqlContext (o solo SparkSession per Spark > 2.x)  en su computadora y ahora puede comenzar  a usar PySpark del pc. aqui algunos ejemplos para probar el ambiente.

Ejecutar PySpark nell’IDE  elejido (Integrated Devolopment Environment)

A veces necesitarás un entero IDE para crear códigos más complejos y PySpark no es de dafult en sys.path. pero esto no significa que no puedas usarlo como una biblioteca normal: simplemente agrégalo a la sys.path en la fase de ejecución.  El paquete findspark posee esta función.

$ pip install findspark

Después, para reiniciar PySpark en su IDE, escriban:

import findspark
findspark.init()

 

 

import pyspark
sc = pyspark.SparkContext(appName=”myAppName”)

Esto es todo. A continuación se muestra un ejemplo para probar PySpark localmente:

import findspark
findspark.init(“/opt/spark”)
import random
from pyspark import SparkContext
sc = SparkContext(appName=”EstimatePi”)
def inside(p):
    x, y = random.random(), random.random()
    return x*x + y*y < 1
NUM_SAMPLES = 1000000
count = sc.parallelize(range(0, NUM_SAMPLES)) \
             .filter(inside).count()
print(“Pi is roughly %f” % (4.0 * count / NUM_SAMPLES))
sc.stop()

view rawsimple_spark.py hosted with ❤ by GitHub

Si tiene alguna duda o pregunta, ¡no dude en hacer comentarios y solicitar aclaraciones!

 

Jupyter Notebook Python, Scala, R, Spark, Mesos Stack

docker

 

 

Docker es similar a una “máquina virtual” liviana (Dockers proporciona “imágenes” y “cointainer” y no máquinas virtuales),  como si tuviéramos una segunda computadora con su propio sistema operativo dentro de nuestra máquina. Podemos acceder a esta máquina virtual desde nuestra computadora y usarla como si estuviéramos accediendo a una computadora remota a través de ssh.

jupyter/docker-stacks
docker-stacks – Opinionated stacks of ready-to-run Jupyter applications in Docker.github.com

hagan click en el link  y siga los pasos indicados para tener una versión “contenerizada”  de Spark (2.3 con Hadoop 2.7)

Uso básico

El comando que sigue starts a container with the Notebook server listening for HTTP connections on port 8888 con un token de autenticación generada aleatoriamente

$ docker run -it –rm -p 8888:8888 jupyter/pyspark-notebook

 

Instalación de Pip

pip

 

Este paquete aún es experimental y puede cambiar en versiones futuras.

El paquete Python para Spark no pretende reemplazar todos los demás casos de uso. Esta versión     Python packaged de Spark es adecuado para interactuar con un clúster existente, que puede ser Spark, YARN o Mesos, pero no contiene las herramientas necesarias para configurar nuovos cluster.

Para instalarlo, ejecuta:$ pip install pyspark

Los paradigmas en el aprender del aprendizaje automático

Autor: Matteo Alberti

 

Tradicionalmente tenemos tres tipos diferentes de aprendizaje en el aprendizaje automático:

  • Aprendizaje supervisado
  • Aprendizaje no supervisado
  • Aprendizaje de refuerzo

 

Aprendizaje supervisado

El aprendizaje supervisado tiene como objetivo inferir una función dada de los datos de entrenamiento.

Estos datos consisten en un par que esta formado por un vector de entrada y un valor de salida deseado.

Podemos tener dos diferentes situaciones:

 

  • Clasificación: cuando la variable de salida deseada es categórica (cualitativa nominal o ordinal)

Un ejemplo típico en el campo del marketing puede ser clasificar a los clientes buenos / malos, en el campo médico para predecir a partir de una radiografía la presencia o ausencia de una enfermedad viendo los síntomas.

  • Regresión: cuando la variable de salida deseada es cuantitativa

Problema típico de las estadísticas clásicas en el que dado un conjunto de variables queremos ir y predecir el valor de nuestro objeto variable del análisis

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.

La idea básica es encontrar un conjunto de ponderaciones que puedan predecir correctamente el resultado deseado dando cualquier valor de entrada de datos, generando desde datos de aprendizaje hasta situaciones diferentes.

Los ejemplos típicos de los algoritmos para el aprendizaje supervisado son:

  • Regresión lineal, árboles de decisión, .. para problemas de regresión
  • Logística, árboles de decisión, ANN para problemas de clasificación

 

1 2

 

Aprendizaje no supervisado

En el aprendizaje no supervisado, solo tenemos datos de entrada sin ningún resultado deseado. El objetivo es modelar la distribución de datos subyacente, por ejemplo, para preservar la geometría de los datos locales, reduciendo el número de dimensiones para realizar análisis adicionales o reduciendo a las dos dimensiones individuales, reduciéndonos a los métodos gráficos.

Los algoritmos de aprendizaje no supervisados pueden dividirse en tres situaciones diferentes:

 

 

Los algoritmos de aprendizaje no supervisados pueden dividirse en tres situaciones diferentes:

  • Agrupación: el objetivo es descubrir agrupaciones en los datos
  • Análisis de asociaciones: queremos ir y descubrir las reglas que mejor describen la mayor parte de los datos posibles
  • Estimación cuantil

 

Ejemplos comunes de aprendizaje no supervisado son:

  • Algoritmo de k-promedios
  • Algoritmos a priori para problemas de análisis de asociación
  • Análisis de los componentes principales

 

2.jpg 4

 

Aprendizaje semi-supervisado

En el aprendizaje semi-supervisado, solo una parte de la información está presente, por lo que estamos en un caso en el límite entre los supervisados y los no supervisados.

Un ejemplo típico puede ser el reconocimiento de objetos a partir de imágenes

 

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

 

Aprendizaje de refuerzo:

El aprendizaje de reforzar tiene como objetivo clasificar diferentes situaciones para tomar medidas.

El principal campo de aplicación es la aplicación a la robótica, donde nuestro agente se posiciona dentro de un entorno (entorno) y en cada paso podemos recibir una recompensa dada por una acción positiva. Un ejemplo común son simuladores y bots en videojuegos.

 

3 1

3 1

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/

 

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

Autor: Matteo Alberti

 

 

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 ∈ RK ,  intentamos construir una función (𝛗) ∈ R2.

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 Rk a R2

 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

 

 

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:

 

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

 

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

 

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)

 

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

Autor: Matteo Alberti


 

En este tutorial veremos una miniserie dedicada a métodos de reducción de dimensionalidad basados en una estructura matemática llamada Manifold.

Entonces, primero que todo comprendamos qué es un Manifold, cuándo es útil y cómo aplicarlo, pero sin entrar en detalles sobre la estructura y las propiedades matemáticas.

“Manifold no es más que un espacio matemático donde viene recreado localmente un espacio euclidiano (de una dimensión específica) pero no a nivel global”

Entonces, ¿cuándo y cómo vamos a aplicar métodos basados en Manifold?

La respuesta es simple: cuando fallan los métodos lineales

Investigemos con más profundidad:

 

Ejemplo:

En los métodos lineales (como PCA, MDS, SVD), nuestros datos pueden redimensionarse solo mediante combinaciones lineales de nuestras características, esto significa que no se encuentran estructuras más complejas y no lineales, y por lo tanto se discriminan.

Veamos un ejemplo gráfico:

Metodos Lineares reduciríamos los datos al perder la estructura geométrica. Como se muestra en la figura, se abordarán los puntos X1 y X2  estos se ven mas cerca.(y, por lo tanto, toda la estructura sería “aplanada”)

Metodos Manifold,

los principales son:

  • ISOMAP
  • Local Linear Embedding (LLE)

 

Esta idea básica nos permite resolver muchos problemas no solo en la fase de preproceso (en la computadora Vision, por ejemplo, nos permite resolver problemas de: estimación de posición, compresión de datos, reducción de ruido en la imagen e interpolación de datos faltantes)

 

 

ISOMAP

Comencemos con la primera herramienta:

El algoritmo consta de tres fases:

(1)

Determinar el número de vecinos (neighbors) en Manifold ( basadonde según las distancias euclidianas). Para cada punto, asignaremos los vecinos (determinados según el número de vecinos fijados como en el algoritmo K-NN o en función de un radio fijo)

 

El radio/ el número de vecinos es constante

(2)

En este paso, calcularemos la geodésica. Por lo tanto, calcularemos la distancia de cada par de puntos pero no trabajará en un espacio euclidiano, corresponderá con el camino más corto entre todos los caminos posibles para conectar dos puntos en el colector. Un ejemplo de uso común puede ser el algoritmo Djkstra, muy común en el cálculo de la navegación por carretera.

(3)

En este último paso aplicaremos un MDS (escalado multidimensional) a la matriz de distancia de las geodésicas para reconstruirlo en un espacio euclidiano que mantendrá la misma estructura geométrica. Los vectores de coordenadas en el espacio euclidiano se eligen para minimizar la siguiente función de costo:

  • Dy corresponde a las matriz de las distancias Euclidee
  • L2 corresponde a la raíz cuadrada de la suma de los elementos
  • τ no es más que una función de conversión (las distancias se reemplazan en productos internos) para utilizar algoritmos de optimización eficientes

 

 

Implementémoslo en Python:

En primer lugar, importamos los paquetes necesarios de  scikit-learn


import numpy as np

import matplotlib.pyplot as plt

from sklearn import manifold

 

entonces:

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

 

Analicemos los parámetros principales:
• n_ neighbors = Número entero, que corresponde al número de vecinos
• n_ components = Integer, generalmente establecido de manera predeterminada en 2. Corresponde al número de coordenadas en el espacio del Colector
• path_method = default ‘auto’, FW para Floyd-Warshall, D para el algoritmo Djkstra establece cómo calcular las distancias en el gráfico

Si queremos ir a imprimir un gráfico con los tiempos de ejecución relativos:

 

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

Hacemos dos últimas consideraciones de uso práctico:

ISOMAP resulta ser una herramienta de reducción muy efectiva que nos permite eludir muchos problemas relacionados con la linealidad, pero es capaz de preservar una estructura geométrica local naturalmente es a expensas de algunos factores, en particular:
• Sensible a outliers
• Pocos parámetros libres

Esto se debe a que la funcionalidad del algoritmo depende principalmente de la elección de algunos parámetros (la elección del número de vecinos), de hecho, incluso unos pocos valores atípicos pueden, de alguna manera, reunir porciones de datos que de otra manera deberían ser discriminados.
Por este motivo, ISOMAP es muy recomendable cuando ya tenemos algunas ideas sobre la estructura de datos porque, comparado con otros métodos lineales, es computacionalmente más intensivo.

En el próximo tutorial abordaremos LLE, el segundo de nuestros métodos basados en Manifold.

 

Referencias
• http://scikit-learn.org/stable/index.html (Official Website of Scikit libraries)
• http://web.mit.edu/cocosci/Papers/sci_reprint.pdf (documentazione su ISOMAP)