Meetup Spark y la Combinación de sus Distintos Módulos

Spark y la
relación entre
sus distintos
módulos

Quienes somos
Quienes somos
JORGE LOPEZ-MALLA
Tras trabajar con algunas
metodologías tradicionales
empecé a centrarme en el
mundo del Big Data, del cual
me enamoré. Ahora soy
arquitecto Big Data en Stratio y
he puesto proyectos en
producción en distintas partes
del mundo.
SKILLS

Jorge López-Malla Matute
jlopezm@stratio.com
CONTACTO
Introducción
● Introducción al Big Data
● Hadoop
● ¿Por qué Spark?
1 2
5
3 Spark SQL
● Introducción
● Dataframe
● ¿Cómo relacionamos Core y
SQL?
● Ejemplos prácticos
Spark core
● RDD
● Transformaciones/Acciones con
RDD
● Ejemplo de operaciones
Spark Streaming
● Introducción
● DStreams
● Operaciones "Stateful"
● ¿Cómo se relaciona con el Batch?
MlLib
● Introducción
● Modelos
● ¿Cómo relacionamos Batch y
MLib?
● ¿Cómo usamos MlLib en Streaming
ÍndiceÍndice
4

jlopezm@stratio.com
CONTACTO
Introducción
● Hadoop
1 2
5
3 Spark SQL
● Introducción
● Dataframe
SQL?
Spark Streaming
● Introducción
● DStreams
MlLib
● Introducción
● Modelos
● ¿Cómo relacionamos Batch y
MLib?
● ¿Cómo usamos MlLib en Streaming
ÍndiceÍndice
4
Spark core
● RDD
RDD

Introducción
Introducción al Big Data

Introducción
Map&Reduce es un modelo de programación utilizado por Google para dar soporte a
la computación paralela sobre grandes colecciones de datos en grupos de
computadoras y al commodity computing. El nombre del framework está inspirado
en los nombres de dos importantes métodos, macros o funciones en programación
funcional: Map y Reduce. MapReduce ha sido adoptado mundialmente, ya que
existe una implementación OpenSource denominada Hadoop. Su desarrollo fue
liderado inicialmente por Yahoo y actualmente lo realiza el proyecto Apache. En esta
década de los años 2010 existen diversas iniciativas similares a Hadoop tanto en la
industria como en el ámbito académico, entre ellas está Spark.

Introducción
Map(k1,v1) ->
list(k2,v2)
Reduce(k2,list(v2)) -> (k3,v3)

Fases opcionales del modelo
Aunque el modelo Map & Reduce puede realizarse únicamente con las fases de Map y de Reduce existen
una serie de fases opcionales que nos ayudan a mejorar y optimizar nuestros procesos. Estas fases son:
● Combiner (Fase de Combinación)
● Partitioner (Fase de Particionado)
Map Combiner Partitioner Reduce
Introducción

Hadoop
Apache Hadoop es un framework de procesamiento, almacenamiento y gestión de
procesos distribuido que facilita la programación de tareas mediante el paradigma map
& reduce y es escalable desde unos pocos hasta miles de nodos. Es bastante robusto y
está diseñado para trabajar en alta disponibilidad, con tolerancia a fallos y en su versión
reciente gestionar recursos de manera muy eficiente.
Introducción

¿Por qué Spark?
Apache Spark es una framework de procesamiento distribuido en memoria de
segunda generación que facilita la analítica de grandes conjuntos de datos
integrando diferentes paradigmas como Bases de Datos NoSQL, analítica
en tiempo real, machine learning o análisis de grafos mediante un
único lenguaje común.
SPARK CORE
SQL RSTREAMING MlLib GraphX
Introducción

Introducción al Modelo de Map & Reduce
¿Por qué Spark?
• API única para
todo
• Presente y Futuro
• Gran adopción
• Integración con
Hadoop
• Facilidad de uso
• Tolerancia a fallos
• Production-ready
• Multilenguaje

