Java o Python para procesamiento de lenguaje natural?

Podríamos afirmar que en Java y Python son los lenguajes que tienen mayor éxito en la ciencia. Tal vez Python aventaje a Java, pero por muy poco.

Para procesamiento de lenguaje natural (NLP)  existen muchísimas librerías y como es de esperar una gran cantidad en Pyhton y Java.

Además de NLTK (www.nltk.org), que es la librería lider en NLP hay otras librerías para el procesamiento de texto en Python:

• TextBlob: http://textblob.readthedocs.org/en/dev/
• Gensim: http://radimrehurek.com/gensim/
• Pattern: http://www.clips.ua.ac.be/pattern
• Spacy:: http://spacy.io
• Orange: http://orange.biolab.si/features/
• Pineapple: https://github.com/proycon/pynlpl

Para Java, hay otras muchas:

• Freeling: http://nlp.lsi.upc.edu/freeling/
• OpenNLP: http://opennlp.apache.org/
• LingPipe: http://alias-i.com/lingpipe/
• Stanford CoreNLP: http://stanfordnlp.github.io/CoreNLP/ 
• CogComp NLP: https://github.com/CogComp/cogcomp-nlp

Si podemos elegir el lenguaje, usaremos el que nos sintamos más cómodos. En el tema de performance java en un poco más rápido pero los científicos eligen Python por su simpleza y su capacidad de hacer mucho escribiendo poco.

Tal vez además de las herramientas de procesamiento de lenguaje, necesitaría herramientas de aprendizaje automático para incorporar. Existe un amplio rango en Python y Java, y una vez más depende de las preferencias y si las bibliotecas son lo suficientemente amigables para el usuario:

Bibliotecas de Machine Learning en python:

• Sklearn (Scikit-learn): http://scikit-learn.org/stable/
• Milk: http://luispedro.org/software/milk
• Scipy: http://www.scipy.org/
• Theano: http://deeplearning.net/software/theano/
• PyML: http://pyml.sourceforge.net/
• pyBrain: http://pybrain.org/
• Graphlab Create (Commerical tool but free academic license for 1 year): https://dato.com/products/create/

Y en java

• Weka: http://www.cs.waikato.ac.nz/ml/weka/index.html
• Mallet: http://mallet.cs.umass.edu/
• Mahout: https://mahout.apache.org/

Además tenemos Spark MLlib que funciona con Python, Java y Scala. 

Si están interesados en otros lenguajes o simplemente leer : 

• Machine Learning and Natural Language Processing
• What are good starting points for someone interested in natural language processing?
• Natural language processing
• Natural Language Processing in Java (NLP)
• Is there a good natural language processing library
• Simple Natural Language Processing Startup for Java
• What libraries offer basic or advanced NLP methods?
• Latest good languages and books for Natural Language Processing, the basics
• (For NER) Entity Extraction/Recognition with free tools while feeding Lucene Index
• (With PHP) NLP programming tools using PHP?
• (With Ruby) https://stackoverflow.com/questions/3776361/ruby-nlp-libraries

Data Science and Cognitive Computing Courses

Quiero compartir la siguiente página que permite hacer cursos de machine learning, Apache Spark, SQL, Python, R, Data science, Reactive, Scala, Big Data, etc...

Y todos de forma gratuita!

Dejo link: https://cognitiveclass.ai

Apache Spark MLlib parte 4

Continuamos!!!

Vamos a ver un ejemplo utilizando el algoritmo Kmeans que es uno de los algoritmos más fáciles de clasificación.

K-means es un método de agrupamiento, que tiene como objetivo la partición de un conjunto de n observaciones en k grupos en el que cada observación pertenece al grupo cuyo valor medio es más cercano.

Si bien se puede indicar que es una técnica utilizada por minería de datos más que para Maching learning, vamos a empezar de a poco.

Empecemos viendo los datos, los cuales supongamos ya hemos limpiado :

0 1:0.0 2:0.0 3:0.0
1 1:0.1 2:0.1 3:0.1
2 1:0.2 2:0.2 3:0.2
3 1:9.0 2:9.0 3:9.0
4 1:9.1 2:9.1 3:9.1
5 1:9.2 2:9.2 3:9.2

Como se puede ver son 4 columnas, de la cuales la primera es un id (identificador) y las demás están compuestas por un indice y un dato, por ejemplo 1:0.0 (el indice es 1 y el dato 0.0 el cual es continuo)

