Instalar Apache Cassandra en Linux con un nodo

Vamos a instalar Apache Cassandra en Linux, en este caso CentOs. Bueno, en realidad no lo vamos a instalar. Vamos a trabajar con la extracción de cassandra, ojo! tengo la jdk instalada :

yum -y install java-1.8.0-openjdk java-1.8.0-openjdk-devel

$ java -version
openjdk version "1.8.0_171"
OpenJDK Runtime Environment (build 1.8.0_171-b10)
OpenJDK 64-Bit Server VM (build 25.171-b10, mixed mode)

Vamos a hacer un directorio:

mkdir cassandra
cd cassandra

Luego bajamos Apache Cassandra:

wget http://apache.dattatec.com/cassandra/3.11.2/apache-cassandra-3.11.2-bin.tar.gz

ahora vamos a extraer el tar: 

$ tar -zxf apache-cassandra-3.11.2-bin.tar.gz 

$ mv apache-cassandra-3.11.2 cassandra

ahora vamos a setear las variables de entorno: 

$ nano /home/app/.bash_profile

y agregamos : 

export CASSANDRA_HOME=<dir_de_casandra>/cassandra

export PATH=$PATH:$CASSANDRA_HOME/bin

Ahora vamos a correr a cassandra: 

$ cassandra

Y luego en otra consola vamos a ejecutar el cliente cqlsh

$ cqlsh

Connected to Test Cluster at 127.0.0.1:9042.

[cqlsh 5.0.1 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]

Use HELP for help.

cqlsh> 

Y Listo!!

Ahora tenemos que ver que podemos hacer con esta base :S

Machine Learning Yearning

Sigo publicando Machine Learning Yearning:

AI is the new electricity

Machine Learning Yearning Dear friends, What happens when the data in your training set does not come from the same distribution as your dev/test set? We are acquiring larger and larger datasets to train our cat detectors...erm...learning algorithms. Sometimes this means living with a training set whose distribution is different from the test set. When is this a good idea, and how can your algorithms still do well on the data distribution you care about? Read this week’s chapters to learn more! Read Chapters 36-39 Pun of the Week As CEO of an AI+Mental health company, my friend Alison Darcy over at Woebotreally liked this one: If you have a great AI pun, tweet it to me @AndrewYNg using #AIpun. I'll share my favorite in next week's email!

Catch up on Machine Learning Yearning Miss last week's email? Access all released chapters Copyright © 2018 Andrew Ng, All rights reserved. Want to change how you receive these emails? You can update your preferences or unsubscribe from this list.

Microsoft adquiere GitHub por $7.5 Billones de dolares

Creo que todo el mundo ya conoce la noticia pero bueno no quiero ser el único blog que no hable de esto.

Microsoft compro Github. Y que se yo... No se si es bueno o malo, no se pero creo que es una gran apuesta. Y apuesta de todos de los que tenemos repositorios de código ahí y de microsoft.

No soy de los que corren a gitlab, creo que vamos a tener que esperar. Tal vez es una buena noticia, microsoft nos ha desconcertado estos tiempos...

Dejo links:
https://www.infoq.com/news/2018/06/microsoft-acquire-github
https://www.clarin.com/tecnologia/microsoft-compra-github-plataforma-codigo-abierto-popular-mundo_0_ByBNVgmxX.html

¿Qué es MongoDB?

MongoDB es una base de datos orientada a documentos de código abierto.

Facilita el desarrollo proveyendo alta performance, alta disponibilidad y fácil escalabilidad.

El motor almacena N cantidad de bases de datos, cada una de las cuales almacena un set de colecciones y cada colección almacena un set de documentos. Un documento es un par clave-valor.

Los documentos son dinámicos.

Un documento en MongoDB es un registro cuya estructura de datos se compone de pares clave-valor.

Estos documentos son similares a un objeto JSON.

El siguiente es un ejemplo de un documento:

Los datos en MongoDB tienen un esquema flexible. Las colecciones en MongoDB no deben cumplir con una estructura definida, lo que facilita mapear un documento a una entidad u objeto.

El desafío a la hora de modelar datos está en balancear las necesidades de la App, las características de performance del motor de base de datos y los patrones de recuperación de datos.

La decisión sobre el diseño de los modelos de datos para MongoDB se resuelven alrededor de la estructura de los documentos y de cómo la App representa las relaciones entre los datos.

Existen dos herramientas que permiten a las Apps representar estas relaciones:

Referencias : Almacenan las relaciones entre los datos incluyendo links desde un documento a otro.

La Apps pueden resolver esas referencias accediendo a los datos relacionados.

En términos generales, estos son los modelos de datos normalizados.

Documentos Embebidos: Capturan las relaciones entre los datos almacenando la información relacionada en una única estructura documental.

