Translate

domingo, 2 de septiembre de 2018

5 librerías de machine learning para Java



El aprendizaje automático o machine learning esta en la cresta de la ola, por lo tanto vamos a nombrar 5 librerías o frameworks para machine learning en Java.

Weka : Weka 3 es un framework de trabajo totalmente basado en Java que se utiliza para aprendizaje automático. Weka se utiliza principalmente para la extracción de datos, el análisis de datos y el modelado predictivo. Es completamente gratuito, portátil y fácil de usar con su interfaz gráfica.
La fuerza de Weka radica en la clasificación, por lo que las aplicaciones que requieren clasificación automática de datos pueden beneficiarse de ella, pero también admite clustering, minería de reglas de asociación, predicción de series de tiempo, selección de características y detección de anomalías.

Massive Online Analysis (MOA) : MOA es un software de código abierto utilizado específicamente para el aprendizaje automático y la minería de datos en flujos de datos en tiempo real. Desarrollado en Java, también se puede usar fácilmente con Weka mientras escala a problemas más exigentes. La colección de MOA de algoritmos de aprendizaje automático y herramientas para la evaluación son útiles para la regresión, clasificación, detección de valores atípicos, clustering, sistemas de recomendación y detección de deriva de conceptos. MOA puede ser útil para grandes conjuntos de datos en evolución y flujos de datos, así como también para los datos producidos por los dispositivos del Internet of Things (IoT). MOA está específicamente diseñado para el aprendizaje automático en flujos de datos en tiempo real. Su objetivo es el procesamiento eficiente en tiempo y memoria. MOA proporciona un marco de referencia para ejecutar experimentos en el campo de minería de datos al proporcionar varias funciones útiles, que incluyen un marco fácilmente extensible para nuevos algoritmos, flujos y métodos de evaluación; configuraciones almacenables para flujos de datos (reales y sintéticos) para experimentos repetibles; y un conjunto de algoritmos y medidas existentes de la literatura para comparación.

Deeplearning4j : Deeplearning4j es una librería de deep-learning distribuida, de código abierto y esta programado en Java y Scala. Su misión es reunir redes neuronales profundas y aprendizaje de refuerzo profundo para entornos empresariales. Deeplearning4j está destinado a servir como herramienta de bricolaje para los programadores Java, Scala y Clojure que trabajan en Hadoop. Las redes neuronales profundas y el aprendizaje de refuerzo profundo son capaces de reconocimiento de patrones y aprendizaje automático orientado a objetivos. Todo esto significa que Deeplearning4j es muy útil para identificar patrones. Además, puede usarse para detectar anomalías en datos de series de tiempo como transacciones financieras.

MALLET : MALLET es un conjunto de herramientas de código abierto Java para aprendizaje automático de lenguaje a texto. Este paquete basado en Java admite el procesamiento estadístico de lenguaje natural, clustering, clasificación de documentos, extracción de información, modelado de temas y otras aplicaciones de aprendizaje automático para texto. La especialidad de MALLET incluye herramientas sofisticadas para la clasificación de documentos, tales como rutinas eficientes para la conversión de texto. Admite una amplia variedad de algoritmos (incluidos Naïve Bayes, Decision Trees y Maximum Entropy) y un código para evaluar el rendimiento de la clase. Además, MALLET incluye herramientas para el etiquetado de secuencias y el modelado de temas.

ELKI : El entorno para el desarrollo de aplicaciones KDD es un software de minería de datos de código abierto para Java. El enfoque de ELKI es la investigación en algoritmos, enfatizando los métodos no supervisados ​​en análisis de clusters, índices de bases de datos y detección de valores atípicos. ELKI permite una evaluación independiente de algoritmos de minería de datos y tareas de administración de datos separando los dos. Esta característica es única entre otros marcos de minería de datos como Weta o Rapidminer. ELKI también permite tipos de datos arbitrarios, formatos de archivo o medidas de distancia o similitud. Diseñado para investigadores y estudiantes, ELKI ofrece una gran colección de parámetros de algoritmos altamente configurables. Esto permite una evaluación justa y fácil y una evaluación comparativa de los algoritmos. ELKI es particularmente útil para la ciencia de datos.




sábado, 1 de septiembre de 2018

EBooks gratuitos sobre visualización de datos y Machine Learning





Quiero compartir un post de data science central donde regalan libros sobre visualización de datos y Machine Learning. Los títulos son los siguientes:


  • What You Need to Know about Machine Learning
  • HTML5 Graphing and Data Visualization Cookbook
  • Building Machine Learning Systems with Python
  • Practical Data Analysis
  • Machine Learning with R


Sin más dejo link: https://www.datasciencecentral.com/profiles/blogs/free-ebooks-on-data-visualization-and-machine-learning

jueves, 30 de agosto de 2018

Data science central


Quiero recomendarles la pagina data science central donde encontraran muy buenos post y libros gratuitos y muchísima información sobre data science.

Sin más, dejo link: https://www.datasciencecentral.com/

martes, 28 de agosto de 2018

6 lenguajes de programación que debes estudiar para Data Science


Quiero compartir un artículo sobre los lenguajes de programación que debes aprender para ser el capo máximo de data science. Ya que este es mi blog y los gustos me los tengo que dar en vida, voy a atreverme a ordenar los lenguajes según la importancia con respecto al data science:

  • SQL
  • Python
  • R
  • Scala
  • Java 
  • Julia

En que me baso? en mi opinión, es decir, no puedo se menos científico. Peroooo, tengo una explicación. SQL esta en todos lados, y si el motor de base de datos es noSQL, algún lenguaje de consulta similar a SQL (con sus restricciones) va a tener por esa razón me parece imprescindible saber SQL. Python y R son los más famosos lenguaje en data science por lejos...

Scala y Java por la sacudida que esta dando Spark. Y Julia, porque es un lenguaje que viene creciendo.

Dejo link: https://dzone.com/articles/what-is-data-science-programming-top-7-languages?utm_source=Top%205&utm_medium=email&utm_campaign=Top%205%202018-08-243

sábado, 25 de agosto de 2018

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!!

jueves, 23 de agosto de 2018

miércoles, 22 de agosto de 2018

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:

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:

Y en java

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

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

sábado, 18 de agosto de 2018

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/

martes, 14 de agosto de 2018

¿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
View Now
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 

domingo, 12 de agosto de 2018

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 : 

Cursos Gugler

Quiero recomendarles los siguientes cursos:



sábado, 11 de agosto de 2018

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

jueves, 9 de agosto de 2018

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 :

lunes, 6 de agosto de 2018

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