Haciendo un proyecto con scalatra y spark

Vamos a hacer un proyecto en Scala con Scalatra y Spark. La idea es hacer una Api Rest, la cual utilice Spark.

Lo primero que hacemos es el proyecto de scalatra como esta indicado aquí :
https://emanuelpeg.blogspot.com/2018/08/haciendo-un-proyecto-con-scalatra.html

Ya teniendo este proyecto agregamos las dependencias de spark y de jersey (este ultimo es necesario para el funcionamiento de los frameworks)

Es decir el buil.sbt nos va quedar así:

val ScalatraVersion = "2.6.3"

organization := "com.hexacta"

name := "Sparklatra"

version := "0.1.0-SNAPSHOT"

scalaVersion := "2.11.0"

resolvers += Classpaths.typesafeReleases

libraryDependencies ++= Seq(
  "org.scalatra" %% "scalatra" % ScalatraVersion  ,
  "org.scalatra" %% "scalatra-scalatest" % ScalatraVersion % "test" ,
  "ch.qos.logback" % "logback-classic" % "1.2.3" % "runtime" ,
  "org.eclipse.jetty" % "jetty-webapp" % "9.4.9.v20180320" % "container" ,
  "javax.servlet" % "javax.servlet-api" % "3.1.0" % "provided"  ,
  "com.sun.jersey" % "jersey-core" % "1.19.4" ,
  "com.sun.jersey" % "jersey-server" % "1.19.4" ,
  "org.apache.spark" %% "spark-core" % "2.3.1"
)

enablePlugins(SbtTwirl)
enablePlugins(ScalatraPlugin)

Luego de agregar estas dependencias vamos a hacer un objeto que contenga el contexto de Spark, dado que queremos utilizar un contexto en toda nuestra aplicación y lo hacemos de la siguiente manera :

package com.miEmpresa

import org.apache.spark.{SparkConf, SparkContext}

object SparkContext {

  //Create a SparkContext to initialize Spark
  val conf = new SparkConf()
  conf.setMaster("local")
  conf.setAppName("Word Count")
  val sc = new SparkContext(conf)

   def getSc = {
      sc
   }
}

Luego de hacer esto, vamos a servlet de scalatra y agregamos el método get que cuente palabras pasadas como parámetro en la url :

   get(s"/contar/:str") {

    //word count
    val counts = List({
      params("str")
    }).flatMap(line => line.split(" "))
      .map(word => (word, 1))

    val countsRdd = SparkContext.getSc.parallelize(counts).reduceByKey(_ + _).collect()

    var result = ListBuffer[(String,Int)]()

    countsRdd.foreach(line => result += line)

    Ok(compact(render(result)))

  }

En el get definimos que la url va a contener un string que es nuestro parámetro str. Luego hacemos un split por espacios en blanco y luego hacemos un mapa (palabra, 1).  Como ultimo paso convertimos nuestro map a RDD y reducimos por palabra. Es decir el proceso sería para la linea "hola hola mundo" de la siguiente manera :

 "hola hola mundo" -> split(" ") = ("hola","hola","mundo") -> map = ( ("hola", 1) , ("hola", 1) , ("mundo", 1) ) -> reduceByKey = ("hola",2), ("mundo",1)

Para probarlo primero debemos ejecutarlo con sbt y jetty. Vamos al directorio donde se encuentra el archivo build.sbt y escribimos:
sbt
--- Acá va correr un montón de cosas ---
jetty:start

Por ultimo, debemos ir a un browser y probar la url : http://localhost:8080/contar/

Como se envían los datos por el método get podemos probar con la siguiente url, por ejemplo:

"http://localhost:8080/contar/hola hola hola Mundo"

Y listo!!

3 eBooks sobre Reactive Microservices con Java

Me llego un mail de lightbend que están regalando 3 ebooks sobre Reactive en Java. Nada, solo hay que bajarlo.

Dejo link: http://inform.lightbend.com/Xlk0yJC0l000Xz02f02aNN0

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

Haciendo un proyecto con scalatra

Scalatra es el Sinatra de scala.

Para el que no conoce Sinatra es un framework que permite hacer paginas web con las menores configuraciones y desarrollo posible. Trata de acelerar el desarrollo manteniendo un modelo simple y convención antes de configuración.  Y el mismo espíritu tiene Scalatra.

Vamos hacer un proyecto con sbt.

Vamos a la consola y hacemos:

sbt new scalatra/scalatra.g8

Luego nos va pedir un montón de datos, pero es fácil saber a que se refiere dado que presenta unos ejemplos.

Y con eso ya estamos, podemos ejecutar esto con el comando :

sbt jetty:start

Y podemos chequearlo en la url: http://localhost:8080/

Como funciona?

La clase MyScalatraServlet capta el método get / y responde con la vista.

import org.scalatra._

class MyScalatraServlet extends ScalatraServlet {

  get("/") {
    views.html.hello()
  }

}

Dejo link: http://scalatra.org/

¿Cuál es la diferencia entre SQL, NoSQL y NewSQL?

Me llego este mail de la gente de VoltDB, sobre un paper que trata sobre las diferencias entre SQL, NoSQL y NewSQL. Y como es costumbre quiero compartirlo con ustedes :

Hi Emanuel, Database technologies have come a long way since the 1980's. First there was SQL. Then along came NoSQL. And over the last decade, we’ve seen the emergence of NewSQL. Each database offers their own unique benefits, but are you aware of their drawbacks? In this white paper, we compare the differences between SQL vs. NoSQL vs. NewSQL databases and explore topics, including: The basics of NoSQL The promise of NewSQL 4 use cases where NoSQL databases fall short And more VoltDB 209 Burlington Rd. #203 MA Bedford You received this email because you are subscribed to emails from VoltDB Update your email preferences to choose the types of emails you receive. Unsubscribe from all future emails

Ejemplo con Java y Spark

Vamos hacer un pequeño ejemplo, una aplicación Java que utilice Spark para contar palabras. La aplicación calculara cuantas veces aparece una palabra en un archivo de texto.

Para hacer esto vamos a utilizar eclipse y maven.

Primero creamos un proyecto simple de maven, para lo cual podemos utilizar la consola, con el siguiente comando:

mvn archetype:generate
-DarchetypeGroupId=org.apache.maven.archetypes
-DarchetypeArtifactId=maven-archetype-quickstart
-DarchetypeVersion=RELEASE
-DgroupId=org.miOrganizacion
-DartifactId=nombreDelProyecto

o con eclipse, vamos a File -> New -> Project -> Maven -> Maven Project y luego elegimos es arquetipo "maven-archetype-quickstart" y luego completamos los campos groupId y artifactId. Y listo!

Ahora vamos agregar spark en las dependencias en el pom.xml :

  <dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.11</artifactId>
<version>2.2.1</version>
</dependency>

Y vamos a indicarle que utilizaremos java 8 con la siguiente lineas :

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>

El pom.xml queda de la siguiente manera:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.hexacta</groupId>
<artifactId>testSpark</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>testSpark</name>
<url>http://maven.apache.org</url>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>

<dependencies>

<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.11</artifactId>
<version>2.2.1</version>
</dependency>


<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>


</dependencies>
</project>

Y ahora, a programa!!.

Vamos hacer el ejemplo de contar palabras de un archivo de texto. Para lo cual haremos un objeto llamado "App.java" : 

package com.hexacta.testSpark;

import java.util.Arrays;

import org.apache.spark.api.java.JavaPairRDD;

import org.apache.spark.api.java.JavaSparkContext;

import org.apache.spark.api.java.JavaRDD;

import org.apache.spark.SparkConf;

import scala.Tuple2;

public class App {

public static void main(String[] args) {

// Create a SparkContext to initialize

SparkConf conf = new SparkConf().setMaster("local").setAppName("Word Count");

// Create a Java version of the Spark Context

JavaSparkContext sc = new JavaSparkContext(conf);

// Load the text into a Spark RDD, which is a distributed representation of each

// line of text

JavaRDD<String> textFile = sc.textFile("/java/spark/artists.csv");

JavaPairRDD<String, Integer> counts = textFile

                                .flatMap(s -> Arrays.asList(s.split("[ ,]")).iterator())

.mapToPair(word -> new Tuple2<>(word, 1)).reduceByKey((a, b) -> a + b);

counts.foreach(p -> System.out.println(p));

System.out.println("Total words: " + counts.count());

counts.saveAsTextFile("/java/spark/artistsCount.txt");

}

}

Dejo el repo git :
https://github.com/emanuelpeg/client-java-spark

Ejemplo con Scala y Spark

Vamos hacer un pequeño ejemplo, una aplicación Scala que utilice Spark para contar palabras. La aplicación calculara cuantas veces aparece una palabra en un archivo de texto.