Los documento en MongoDB hacen posible embeber estructuras en un campo o arrays dentro de un documento.

Este modelo de datos desnormalizado permite a las Apps obtener y manipular datos relacionados en una única operación.

Crecimiento del Documento: algunas actualizaciones sobre los documentos pueden incrementar el tamaño de los mismos. 

Atomicidad: Las operaciones son atómicas. Lo que significa que una operación no puede cambiar más de un documento. Operaciones que modifican más de un documento en una colección se ejecutan sobre un documento a la vez.

Sharding: MongoDB utiliza el sharding para proporcionar escalabilidad horizontal. Esto permite particionar una colección dentro de la base de datos para distribuir los documentos de una colección a través de una serie de instancias de MongoDB.

Índices:  Los índices son usados para mejorar la performance. Se pueden crear índices a partir de los campos de uso común dentro de las queries que se manejan en la App. Además MongoDB crea índices únicos para el campo _id.

Las Colecciones pueden contener un gran número de Documentos. De ser posible, hay que evitar que se dé esta condición por motivos de performance. Es aconsejable juntar estos objetos más pequeños mediante alguna lógica que los agrupe. De esta manera habrá pocas copias de los campos comunes y habrá pocas entradas claves para el correspondiente índice.

Optimización de Almacenamiento para pequeños Documentos: Cada documento en MongoDB contiene algún tipo de sobrecarga la cual es normalmente insignificante, pero se torna lo contrario si los documentos son pequeños (uno o dos campos máximo).

Dejo link: https://www.mongodb.com/

R en Spark

Podemos utilizar R en Spark.

Primero debemos instalar R, yo lo voy a instalar en ubuntu:

sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9

sudo add-apt-repository 'deb [arch=amd64,i386] https://cran.rstudio.com/bin/linux/ubuntu xenial/'

sudo apt-get update

sudo apt-get install r-base

sudo -i R

con este ultimo comando inicializamos R, ahora vamos a instalar txtplot para poder graficar en la consola.

install.packages('txtplot')

podemos probar esto con la siguiente linea:

library('txtplot')
txtplot(cars[,1], cars[,2], xlab = "speed", ylab = "distance")

Ahora salimos de r con q()

Nos ubicamos en el directorio bin de spark y ejecutamos

./sparkR

y si todo fue bien veras algo así:

Welcome to
    ____              __
   / __/__  ___ _____/ /__
  _\ \/ _ \/ _ `/ __/  '_/
 /___/ .__/\_,_/_/ /_/\_\   version  2.2.1
    /_/


 SparkSession available as 'spark'.

Y bueno, ahora a probarlo!!

podemos probar con el mismo codigo que probamos la instalación de r :

library('txtplot')
txtplot(cars[,1], cars[,2], xlab = "speed", ylab = "distance")

pero no vamos a estar utilizando la potencia de spark.

Vamos a leer un archivito que se llama customers.txt y tiene los siguientes datos:

$ cat customers.txt
100,John Smith, Austin, TX, 78727
200,Joe Johnson, Dallas, TX, 75201
300,Bob Jones, Houston, TX, 77028
400,Andy Davis, San Antonio, TX, 78227
500,James Williams, Austin, TX, 78727

Que corresponden a la estructura:

customer_id: Int, name: String, city: String, state: String, zip_code: String


> csvPath <- “../../customers.txt”
> df <- read.df(csvPath, "csv", header = "false", inferSchema = "true", na.strings = "NA")
> df
SparkDataFrame[_c0:int, _c1:string, _c2:string, _c3:string, _c4:double]

Leímos el archivo como no tiene cabecera, los campos nos quedan como "_c0", "_c1" ... De igual manera para el ejemplo nos sirve.

Vamos contar cuentos clientes tenemos por zip y luego lo imprimimos :

> groupByZip <- summarize(groupBy(df, df$"_c4"), count = n(df$"_c4"))
>  head(groupByZip)
    _c4 count
1 75201     1
2 77028     1
3 78227     1
4 78727     2

Dejo link:
https://spark.apache.org/docs/latest/sparkr.html

Entendiendo el plan de ejecución de una consulta SQL

Muchas veces tenemos problemas de performance y como unos campeones vamos a ver el plan de ejecución pero no entendemos nada :(

¿Qué debo buscar primero?

Todos los motores de bases de datos deberían indicar al menos dos cosas en el plan de ejecución sobre la consulta que estamos investigando:

• Costo
• Cantidad de registros

Es importante buscar el costo y la cantidad de registros en cada parte de la consulta porque nos va a dar una idea donde trabajar..

Depende de la herramienta que usen, es más fácil encontrar uno u otro, por ejemplo Oracle directamente en el EXPLAIN PLAN tenes la columna Cost y Rows.

En SQL Server, si vemos el plan de ejecución en el Management Studio podemos ver el Subtree Cost que es el acumulado de la tarea actual más todas las tareas anteriores que ejecutó (en esa rama). Además, el grosor de la flecha (viendo el plan gráficamente) muestra la cantidad de registros que se mueven en esa consulta.

¿Por qué hay un Sort en mi plan si no hago Order By en la query?

Usualmente esto puede suceder cuando el JOIN se resuelve con el algoritmo MERGE (o sort-merge join). En SQL Server se ve está manera:

El Sort es costoso cómo se ve, pero es peor que resolverlo con un “Loop”. Esto se soluciona con índices ya que con un índice, el ordenamiento es mucho más simple.

¿Que cosas NO deberían aparecer en el plan de ejecución?

En bases de datos relacionales (me refiero a las OLTP y no a los DW donde se hace adrede), no deberíamos jamás encontrarnos con un “Table Scan”. Si aparece un table scan, es porque esa tabla no tiene un Cluster Index (y probablemente tampoco una PK). Cuando las tablas no tienen un Cluster Index no se guardan de manera ordenada y por lo tanto, para hacer una búsqueda el motor se ve obligado a escanear la tabla entera.

¿La base está eligiendo el plan correcto?

Si pensas que existe la posibilidad de que la base no esté eligiendo el plan de ejecución correcto, es porque seguramente tenes que actualizar la estadísticas. No pretendan forzar a la base de datos a elegir un índice específico (aunque puedas hacerlo). Si la base no elige tu índice, seguro tiene un motivo.

Spark Streaming API

Spark Streaming viene con un conjunto de métodos que facilitan el procesamiento de datos. Hay operaciones que son compatibles con RDD como : map , flatMap ,filter , count , reduce , groupByKey , reduceByKey , sortByKey y join. A la vez provee un conjunto de métodos basados en ventanas y operaciones stateful como :  window , countByWindow , reduceByWindow , countByValueAndWindow , reduceByKeyAndWindow y updateStateByKey.

Spark streaming soporta a scala, java y python.

Vamos a ver los pasos típicos para hacer una aplicación con Spark Streaming:

El primer paso es generar el contexto el cual tiene 2 parámetros en el constructor. Uno es el contexto de spark (que lo tenemos) y el otro es el sliding-interval time, este intervalo es el intervalo en el cual los datos van a ser actualizados, es decir es estamos definiendo en que intervalo se van a buscar los datos. Una vez que se inicializa el contexto, no se pueden definir ni agregar nuevos cálculos al contexto existente. Además, solo un objeto StreamingContext puede estar activo en cualquier momento.

Luego tenemos que definir el origen de datos de entrada esto lo hacemos definiendo un DStream de entrada.

Teniendo el origen de datos definimos los cálculos que se realizarán en la entrada DStream utilizando la API de transformaciones Spark Streaming.

Después de definir la lógica de cómputo de transmisión, podemos comenzar a recibir los datos y procesarlos usando el método de inicio en el objeto StreamingContext.

Finalmente, esperamos que el proceso de transmisión de datos se detenga utilizando el método awaitTermination del objeto StreamingContext.

Machine Learning Yearning

Sigo publicando Machine Learning Yearning:

AI is the new electricity

Machine Learning Yearning Dear friends, Learning algorithms are surpassing human-level performance in more and more areas, ranging from speech recognition to image recognition (in narrow domains). Competing against human-level performance has become a new sport in the deep learning world, but it is also a valuable endeavor for many businesses. Why should you refer to human-level performance to speed up ML development? What happens when you surpass human-level performance? Read this week's chapters to find out! Read Chapters 33-35 AI + X-rays: Enter the MURA Bone X-ray Deep Learning Competition! For those of you looking for important ML applications to work on, my Stanford lab just released MURA, a large dataset of musculoskeletal X-rays. Applying deep learning to this dataset can advance diagnoses and improve healthcare in parts of the world where access to skilled radiologists is limited. Enter our competition to see if your model can detect abnormalities in bone X-rays as well as a human radiologist!  Join the deeplearning competition Pun of the Week If you have a great AI pun, tweet it to me @AndrewYNg using #AIpun. I'll share my favorite in next week's email!

Catch up on Machine Learning Yearning Miss last week's email? Access all released chapters Copyright © 2018 Andrew Ng, All rights reserved. Want to change how you receive these emails? You can update your preferences or unsubscribe from this list.

Apache Cassandra en 60 palabras o menos

Algo muy bueno del blog es que trata de ser un resumen, escribir poco para que lean muchos. Ahora vamos con un pequeña definición de Apache Cassandra:

Apache Cassandra es una base de datos de código abierto, distribuida, descentralizada, elásticamente escalable, de alta disponibilidad, tolerante a fallas, tuneablemente consistente y orientada a filas que basa su diseño en Dynamo de Amazon y su modelo de datos en Bigtable de Google.
Creado en Facebook, ahora se usa en algunos de los sitios más populares en la Web.

Exactamente 59 palabras.

Saludos!!

StreamingContext

Al igual que SparkContext lo ultilizamos para trabajar con spark,  para trabajar con Streaming en spark tenemos StreamingContext que es el principal punto de entrada para todas las funciones de transmisión.

Usando este contexto podemos crear un DStream que representa datos de streaming desde un destino TCP, especificando el hostname y el puerto. Por ejemplo si queremos utilizar una herramienta como Ncat para probar Spark Streaming, recibiríamos una secuencia de datos de la máquina donde se está ejecutando Ncat (por ejemplo, localhost) y el número de puerto de 9999.

Tengamos en cuanta que Spark funciona de modo perezoso, de tal manera cuando configuramos el cálculo que realizará cuando se inicie, y no cuando se vaya configurando. 

Para iniciar el procesamiento (después de que se hayan configurado todas las transformaciones) llamamos al método start() para iniciar el cómputo y al método awaitTermination() para esperar a que finalice.

El típico "hola mundo" en diferentes lenguajes

Esto esta revisto, ya he publicado cientos de post que muestran el hola mundo en diferentes lenguajes pero yo no me he cansado :D

Dejo link:
https://excelwithbusiness.com/blog/say-hello-world-in-28-different-programming-languages/

Machine Learning Yearning

Sigo publicando Machine Learning Yearning:

AI is the new electricity

Machine Learning Yearning Dear friends, This week's chapters teach you how to read learning curves. I also give practical advice on how to plot learning curves when your dataset is very small or very large. Happy reading! Read Chapters 31-32 Pun of the Week If you have a great AI pun, tweet it to me @AndrewYNg using #AIpun. I'll share my favorite in next week's email!

Catch up on Machine Learning Yearning Miss last week's email? Access all released chapters Copyright © 2018 Andrew Ng, All rights reserved. You are receiving this because you opted in to receiving emails about Andrew's upcoming book. Our mailing address is: Andrew Ng 353 Serra Mall Stanford, CA 94305 Add us to your address book

DataFrame en Spark SQL

En lenguajes de programación como R, hay una abstracción que es utilizada para almacenar tablas de datos en la memoria. La biblioteca de análisis de datos de Python, llamada Pandas, también tiene un concepto similar. El mismo concepto de tabla de datos se extiende a Spark, conocido como DataFrame, construido sobre RDD, y hay una API muy completa conocida como API DataFrame en Spark SQL para procesar los datos en el DataFrame. También se desarrolló un lenguaje de consulta similar a SQL sobre la abstracción de DataFrame, atendiendo a las necesidades de los usuarios finales para consultar y procesar los datos.

La diferencia clave entre RDD y DataFrame es que DataFrame almacena mucha más información sobre la estructura de los datos, como los tipos de datos y los nombres de las columnas, que el RDD. Esto permite que el DataFrame optimice el procesamiento de forma mucho más efectiva que las transformaciones Spark y las acciones Spark que procesan en RDD. El otro aspecto más importante para mencionar aquí es que todos los lenguajes de programación compatibles de Spark se pueden usar para desarrollar aplicaciones utilizando la API DataFrame de Spark SQL.

Para todos los propósitos prácticos, Spark SQL es un motor SQL distribuido. Que usa esta abstracción para manipular datos que pueden provenir de diferentes orígenes de datos.

Vamos a construir un dataframe desde una base de datos relacional y un archivo y luego vamos a combinarlos:

import org.apache.spark.sql.SQLContext

//Creo el contexto Spark sql
val sqlContext = new org.apache.spark.sql.SQLContext(sc)

//genero el jdbc
val url = "jdbc:mysql://127.0.0.1:3306/amarokdb"

//me conecto a la base y traigo los albunes
val albums = spark.read.format("jdbc").option("url", url).option("dbtable", "albums").option("user", "root").option("password","pass").load()

albums.printSchema() // Imprimo el esquema para probar
albums.registerTempTable("albums") //Registro la lista.

import sqlContext.implicits._

// Creo una clase artista que para leer el archivo
case class Artist(album_id: Int, id: Int, name: String)

// Leo el archivo y creo un DataFrame de artistas

val artists = sc.textFile("/java/spark/artists.csv").map(_.split(",")).map(p => Artist(p(0).trim.toInt, p(1).trim.toInt, p(2))).toDF()

//registro la tabla
artists.registerTempTable("artists")

//Genero un dataframe con un join entre los 2 dataframes y lo imprimo
spark.sql(“select * from albums a, artists aa where a.artist = aa.id”).show

Y eso es todo amigos!!!