jlopezm@stratio.com
CONTACTO
Introducción
● Hadoop
1 2
5
3 Spark SQL
● Introducción
● Dataframe
SQL?
Spark core
● RDD
● Transformaciones/Acciones
con RDD
Spark Streaming
● Introducción
● DStreams
MlLib
● Introducción
● Algoritmos
ÍndiceÍndice
4

Definición:
Un RDD en Spark es una colección de colecciones de objetos inmutable y distribuida. Cada RDD está
dividido en diferentes particiones, que pueden ser computadas en los distintos nodos del Cluster de Spark.
Es la Unidad mínima de computación en Spark
Ej:
El RDD numbers es un rdd de enteros que está distribuido por en un cluster con 3 Workers{W1, W2, W3}
numbers = RDD[1,2,3,4,5,6,7,8,9,10]
Conceptos de Spark
RDD
W1 W2 W2
[1,5,6,9] [2,7,8] [3,4,10]

Los RDD tienen dos tipos de operaciones:
1. Transformaciones: Son aquellas operaciones que tras ejecutarlas nos devuelven otro RDD. Como un RDD no
deja de ser una colección distribuida estas operaciones son Lazy por lo que no se realizará ningún cálculo a
no ser que al final del árbol de operaciones haya una acción.
2. Acciones: Son operaciones que una vez realizadas sobre un RDD nos devuelven un objeto distinto a un RDD
o vacío. Este tipo de operaciones hace que se lance la ejecución del workflow y por consiguiente que se
ejecute nuestra aplicación de Spark.
Spark Core
Transformaciones

Spark Core
Transformaciones
map
Devuelve el rdd resultante de aplicar una función a cada uno de los elementos del rdd que lo
invoca:
map
scala> val rddUpper = rddCow.map(_.toUpperCase)
rddUpper: org.apache.spark.rdd.RDD[String] = MappedRDD[1] at map
rddCow rddUpper
I've never seen a purple cow
I never hope to see one
But i can tell you, anyhow,
I’d rather see than be one
I'VE NEVER SEEN A PURPLE
COW
I NEVER HOPE TO SEE ONE
BUT I CAN TELL YOU, ANYHOW,
I’D RATHER SEE THAN BE ONE

Spark Core
Transformaciones
flatMap
scala> val rddCowWords = rddCow.flatMap(_.split(" "))
rddCowWords: org.apache.spark.rdd.RDD[String] = FlatMappedRDD[2] at flatMap
scala> rddCow.partitions.size == rddCowWords.partitions.size
res1: Boolean = true
scala> rddCow.count == rddCowWords.count
25/04/15 10:30:28 INFO SparkContext: Starting job: count
25/04/15 10:30:28 INFO DAGScheduler: Got job 2 (count) with 3 output partitions
(allowLocal=false)
…
25/04/15 10:30:20 INFO DAGScheduler: Job 3 finished: count, took 0,11456 s
res2: Boolean = false
flatMap
rddCowWords
I've never seen a purple cow
I never hope to see one
But i can tell you, anyhow,
I’ve
never
seen
a
purple
cow
I
never
hope
to
see
one
But
i
can
tell
you,
anyhow
rddCow

rddVisits
combineByKey:
Spark Core
Shuffle
(February, (5, 1))
(January, (21, 5))
(June, (2,2))
(March, (2,2))
rddMeanVisitsByMonth
scala> val rddMeanVistisByMonth = rddVisits.combineByKey(
(visit: Int) => (visit, 1),
(comb: (Int, Int), visit) => (comb._1 + visit, comb._2 + 1),
(combAcc: (Int, Int), comb: (Int, Int)) => (combAcc._1 + comb._1, combAcc._2 + comb._2))
rddMeanVistisByMonth: org.apache.spark.rdd.RDD[(String, (Int, Int))] = ShuffledRDD[2]
2
1
3
(March, 4)
(March, 4)
(January, 4)
(January, 4)
(January, 3)
(January, 5)
(June, 2)
(March, 3)
(February, 5)
(June, 1)
(January, 5)
1
1
1
1
1
1
1
2
1
1
2
1
1
2
3
3
3
3
Transformaciones