Para hacer esto vamos a utilizar Intellij Idea. Primero vamos a bajar intellij idea community edition porque somos muy pobres.

Luego instalamos el plugin de Scala. Eso lo hacemos yendo a file->settings->plugins y ahí instalamos  el plugin de scala :

Luego debemos hacer un nuevo proyecto, vamos a elegir un proyecto sbt :

Luego agregamos esta dependencia en el archivo build.sbt :

libraryDependencies ++= {
  val sparkVer = "2.1.0"
  Seq(
    "org.apache.spark" %% "spark-core" % sparkVer
  )
}

Quedando de la siguiente manera :

name := "cliente-spark-scala"

version := "0.1"

scalaVersion := "2.11.0"

libraryDependencies ++= {
  val sparkVer = "2.1.0"
  Seq(
    "org.apache.spark" %% "spark-core" % sparkVer
  )
}

Luego de cambiar este archivo el IDE nos preguntará si importa las librerías o siempre importa las librerías. En este caso, elegimos cualquiera de los dos :

Y ahora, a programa!!.

Vamos hacer el ejemplo de contar palabras de un archivo de texto. Para lo cual haremos un objeto llamado "ScalaExample" :

object ScalaExample {

  import org.apache.spark.{SparkConf, SparkContext}

  def main(args: Array[String]): Unit = {
    //Create a SparkContext to initialize Spark
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("Word Count")
    val sc = new SparkContext(conf)

    // Load the text into a Spark RDD, which is a distributed representation of each line of text
    val textFile = sc.textFile("/java/spark/customers.txt")

    //word count
    val counts = textFile.flatMap(line => line.split(" "))
      .map(word => (word, 1))
      .reduceByKey(_ + _)

    counts.foreach(println)
    System.out.println("Total words: " + counts.count());
   // counts.saveAsTextFile("/java/spark/customersCount.txt");
  }

}

Dejo el repo git : 

https://github.com/emanuelpeg/exampleSparkScala

Cursos Gugler

Quiero recomendarles los siguientes cursos:

Crystal v0.26.0 fue liberado !!

Crystal es un lenguaje que tiene muchísimo futuro y en mi opinión es el lenguaje orientado a objeto de tipado estático mejor diseñado.

Es simple y la inferencia de tipos lo hace fácil de usar y al ser de tipado estático es muy rápido. 

Esta es su versión 0.26.0 y sigue creciendo. 

Lo único que a mi modo de ver las cosas debería hacer es correr en una plataforma donde pueda reutilizar frameworks como dot net core o java. Eso le daría una popularidad increíble.

Sin más espero que siga creciendo este gran lenguaje.

Dejo link:
https://crystal-lang.org/
https://github.com/crystal-lang/crystal/blob/master/CHANGELOG.md

5 cursos gratuitos de estructura de datos y algoritmos en Java y C

Si queremos aprender una tecnología nueva lo mejor es empezar por un libro o un curso y luego ir a tutoriales de internet. Saltar de tutorial en tutorial, nos da el conocimiento pero nos falta el orden. Con un curso o un libro aprendemos ordenadamente, como debe ser.

Por lo tanto dejo 5 cursos gratuitos de estructura de datos y algoritmos en Java y C :

• Data Structures & Algorithms with Java - Interview !!
• Data Structures Concepts in C
• Algorithms and Data Structures - Part 1
• Algorithms and Data Structures - Part 2
• Data Structure in Java

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

Procesamiento de lenguaje natural con NLTK

NLTK es una plataforma líder para construir programas en Python para trabajar con datos de lenguaje natural.

Proporciona interfaces fáciles de usar a más de 50 recursos corporales y léxicos como WordNet, junto con un conjunto de bibliotecas de procesamiento de texto para clasificación, tokenización, derivación, etiquetado, análisis y razonamiento semántico, wrappers para bibliotecas de PNL.

NLTK es adecuado para lingüistas, ingenieros, estudiantes, educadores, investigadores y usuarios de la industria por igual. NLTK está disponible para Windows, Mac OS X y Linux. Lo mejor de todo es que NLTK es un proyecto gratuito, de código abierto, impulsado por la comunidad.

NLTK ha sido llamado "una herramienta maravillosa para enseñar y trabajar en lingüística computacional usando Python" y "una biblioteca increíble para jugar con el lenguaje natural".

Veamos unos ejemplos de lo que podemos hacer con nltk:

Tokenizar y etiquetar un texto:

>>> import nltk
>>> sentence = """At eight o'clock on Thursday morning
... Arthur didn't feel very good."""
>>> tokens = nltk.word_tokenize(sentence)
>>> tokens
['At', 'eight', "o'clock", 'on', 'Thursday', 'morning',
'Arthur', 'did', "n't", 'feel', 'very', 'good', '.']
>>> tagged = nltk.pos_tag(tokens)
>>> tagged[0:6]
[('At', 'IN'), ('eight', 'CD'), ("o'clock", 'JJ'), ('on', 'IN'),
('Thursday', 'NNP'), ('morning', 'NN')]

Identificar entidades:

>>> entities = nltk.chunk.ne_chunk(tagged)

>>> entities

Tree('S', [('At', 'IN'), ('eight', 'CD'), ("o'clock", 'JJ'),

           ('on', 'IN'), ('Thursday', 'NNP'), ('morning', 'NN'),

       Tree('PERSON', [('Arthur', 'NNP')]),

           ('did', 'VBD'), ("n't", 'RB'), ('feel', 'VB'),

           ('very', 'RB'), ('good', 'JJ'), ('.', '.')])

Mostrar un árbol de análisis sintáctico:

>>> from nltk.corpus import treebank

>>> t = treebank.parsed_sents('wsj_0001.mrg')[0]

>>> t.draw()

Como estoy usando nltk 3, debo usar python 3. Otra cosa importante tienen que tener instalado python3-tk.

Ojo que si quieren probar estos ejemplos deben hacer :

>>> nltk.download()

Y ahí tienen que bajar los paquetes. 

Tenemos un libro gratuito y online: http://www.nltk.org/book/

Dejo link:
https://www.nltk.org/

5 Cursos de Spring Gratuitos

Si queremos aprender una tecnología nueva lo mejor es empezar por un libro o un curso y luego ir a tutoriales de internet. Saltar de tutorial en tutorial, nos da el conocimiento pero nos falta el orden. Con un curso o un libro aprendemos ordenadamente, como debe ser.

Por lo tanto dejo 5 cursos gratuitos para todos los que quieran empezar con Spring :

• Spring Framework And Dependency Injection For Beginners
• Introducing Spring Boot
• Spring Fundamentals
• Introduction to Spring MVC 4
• Spring & Hibernate for Beginner 

Un ejemplo utilizando Apache Spark Streaming

Lo que vamos a hacer es un proceso que escuche lo que escribimos con "nc" en el puerto 9999. Y luego vamos a contar, es decir vamos a contar las palabras.

Iniciamos spark-shell :

./spark-shell

Luego debemos importar todos los objetos para hacer streaming:

import org.apache.spark._
import org.apache.spark.streaming._
import org.apache.spark.streaming.StreamingContext._

//Ahora hacemos el contexto de streaming, utilizando el contexto de mi aplicación. A la vez //especificamos el periodo de tiempo que se debe procesar los datos:

val ssc = new StreamingContext(sc, Seconds(10))

// Creamos el DStream para localhost:9999
val lines = ssc.socketTextStream("localhost", 9999)

// indicamos las tareas a realizar con los datos.
val words = lines.flatMap(_.split(" "))
val pairs = words.map(word => (word, 1))

val wordCounts = pairs.reduceByKey(_ + _)

// Imprima los primeros elementos de cada RDD generado en este DStream para la consola

wordCounts.print()

ssc.start()             // comenzamos
ssc.awaitTermination()  // Espere a que termine el cálculo

Y listo, ahora si vamos a otra consola y escribimos :

nc -lk 9999

Este comando va a escribir lo escribimos en el puerto 9999 y nuestra aplicación va a leerlo y contarlo.

Y eso es todo!!!

5 Cursos de Angular Gratuitos

Si queremos aprender una tecnología nueva lo mejor es empezar por un libro o un curso y luego ir a tutoriales de internet. Saltar de tutorial en tutorial, nos da el conocimiento pero nos falta el orden. Con un curso o un libro aprendemos ordenadamente, como debe ser.

Por lo tanto dejo 5 cursos gratuitos para todos los que quieran empezar con Angular :

• Learn Angular 5 from Scratch y Learn Angular 4 from Scratch
• Getting Started with Angular 2+
• Angular: Getting Started
• Angular Fundamentals
• AngularJS Authentication: Secure Your App with Auth0