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
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
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:
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:
Y en java
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:
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.- 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
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/
- 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
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/
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
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()
}
}
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 :
|
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");
}
}
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 :
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 :
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
Suscribirse a:
Entradas (Atom)