Acciones:
Las acciones son los métodos de Spark que hacen que se ejecute todo el workflow asociado a
una acción. Hasta el momento no se ha ejecutado ninguna operación ni se han movido los datos
de los repositorios distribuidos.
Hay que tener cuidado con algunas de estas operaciones porque pueden dar como resultado el
traer todos los datos de un repositorio Big Data a una sola máquina.
A continuación enumeramos algunas de las usadas.
Spark Core
Acciones

foreach
Recorre todo el RDD ejecutando una acción. Esta acción no debe devolver ningún valor.
Spark Core
Acciones
(January, (3, 5, 7))
(March, (3))
(February, (5))
(June, (1, 2))
(March, (4, 4))
(January, (4, 4))
rddVisitsByMonth
scala> rddVisitsByMonth.foreach(tuple => println(tuple._2.reduce(_ + _)))
15
3
5
3
8
8

jlopezm@stratio.com
CONTACTO
Introducción
● Hadoop
1 2
5
3 Spark SQL
● Introducción
● Dataframe
SQL?
Spark core
● RDD
RDD
Spark Streaming
● Introducción
● DStreams
MlLib
● Introducción
● Algoritmos
ÍndiceÍndice
4

Spark Sql
Introducción
Spark SQL nace en la versión 1.0 y quiere aunar y mejorar diferentes iniciativas de
"SQL-on-Hadoop" ya existentes.
•
Ejecuta consultas SQL / HiveQL sobre RDD’s o datasources.
•
Conecta herramientas de BI a Spark mediante JDBC vía "thrift server"
•
Manejo con Python, Scala, Java, R

Spark Sql
DataFrame
Un DataFrame es una colección de Rows que contiene un esquema específico
indícando el nombre de las columnas y el tipo de dato que contiene cada una de
ellas.
Conceptualmente es equivalente a una tabla en una base de datos relacional
pero con una capa de optimización que transforma lógica SQL en un plan
"físico" basado en RDD’s para ser ejecutados en Spark.

Spark Sql
DataFrame API
El trabajo con SQL puede hacerse de forma directa haciendo consultas en este
lenguaje o haciendo uso de una completa API que han desarrollado y que permite
trabajar de forma programática con todas la funcionalidad del lenguaje y
añadiendo la propia, integrada totalmente con el core de Spark.
• Proyección y filtrado de columnas
• Joins entre datasources
diferentes
• Funciones de agregación
• Soporte para UDF’s
• API extensible

Spark Sql
¿Cómo mezclamos el Core con el SQL?
Como hemos explicado antes, un Dataframe no deja de ser un RDD de un tipo
concreto, Row.
La forma más sencilla de mezclarlos es mediante la creación de un Dataframe a
partir de un RDDimport org.apache.spark.sql.functions._
import sqlContext.implicits._
val flightsTicketsText = sc.textFile("/home/meetup/datasets/flightsTickets.dat")
val flightsArray = flightsText.map(line => line.split(","))
val ticketsDF = flightsArray.map(ticket =>
(ticket(0).toInt, ticket(1), ticket(2), ticket(3).toBoolean))
.toDF("idFlight", "dni", "dest", "isPersonal").cache()