Esto se encuentra en el archivo sample_kmeans_data.txt

Empecemos tomando los datos y llevándolos a un RDD :

//creamos la aplicación de spark si utilizamos spark-shell esto no es necesario.
val spark = SparkSession.builder.appName("KMeansExample") .getOrCreate()

//Leemos el archivo con el formato libsvm
val dataset = spark.read.format("libsvm").load("path/sample_kmeans_data.txt")

//Probamos que se leyeron los datos, si estamos en spark-shell
dataset.show()
+-----+--------------------+
|label|            features|
+-----+--------------------+
|  0.0|           (3,[],[])|
|  1.0|(3,[0,1,2],[0.1,0...|
|  2.0|(3,[0,1,2],[0.2,0...|
|  3.0|(3,[0,1,2],[9.0,9...|
|  4.0|(3,[0,1,2],[9.1,9...|
|  5.0|(3,[0,1,2],[9.2,9...|
+-----+--------------------+

// Entrenamos nuestro modelo

import org.apache.spark.ml.clustering.KMeans

val kmeans = new KMeans().setK(2).setSeed(1L)
val model = kmeans.fit(dataset)

// Evaluamos la agrupación mediante el cómputo dentro de la suma establecida de errores cuadrados.
val WSSSE = model.computeCost(dataset)
println(s"Within Set Sum of Squared Errors = $WSSSE")

// Mostramos el resultado
println("Cluster Centers: ")
model.clusterCenters.foreach(println)
[0.1,0.1,0.1]
[9.1,9.1,9.1]

Para los que como yo no entendieron que paso el ultimo momento... Reiteramos!

Dado un conjunto de observaciones (x1, x2, …, xn), donde cada observación es un vector real de d dimensiones, k-means construye una partición de las observaciones en k conjuntos (k ≤ n) a fin de minimizar la suma de los cuadrados dentro de cada grupo (WCSS): S = {S1, S2, …, Sk}

Si vemos la Wikipedia : 

Paso de asignación: Asigna cada observación al grupo con la media más cercana (es decir, la partición de las observaciones de acuerdo con el diagrama de Voronoi generado por los centroides).

${\displaystyle S_{i}^{(t)}={\big \{}x_{p}:{\big \|}x_{p}-m_{i}^{(t)}{\big \|}\leq {\big \|}x_{p}-m_{j}^{(t)}{\big \|}\ \forall \ 1\leq j\leq k{\big \}}}$

Donde cada ${\displaystyle x_{p}}$ va exactamente dentro de un ${\displaystyle S_{i}^{(t)}}$, incluso aunque pudiera ir en dos de ellos.

Paso de actualización: Calcular los nuevos centroides como el centroide de las observaciones en el grupo.

${\displaystyle \mathbf {m} _{i}^{(t+1)}={\frac {1}{|S_{i}^{(t)}|}}\sum _{\mathbf {x} _{j}\in S_{i}^{(t)}}\mathbf {x} _{j}}$

El algoritmo se considera que ha convergido cuando las asignaciones ya no cambian.

Grafícado : 

• Demostración del algoritmos estándar
• 

  1) k centroides iniciales (en este caso k=3) son generados aleatoriamente dentro de un conjunto de datos (mostrados en color).
 
• 

  2) k grupos son generados asociándole el punto con la media más cercana. La partición aquí representa el diagrama de Voronoi generado por los centroides.
 
• 

  3) EL centroide de cada uno de los k grupos se recalcula.
 
• 

  4) Pasos 2 y 3 se repiten hasta que se logre la convergencia.

Si hablamos en criollo el algoritmo trata de hacer grupos y calcular su centro, y va moviendo el centro según los datos hasta que estos centros no cambian y ahí finaliza.

Apache Spark MLlib parte 3

Continuamos...


La detección de fraude es otro caso de uso importante del aprendizaje automático. Aborda un problema crítico en la industria financiera de forma rápida y precisa.

Las organizaciones de servicios financieros solo tienen unos cientos de milisegundos para determinar si una transacción en línea en particular es legítima o es un fraude.

Las técnicas de redes neuronales se utilizan para la detección de fraudes en puntos de venta (POS). Las organizaciones como PayPal utilizan diferentes tipos de algoritmos de aprendizaje automático para la gestión de riesgos, como la red lineal, neuronal y el aprendizaje profundo.

La biblioteca Spark MLlib proporciona varios algoritmos para resolver este caso de uso, incluidos SVM lineales, regresión logística, árboles de decisión y Bayes sencillos. Los modelos de conjunto (que combinan las predicciones de un conjunto de modelos) como los bosques aleatorios o los árboles que aumentan el gradiente también están disponibles …

MLlib es la biblioteca de aprendizaje automático de Spark. Su objetivo es hacer que el aprendizaje automático práctico sea escalable y fácil. Consiste en algoritmos y utilidades de aprendizaje comunes, que incluyen clasificación, regresión, clustering, filtrado colaborativo, reducción de dimensionalidad y primitivas de optimización de nivel inferior y API de canalizaciones de nivel superior.

Como aprendimos anteriormente, hay dos formas de utilizar la API de Aprendizaje Automático de Spark: Spark MLlib y spark.ml.

La API Spark MLlib está disponible en los lenguajes de programación Scala, Java y Python.

Continuara...

Apache Spark MLlib parte 2

 Continuamos!!

Cuando se trabaja en proyectos de aprendizaje automático la preparación de datos, la limpieza y el análisis, también son tareas importantes más allá de los modelos de aprendizaje reales y los algoritmos utilizados para resolver los problemas de negocios.

Los siguientes son los pasos que se realizan en un programa típico de aprendizaje automático:

Caracterización (featurization) del modelo.

entrenar el modelo.

evaluación modelo.

Es importante saber que se debe limpiar y preparar los datos antes de ejecutar un algoritmo de aprendizaje automático, de lo contrario el patrón resultante no será preciso ni útil, y puede pasar por alto algunas anomalías.

La calidad de los datos de entrenamiento que proporcionamos a los programas de aprendizaje automático también juega un papel fundamental en los resultados de predicción. Si los datos de entrenamiento no son lo suficientemente aleatorios, los patrones resultantes no serán precisos. Y si el conjunto de datos es demasiado pequeño, el programa de aprendizaje automático puede dar predicciones inexactas.

Los casos de uso comerciales para aprendizaje automático abarcan diferentes dominios y escenarios, incluidos motores de recomendación (como este motor de recomendación de alimentos), análisis predictivo (por ejemplo, predicción de precios de acciones o retrasos en los vuelos), publicidad dirigida, detección de fraude, reconocimiento de imágenes y videos -conducir automóviles y otras formas de inteligencia artificial.

Veamos dos aplicaciones populares, un motor de recomendación y detección de fraude, en más detalle.

Los motores de recomendación utilizan los atributos de un elemento o un usuario o el comportamiento de un usuario o sus compañeros para hacer predicciones. Diferentes factores impulsan un motor de recomendación eficaz. Algunos de estos factores incluyen:

• análisis por pares.
• comportamiento del cliente.
• ofertas u ofertas corporativas.
• agrupamiento de elementos.
• factores de mercado / tienda.

Podemos construir un motor de recomendación mediante la participación de dos algoritmos: filtrado basado en contenido y filtrado colaborativo.

El filtrado basado en contenido se basa en cuán similares son el uso y las calificaciones de un artículo en particular a otros artículos. El modelo usa los atributos de contenido de los elementos (como categorías, etiquetas, descripciones y otros datos) para generar una matriz que relacione cada elemento con otros elementos y calcule la similitud en función de las clasificaciones proporcionadas. Luego, los elementos más similares se enumeran junto con un puntaje de similitud. Los artículos con el puntaje más alto son los más similares.

La recomendación de la película es un buen ejemplo de este modelo. Puede aconsejar que a los usuarios a los que les haya gustado una película en particular también les hayan gustado estas otras películas.

El filtrado basado en contenido no tiene en cuenta el comportamiento general de otros usuarios, por lo que sus modelos no ofrecen recomendaciones personalizadas, como el filtrado colaborativo y otros modelos.

Por otro lado, los modelos de filtrado colaborativo predicen y recomiendan elementos específicos o usuarios en función de la similitud con otros elementos o usuarios.

El filtro aplica ponderaciones basadas en las preferencias del "usuario par". La suposición es que los usuarios con perfiles o comportamientos similares también tendrán preferencias de elementos similares.

Un ejemplo de este modelo son las recomendaciones sobre sitios web de comercio electrónico como Amazon. Cuando buscamos un artículo en el sitio web, vemos una lista llamada "Los clientes que vieron este artículo también compraron".

Los elementos con el puntaje de recomendación más alto son los más relevantes para el usuario en contexto.

Las soluciones de filtrado colaborativo funcionan mejor que otros modelos. Spark MLlib implementa un algoritmo de filtrado colaborativo llamado Alternating least squares (ALS). Hay dos variaciones de las entradas en el filtrado colaborativo, llamadas realimentación explícita e implícita.

La retroalimentación explícita se basa en las preferencias directas otorgadas por el usuario al elemento (como una película). La retroalimentación explícita es agradable, pero muchas veces es sesgada porque los usuarios a quienes les gusta o no les gusta mucho un producto tienden a opinar con más frecuencia que los que les es indiferente. Por lo tanto podemos no obtener la opinión de muchas personas en el centro de la curva.

La retroalimentación implícita incluye las vistas del usuario, los clics, los "me gusta", etc. La retroalimentación implícita a menudo se utiliza para el análisis predictivo debido a lo fácil que es recopilar este tipo de datos.

También hay métodos basados en modelos para motores de recomendación. A menudo incorporan métodos de filtrado colaborativo y basado en contenido. Un enfoque basado en modelos obtiene lo mejor de ambos mundos: el poder y el rendimiento del filtrado colaborativo y la flexibilidad y adaptabilidad del filtrado basado en el contenido. Las técnicas de aprendizaje profundo o deep learning son buenos ejemplos de este modelo.

También puede integrar otros algoritmos como k-means clustering en el motor de recomendación para refinar aún más las predicciones. El algoritmo k-means funciona al dividir N observaciones en k clústeres en los que cada observación pertenece al clúster con la media más cercana. Usando la técnica de k-means, podemos encontrar elementos similares o usuarios en función de sus atributos.

Como deben adivinar:

continuará...

Apache Spark MLlib

Apache Spark Mllib incluye diferentes algoritmos de Machine Learning. Estas librerías se encuentran en 2 paquetes : spark.mllib  y  spark.ml

spark.mllib contiene la API original de spark construida sobre RDDs. Estos algoritmos incluyen correlación, clasificación y regresión, filtrado colaborativo, clustering y reducción de dimensionalidad.

spark.ml contiene la API construida sobre Dataframes, el cual es el core de Spark SQL. Esto puede ser utilizado para hacer una tubería de maching learning, es decir combinar técnicas o limpiar los datos y luego procesarlos. Este paquete provee: selectores, transformadores, extractores y técnicas de maching learning como clasificación, regresión y clustering.

La ciencia de datos o Data science es la disciplina que extraer el conocimiento de grandes conjuntos de datos (estructurados o no estructurados) para proporcionar información a los equipos de negocios e influir en las estrategias comerciales. El papel del científico de datos es resolver problemas que no son fáciles de resolver utilizando los métodos numéricos tradicionales. Normalmente estos cientificos de datos utilizan modelos de aprendizaje automático.

Existen diferentes tipos de modelos de aprendizaje automático:

• aprendizaje supervisado,
• aprendizaje sin supervisión,
• aprendizaje semi-supervisado
• aprendizaje reforzado.

Entre los algoritmos soportados por Spark MLlib y utilizados por los científicos de datos, podemos nombrar:

• Naive Bayes es un algoritmo de aprendizaje supervisado utilizado para la clasificación. Se basa en la aplicación del teorema de Bayes y un conjunto de suposiciones de independencia condicional.
• El algoritmo k-means o k-means clustering crea k grupos a partir de un conjunto de objetos para que los miembros de cada grupo sean más similares entre sí.
• Una máquina de vectores de soporte (SVM) es un algoritmo de aprendizaje supervisado que se utiliza para encontrar el límite que separa las clases por un margen tan amplio como sea posible. Dado un conjunto de ejemplos de entrenamiento, cada uno marcado como perteneciente a una de dos categorías, un algoritmo de entrenamiento SVM construye un modelo que asigna nuevos ejemplos en una categoría u otra. Las aplicaciones de SVM incluyen bioinformática, análisis de texto y reconocimiento de imágenes.
• Los árboles de decisión se utilizan en muchos tipos de problemas de aprendizaje automático, incluida la clasificación multiclase. Spark MLlib es compatible tanto con un algoritmo de árbol de decisión básico como con conjuntos de árboles. Hay dos algoritmos de conjunto disponibles: árboles con gradiente mejorado y bosques aleatorios.

Como una primer vistazo, esta bien hasta aquí, pero debemos seguir en próximos posts, es decir : 

continuará...