{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Ipython y Spark para el analisis de datos"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*Esta notebook fue creada originalmente como un blog post por [Raúl E. López Briega](http://relopezbriega.com.ar/) en [Mi blog sobre Python](http://relopezbriega.github.io). El contenido esta bajo la licencia BSD.*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Una de las nuevas estrellas en el análisis de datos masivos es [Apache Spark](http://spark.apache.org/). Desarrollado en [Scala](http://www.scala-lang.org/), [Apache Spark](http://spark.apache.org/) es una plataforma de computación de código abierto para el análisis y procesamiento de grandes volúmenes de datos. \n",
"\n",
"Algunas de las ventajas que nos ofrece [Apache Spark](http://spark.apache.org/) sobre otros [frameworks](http://es.wikipedia.org/wiki/Framework), son:\n",
"\n",
"* **Velocidad:** Sin dudas la velocidad es una de las principales fortalezas de [Apache Spark](http://spark.apache.org/), como esta diseñado para soportar el [procesameinto en memoria](http://en.wikipedia.org/wiki/In-Memory_Processing), puede alcanzar una performance sorprendente en análisis avanzados de datos. Algunos programas escritos utilizando [Apache Spark](http://spark.apache.org/), pueden correr hasta 100x más rápido que utilizando [Hadoop](http://hadoop.apache.org/).\n",
"* **Fácil de usar:** Podemos escribir programas en [Python](http://python.org/), [Scala](http://www.scala-lang.org/) o [Java](http://java.com/en/) que hagan uso de las herramientas que ofrece [Apache Spark](http://spark.apache.org/); asimismo nos permite trabajar en forma interactiva (con [Python](http://python.org/) o con [Scala](http://www.scala-lang.org/)) y su [API](http://es.wikipedia.org/wiki/Interfaz_de_programaci%C3%B3n_de_aplicaciones) es muy fácil de aprender. \n",
"* **Generalismo:** El mundo del análisis de datos incluye muchos subgrupos de distinta índole, están los que hacen un análisis investigativo, los que que realizan análisis exploratorios, los que construyen sistemas de procesamientos de datos, etc. Los usuarios de cada uno de esos subgrupos, al tener objetivos distintos, suelen utilizar una gran variedad de herramientas totalmente diferentes. [Apache Spark](http://spark.apache.org/) nos proporciona un gran número de herramientas de alto nivel como [Spark SQL](http://spark.apache.org/sql/), [MLlib](http://spark.apache.org/mllib/) para [machine learning](http://es.wikipedia.org/wiki/Machine_learning), [GraphX](http://spark.apache.org/graphx/), y [Spark Streaming](http://spark.apache.org/streaming/); las cuales pueden ser combinadas para crear aplicaciones multipropósito que ataquen los diferentes dominios del análisis de datos. \n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## RDD o Resilient Distributed Datasets"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En el corazón de [Apache Spark](http://spark.apache.org/) se encuentran los [RDDs](http://www.cs.berkeley.edu/~matei/papers/2012/nsdi_spark.pdf).\n",
"Los [RDDs](http://www.cs.berkeley.edu/~matei/papers/2012/nsdi_spark.pdf) son una abstracción distribuida que le permite a los programadores realizar cómputos [en memoria](http://en.wikipedia.org/wiki/In-Memory_Processing) sobre grandes clusters de computadoras sin errores o pérdidas de información. Están especialmente diseñados para el análisis de datos interactivo ([data mining](http://es.wikipedia.org/wiki/Miner%C3%ADa_de_datos)) y para la aplicación de algoritmos iterativos ([MapReduce](http://es.wikipedia.org/wiki/MapReduce)). En ambos casos, mantener los datos en la memoria puede mejorar el rendimiento en una gran proporción. Para lograr la tolerancia a fallos de manera eficiente, [RDDs](http://www.cs.berkeley.edu/~matei/papers/2012/nsdi_spark.pdf) utiliza una forma restringida de memoria compartida. \n",
"Los [RDDs](http://www.cs.berkeley.edu/~matei/papers/2012/nsdi_spark.pdf) son los suficientemente expresivos como para capturar una gran variedad de cálculos."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Instalando Apache Spark"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Para instalar [Apache Spark](http://spark.apache.org/) en forma local y poder comenzar a utilizarlo, pueden seguir los siguientes pasos:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"1. En primer lugar, necesitamos tener instalado [Oracle JDK](http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html). Para instalarlo en [Ubuntu](http://www.ubuntu.com/) podemos utilizar los siguientes comandos:\n",
"\n",
"$ sudo add-apt-repository ppa:webupd8team/java\n",
"$ sudo apt-get update\n",
"$ sudo apt-get install oracle-jdk7-installer\n",
"\n",
"\n",
"2. Luego nos instalamos las herramientas para trabajar con [Scala](http://www.scala-lang.org/), [SBT](http://www.scala-sbt.org/) con el siguiente comando:\n",
"\n",
"$ sudo apt-get install sbt\n",
"\n",
"\n",
"3. Después nos descargamos la última versión de [Apache Spark](http://spark.apache.org/) desde [aquí](http://d3kbcqa49mib13.cloudfront.net/spark-1.0.2.tgz)\n",
"\n",
"4. Ahora descomprimimos el archivo:\n",
"\n",
"$ tar -xvf spark-1.0.2.tgz \n",
"\n",
"\n",
"5. Nos movemos a la carpeta recién descomprimida y realizamos la compilación de [Apache Spark](http://spark.apache.org/) utilizando [SBT](http://www.scala-sbt.org/). (tener paciencia, es sabido que [Scala](http://www.scala-lang.org/) tarda mucho en compilar) \n",
"\n",
"$ cd spark-1.0.2\n",
"$ sbt/sbt assembly\n",
"\n",
"\n",
"6. Opcionalmente, para facilitar la utilización de [Apache Spark](http://spark.apache.org/) desde la línea de comando, yo modifique mi archivo .bashrc para incluir los siguientes alias:\n",
"\n",
"$ echo \"alias ipyspark='IPYTHON_OPTS=\"notebook --pylab inline\" ~/spark-1.0.2/bin/pyspark'\" >> ~/.bashrc\n",
"$ echo \"alias pyspark='~/spark-1.0.2/bin/pyspark'\" >> ~/.bashrc\n",
"$ echo \"alias spark='~/spark-1.0.2/bin/spark-shell'\" >> ~/.bashrc\n",
"\n",
"\n",
"7. Ahora simplemente tipeando `pyspark` nos abre el interprete interactivo de [Python](http://python.org/) con [Apache Spark](http://spark.apache.org/), tipeando `spark` nos abre el interprete interactivo de [Scala](http://www.scala-lang.org/), y tipeando `ipyspark` nos abre el [notebook de Ipython](http://ipython.org/notebook.html) integrado con [Apache Spark](http://spark.apache.org/)!\n",
"$ ./bin/pyspark #o pyspark si creamos el alias
\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Ejemplo de utilización de Spark con Ipython"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ahora llegó el momento de ensuciarse las manos y probar [Apache Spark](http://spark.apache.org/), vamos a hacer el típico ejercicio de wordcounts; en este caso vamos a contar todas las palabras que posee la Biblia en su versión en inglés y vamos a ver cuantas veces aparece la palabra Dios(God). Para esto nos descargamos la versión de la Biblia en texto plano del [proyecto Gutemberg](http://www.gutenberg.org/ebooks/10).\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Comenzamos con algunos imports.\n",
"# No necesitamos importar pyspark porque ya se autoimporta como sc.\n",
"from operator import add\n",
"import pandas as pd"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"lineas = sc.textFile(\"/home/raul/spark-1.0.2/examples/data/Bible.txt\") # usamos la función textFile para subir el texto a Spark"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Mapeamos las funciones para realizar la cuenta de las palabras y generamos el RDD.\n",
"cuenta = lineas.flatMap(lambda x: x.split(' ')) \\\n",
" .map(lambda x: (x.replace(',' , '').upper(), 1)) \\\n",
" .reduceByKey(add)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Creamos la lista con las palabras y su respectiva frecuencia.\n",
"lista = cuenta.collect()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Creamos un DataFrame de Pandas para facilitar el manejo de los datos.\n",
"dataframe = pd.DataFrame(lista, columns=['palabras', 'cuenta'])"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"
\n",
" \n",
" \n",
" | \n",
" palabras | \n",
" cuenta | \n",
"
\n",
" \n",
" \n",
" \n",
" | 2867 | \n",
" FATHER | \n",
" 814 | \n",
"
\n",
" \n",
" | 7329 | \n",
" GOD | \n",
" 3330 | \n",
"
\n",
" \n",
" | 8902 | \n",
" LORD | \n",
" 6448 | \n",
"
\n",
" \n",
" | 21404 | \n",
" JESUS | \n",
" 893 | \n",
"
\n",
" \n",
"
\n",
"