Spark Sql
Al ser ambos RDD también podemos hacer cualquier operación de las vistas
anteriormente para los RDD
import org.apache.spark.sql.functions._
val personsRDD = sc.textFile("/home/jlmalla/meetup/datasets/persons.dat")
.map(line => line.split(","))
.map{case (id, name, gender, revenue) => (id, (name, gender, revenue))}
val joinTicketsPersons = ticketsDF.map(row => (row(1), row)).join(personsRDD)
val fligths = joinTicketsPersons.map{
case (id, (Array((idFlight, dni, dest, isPersonal), (name, gender, revenue))) =>
(dni, name, gender, revenue, idFligth, isPersonal)}
.toDF("dni", "name", "gender", "revenue", "dest", "idFligth", "isPersonal")

Spark Sql
Pero hacer esto carecería de sentido dado que todo RDD con estructura se pude
transformar a un Dataframe y aprovechar las mejoras de Spark SQL
import org.apache.spark.sql.functions._
val personsDF = sc.textFile("/home/meetup/datasets/persons.dat").map(line => line.split(","))
.map{case (dni, name, gender, revenue) => (dni, (name, gender, revenue))}
.toDF(“id", "name", "gender", "revenue“)
val joinTicketsPersons = ticketsDF.join(personsDF, ticketsDF("dni") === personsDF("id"))
val fligths = joinTicketsPersons.select("dni", "name", "gender", "revenue", "dest", "idFligth",
"isPersonal")

Spark Sql
Ejemplos Prácticos
Leemos los datos de los aeropuertos de un CSV los juntamos con datos de vuelos
de un RDD y escribimos las estadísticas en Mongo

Spark Sql
Ejemplos Prácticos
import org.apache.spark.sql.Row
val aiports = sqlContext.read.format("com.databricks.spark.csv").option("header",
"true").option("inferSchema", "true").load("/home/jlmalla/meetup/files/airports")
airpots: DataFrame = [id: int, name: string, description: string]
val flightsToAnalyze = fligths.select("dest", "gender").map(row => {
val Row(dest, gender) = row
val male = if (gender.asInstanceOf[String] == "H") 1 else 0
val female = if (gender.asInstanceOf[String] == "M") 1 else 0
(dest.asInstanceOf[String], (male, female))
}).reduceByKey((gender1, gender2) => (gender1._1 + gender2._1, gender1._2 + gender2._2)).map{case
(dest, (male, female)) => (dest, male, female)}.toDF("dest", "male", "female")
val airportStatictis = flightsToAnalyze.join(aiports, flightsToAnalyze("dest") ===
aiports("name"))
airportStatictis.select("name", "male", "female")
.write.format("com.stratio.datasource.mongodb")
.options(Map("host" -> "localhost:27017", "database" -> "meetup", "collection" ->
"staticts")).save()

Introduccion
SPARK STREAMING OVERVIEW
Spark Streaming es la solución de Spark para la análitica en tiempo real.
Al igual que Spark Core y SparkSQL tienen como unidad mínima de computación el
RDD y el Dataframe correspondienmente Spark Streaming tiene como unidad
mínima de computación: el DStream

Definición:
Un DStream representa una corriente de datos, un conjunto de datos que llegan de manera continua desde una
fuente. En Spark este concepto se implementa como "micro batchs" de RDDs.
Es la unidad mínima de procesamiento de Spark Streaming
Ej:
Conceptos de Spark
DStream
DStream
R
D
D
R
D
D
R
D
D
R
D
D

Spark Streaming
InputDStream y Receivers
La entrada de streams de datos se produce a través de los llamados InputDStream
o Receiver
•
Es común usar sistemas como Kafka, Kinesis o Apache Flume
•
Existen también receivers básicos como sockets, stream de ficheros o actores de
akka.
•
Es importante usar entradas de datos con tolerancia a fallos y alto throughput.

Spark Streaming
DStream
Un DStream representa una entrada de datos en tiempo real en un intervalo de
tiempo determinado.
•
La entrada de datos es dividida en micro batches.
•
Cada micro-batch es un RDD
•
El Dstream es una secuencia de RDD’s

Spark Streaming
Operaciones stateful (I)
Hay operaciones especiales que mantienen estados y se actualizan en cada batch
interval, son llamadas stateful.
•
Estas operaciones son UpdateStateByKey y ReduceByKeyAndWindow
•
Estos estados se mantienen en memoria. Se pueden crear, actualizar y eliminar.
•
Estas operaciones requieren de checkpointing para recuperación de errores.
El flujo normal de un stream es el siguiente
•
Cada Batch interval se genera un Dstream
•
A los datos contenidos en ese Dstream se le aplican
transformaciones
•
Se realiza una o varias acciones con estos datos.
¿Cómo haríais un simple wordcou
que se mantenga a lo largo del
tiempo?

Operaciones Stateful (II)
Spark Streaming
UpdateStateByKey
def updateStateByKey[S](updateFunc: (Seq[V], Option[S]) ⇒ Option[S])
• Para cada clave K mantiene un
Option[S]
• Option a None elimina el estado.

Spark Sql
Ejemplo
val sparkConf = new SparkConf().setAppName(“StreamingTest")
val ssc = new StreamingContext(sparkConf, Seconds(2))
val stream = TwitterUtils.createStream(ssc, None, filters)
val hashTags = stream.flatMap(status => status.getText.split(" ").filter(_.startsWith("#")))
val topCounts60 = hashTags.map((_, 1)).reduceByKeyAndWindow(_ + _, Seconds(60))
.map{case (topic, count) => (count, topic)}
.transform(_.sortByKey(false))
val topCounts10 = hashTags.map((_, 1)).reduceByKeyAndWindow(_ + _, Seconds(10))
.map{case (topic, count) => (count, topic)}
.transform(_.sortByKey(false))
// Print popular hashtags
topCounts60.foreachRDD(rdd => {
val topList = rdd.take(10)
println("nPopular topics in last 60 seconds (%s total):".format(rdd.count()))
topList.foreach{case (count, tag) => println("%s (%s tweets)".format(tag, count))}
})
ssc.start()
ssc.awaitTermination()

¿Cómo relacionamos Batch y Streaming?
Spark Streaming
Como el resto de relaciones entre módulos de Spark todo tiene que ver con sus
unidades mínimas de computación.
Los DStream no son sino conjuntos de mini batches de RDDs
La combinación entre ambos módulos se hace mediante las operaciones
forEachRDD y transform

¿Cómo se relaciona con el Batch?
Spark Streaming
TransformRDD
def transform[U](transformFunc: (RDD[T]) ⇒ RDD[U]) : DStream[U]
Con esta operación transformaremos todos los RDDs pertenecientes a un
micro batch.
Las operaciones que crean los RDDs que representan el “Batch” se realizan en el
driver por lo que no se corre ningún riesgo de serialización.
Con esta operación, aún **, no se puede mezclar Streaming y SQL dado que la
salida que busca es un RDD y no un Dataframe

Spark Streaming
foreachRDD
def foreachRR[U](transformFunc: (RDD[T]) ⇒ Unit : Unit
Esta operación es exactamente igual que el foreach de un RDD sólo que aplicada a
todos los RDD contenidos en un microbatch de Streaming.
Aquí ya se puede relacionar Streaming y SQL

Spark Streaming
val ssc = new StreamingContext(sc, Seconds(2))
ssc.checkpoint("/tmp/chechkpointdir")
val props = Map("metadata.broker.list" -> "localhost:9092", "auto.offset.reset" -> "smallest")
val kafkaStream = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, props, =
Set("meetup-1"))
Val batchStream = kafkaStream.map{case (key, value) => value}.transform(rdd =>{
val context: SparkContext = rdd.sparkContext
val persons = context.textFile("/home/jlmalla/meetup/datasets/persons.dat").map(line => line.split(","))
.map{case Array(dni, name, gender, revenue) => (dni, gender)}
val fligths = rdd.flatMap(line => {
val splitedLine: Array[String] = line.split(",")
if (splitedLine.size == 3)
{
val Array(id, airpot, _) = splitedLine
Some((id, airpot))
}else None
}
)
fligths.join(persons).map{case (id, (airpot, gender)) => {
val male = if (gender == "H") 1 else 0
val female = if (gender == "M") 1 else 0
(airpot, (male, female))
}}.reduceByKey((gender1, gender2) => (gender1._1 + gender2._1, gender1._2 + gender2._2)).map{case (dest, (male,
female)) => (dest, male.toDouble, female.toDouble)}
})

Spark Streaming
batchStream.foreachRDD(rdd => {
val context = rdd.sparkContext
val sqlContext = new SQLContext(context)
val airportStatictis = rdd.toDF("name", "male", "female")
airportStatictis.select("name", "male", "female")
.write.format("com.stratio.datasource.mongodb").mode(SaveMode.Append).options(Map("host" ->
"localhost:27017", "database" -> "meetup", "collection" -> "staticts")).save()
})
ssc.start()

jlopezm@stratio.com
CONTACTO
Introducción
● Hadoop
1 2
5
3 Spark SQL
● Introducción
● Dataframe
● ¿Cómo relacionamos Core y SQL?
Spark core
● RDD
RDD
Spark Streaming
● Introducción
● DStreams
MlLib
● Introducción
● Algoritmos
● ¿Cómo se relaciona con el SQL?
● ¿Cómo se relaciona con el Streaming?
ÍndiceÍndice
4

MlLib
Introducción
MlLib es la librería de Machine Learning de Spark. Su objetivo es dar los
mecanismos necesarios para poder realizar diferentes algoritmias de Machine
Learning aplicadas a grandes cantidades de datos.
Como todas las piezas del ecosistema de Spark, tiene como base los RDDs para la
ejecución de estas algoritmias.
MlLib "únicamente" nos proporciona, de una manera sencilla y eficiente, los
métodos y las API necesarias para poder ejecutarlos, pero estos algoritmos tienen
que ser alimentados por modelos matemáticos generados por el usuario.

MlLib
Algoritmos
MlLib tiene implementados varios algoritmos de distinta índole para distintos
problemas de Machine Learning.
Dada la variedad de algoritmia relacionadas con el Machine Learning y su
complejidad explicar cada uno de estos algoritmos queda fuera de este meetup.
No obstante mostraremos el funcionamiento, mediante ejemplos, de dos
algoritmos bastante usados dentro de la comunidad de Spark KMeans y ALS

MlLib
Algoritmos
Todos los algoritmos de MlLib necesitan alimentarse de un RDD que les proporcione
datos para formular modelos
Algunos de estos modelos podrán ser usados más adelante para predecir el
comportamiento de otros elementos ajenos al dataset de pruebas

MlLib
Ejemplo ALS relación con Batch
import org.apache.spark.mllib.recommendation.ALS
import org.apache.spark.mllib.recommendation.MatrixFactorizationModel
import org.apache.spark.mllib.recommendation.Rating
val data = sc.textFile("data/mllib/als/test.data")
val ratings = data.map(_.split(',') match { case Array(user, item, rate) =>
Rating(user.toInt, item.toInt, rate.toDouble)
})
val rank = 10
val numIterations = 10
val model = ALS.train(ratings, rank, numIterations, 0.01)
val usersProducts = ratings.map {
case Rating(user, product, rate) => (user, product)
}
val predictions = model.predict(usersProducts).map { case Rating(user, product, rate) =>
((user, product), rate)
}
val ratesAndPreds = ratings.map { case Rating(user, product, rate) =>
((user, product), rate)
}.join(predictions)

MlLib
Ejemplo Kmeans relación con Batch
import org.apache.spark.mllib.clustering.{KMeans, KMeansModel}
import org.apache.spark.mllib.linalg.Vectors
// Load and parse the data
val data = sc.textFile("data/mllib/kmeans_data.txt")
val parsedData = data.map(s => Vectors.dense(s.split(' ').map(_.toDouble))).cache()
// Cluster the data into two classes using KMeans
val numClusters = 2
val numIterations = 20
val clusters = KMeans.train(parsedData, numClusters, numIterations)
// Evaluate clustering by computing Within Set Sum of Squared Errors
val WSSSE = clusters.computeCost(parsedData)
println("Within Set Sum of Squared Errors = " + WSSSE)
// Save and load model
clusters.save(sc, "myModelPath")
val sameModel = KMeansModel.load(sc, "myModelPath")

¿Cómo se relaciona con el SQL?
MlLib
A partir de la versión 1.4.0 de Spark se ha integrado una nueva forma de usar los
RDD para cargar información para los modelos.
En vez de usar un RDD y transformalo a un formato usable por el algoritmo se
pueden usar Dataframes y cargar la información directamente usando una
variable de la tabla.

¿Cómo se relaciona con el SQL?
MlLib
import org.apache.spark.ml.clustering.KMeans
import org.apache.spark.mllib.linalg.Vectors
// Crates a DataFrame
val dataset: DataFrame = sqlContext.createDataFrame(Seq(
(1, Vectors.dense(0.0, 0.0, 0.0)),
(2, Vectors.dense(0.1, 0.1, 0.1)),
(3, Vectors.dense(0.2, 0.2, 0.2)),
(4, Vectors.dense(9.0, 9.0, 9.0)),
(5, Vectors.dense(9.1, 9.1, 9.1)),
(6, Vectors.dense(9.2, 9.2, 9.2))
)).toDF("id", "features")
// Trains a k-means model
val kmeans = new KMeans()
.setK(2)
.setFeaturesCol("features")
.setPredictionCol("prediction")
val model = kmeans.fit(dataset)
// Shows the result
println("Final Centers: ")
model.clusterCenters.foreach(println)

¿Cómo se relaciona con el Streaming?
MlLib
La mayoría de algoritmia relacionada con el cáculo de algoritmos de Machine
Learning es de ámbito batch, necesitamos todos los datos para calcular los
algoritomos
Desde que Spark permitió el guardado de modelos en repositorios distribuidos
se puede mezclar ambos mundos mediante la lectura del módelo y pasando este
como variable, similar a la relación de Batch y Streaming, para predecir nuevos
registros que lleguen en Streaming.

MlLib
import org.apache.spark.SparkConf
import org.apache.spark.mllib.clustering.KMeansModel
import org.apache.spark.mllib.linalg.Vector
import org.apache.spark.streaming.twitter._
import org.apache.spark.streaming.{Seconds, StreamingContext}
/**
* Pulls live tweets and filters them for tweets in the chosen cluster.
*/
object Predict {
def main(args: Array[String]) {
if (args.length < 2) {
System.err.println("Usage: " + this.getClass.getSimpleName + " <modelDirectory> <clusterNumber>")
System.exit(1)
}
val Array(modelFile, Utils.IntParam(clusterNumber)) =
Utils.parseCommandLineWithTwitterCredentials(args)
println("Initializing Streaming Spark Context...")
val conf = new SparkConf().setAppName(this.getClass.getSimpleName)
val ssc = new StreamingContext(conf, Seconds(5))
println("Initializing Twitter stream...")
val tweets = TwitterUtils.createStream(ssc, Utils.getAuth)
val statuses = tweets.map(_.getText)

MlLib
println("Initalizaing the the KMeans model...")
val model = KmeansModel.load(ssc.sparkContext, modelFile)
val filteredTweets = statuses
.filter(t => model.predict(Utils.featurize(t)) == clusterNumber)
filteredTweets.print()
// Start the streaming computation
println("Initialization complete.")
ssc.start()
}
}

Meetup Spark y la Combinación de sus Distintos Módulos

Meetup Spark y la Combinación de sus Distintos Módulos

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (12)

Similar a Meetup Spark y la Combinación de sus Distintos Módulos

Similar a Meetup Spark y la Combinación de sus Distintos Módulos (20)

Más de Jorge Lopez-Malla

Más de Jorge Lopez-Malla (8)

Último

Último (19)

Meetup Spark y la Combinación de sus Distintos Módulos