Spark Hands-on

Spark hands-on

Jorge López-Malla Matutejlopezm@stratio.com

CONTACTO Gaspar Muñozgmunoz@stratio.com

Introducción

● Introducción al Big Data

● Hadoop

● ¿Por qué Spark?

Conceptos de Spark

● RDD - Dataframe - DStream

● Componentes de un clúster

● Despliegue de Spark

6Spark SQL

● Introducción

● Dataframe API

● Datasources

● Ejemplos prácticos y Ejercicios

Spark core

● Transformaciones

● Acciones

● Variables compartidas

● Ejemplos prácticos y Ejercicios

Spark Streaming

● Receivers

● Operaciones con DStreams

● Operaciones con ventanas

● Operaciones “Stateful”

● Introducción

● Algoritmos

● Ejemplos prácticos

Quienes somos

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.

Quienes somos

Arquitecto Big Data y

desarrollador en Stratio desde

su creación. He trabajado en

multitud de exitosos proyectos

con Hadoop, Spark y todo su

ecosistema.

jlopezm@stratio.com gmunoz@stratio.com

Introducción al Modelo de Map & Reduce

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.

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

Apache Hadoop es un framework de procesamiento y almacenamiento 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.

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

Spark core

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

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

W1 W2 W2

[1,5,6,9] [2,7,8] [3,4,10]

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

Conceptos de Spark

DStream

Definición:

Un DataFrame en Spark es una colección de colecciones de objetos inmutable y distribuida organizada en columnas con nombre.

Conceptualmente es igual que una tabla en una base de datos relacional. Estos datos pueden provenir de muchas fuentes de datos

estructurados como Json, CSV, tablas de Hive u otros RDD existentes

Es la Unidad mínima de computación en Spark SQL

El RDD persons es un Dataframe que representa la tabla persona que tiene un campo nombre, texto, y otro campo edad, un entero.

Conceptos de Spark

W1 W2 W3

[Jorge, 31] [Gaspar, 28] [María 23]

persons= Dataframe[(Jorge, 31);

(Gaspar, 28);

(María, 23)]

Nombre -> String; Edad -> Int

Spark se puede desplegar de distintas maneras:

● Local: Levanta un cluster embebido de Spark.○ Se hace creando un SparkContext con master = local[NumeroCores]○ El SparkMaster se levanta en el propio proceso y no es accesible ni por via web○ Los Workers, tantos como NúmeroCores, se levantan también en el propio proceso (página de stages accesible vía Web)

● Standalone:○ El SparkMaster se lanza en una máquina del cluster. Web en el Master○ Tendrá tantos Workers como máquinas se indiquen en el fichero slaves○ Se despliega mediante el script start-all.sh de Spark.

Conceptos de Spark

Spark se puede desplegar de distintas maneras:

● YARN○ Se usa el gestor de recursos de Hadoop YARN○ Nuestra aplicación de Spark se lanza dentro de un contenedor de Yarn, que es el encargado de dar los recursos○ Podemos tener varios SparkMaster corriendo a la vez en el cluster (ojo NO podrán compartir información)

● Mesos:○ Mesos es otro gestor de recursos, Spark fue uno de sus Casos de uso○ Como con YARN puede haber más de un SparkMaster (tampoco se podrá compartir su información)○ Se usaba con frecuencia en el primeros momentos de spark, ahora se usa con menos frecuencia.

Conceptos de Spark

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

Devuelve el rdd resultante de aplicar una función a cada uno de los elementos del rdd que lo invoca:

map(f: (V) ⇒ U) : RDD[U]

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

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

purple

anyhow

rddCow

Spark Core

filter scala> val rddEven = rddNumber.filter(number => number%2 == 0)

rddEven : org.apache.spark.rdd.RDD[Int] = FlatMappedRDD[3] at filter

scala> rddNumber.partitions.size == rddEven.partitions.size

res3: Boolean = true

scala> rddNumber.count == rddEven.count

25/11/15 11:30:28 INFO SparkContext: Starting job: count

25/11/15 11:30:28 INFO DAGScheduler: Got job 2 (count) with 3 output partitions (allowLocal=false)

25/11/15 11:30:20 INFO DAGScheduler: Job 3 finished: count, took 0,11456 s

res4: Boolean = false

filter

rddEven

rddNumber

Spark Core

(Algebra, prof1)

(Calculus, prof2)

(Sw Engineering , prof2)

(Algebra, alumn1)

(Logic, alumn1)

(Algebra, alum3)

(Algebra, alum2)

(Calculus, alum1)

(Calculus, alum2)

(Algebra, alum4)

(Algebra, (prof1,alumn1)

(Algebra, (prof1, alum3)

(Algebra, (prof1, alum2))

(Algebra, (prof1, alum4))

(Calculus, (prof2, alum2))

(Calculus, (prof2, alum1))

rddCourseTeacher

rddCourseStudent

rddCourseTeacherStudent

scala> val rddCourseTeacherAllStudent = rddCourseTeacher.leftOuterJoin(rddCourseStudent)

rddCourseTeacherStudent: org.apache.spark.rdd.RDD[(String,(Int, Int))] =

FlatMappedValuesRDD[1] at join

groupByKey:

Agrupa los valores por una clave devolviendo una lista por cada clave

groupByKey() : RDD[(K,Iterable[V])]

Spark Core

(odd, 3)

(odd, 5)

(even, 12)

(even, 4)

groupByKey

(odd, (3, 3, 5))

(even, (4, 4, 12)

rddIsEvenNumber

rddIsEvenNumbers

scala> val rddIsEvenNumbers = rddIsEvenNumber.groupByKey

rddIsEvenNumbers: org.apache.spark.rdd.RDD[(String, Iterable[Int])] = ShuffledRDD[1] at groupByKey

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]

(March, 4)

(January, 4)

(January, 3)

(January, 5)

(June, 2)

(March, 3)

(February, 5)

(June, 1)

(January, 5)

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

numVisits

Cuenta el número de registros de un RDD

countByKey: Map[K, Long]

Spark Core

(January, (3, 5, 7))

(March, (3))

(February, (5))

(June, (1, 2))

(March, (4, 4))

(January, (4, 4))

rddVisitsByMonth

scala> val numVisits = rddVisitsByMonth.count

numVisits: Int

visits

collect

Recolecta todos los datos de un RDD en forma de lista

Spark Core

(January, (3, 5, 7))

(March, (3))

(February, (5))

(June, (1, 2))

(March, (4, 4))

(January, (4, 4))

rddVisitsByMonth

collect

scala> val visits = rddVisitsByMonth.collect

numVisits: Array[(Int, List[Int]]

[(January, (3, 5, 7)),(March, (3)),

(February, (5)),(June, (1, 2))

(March, (4, 4))(January, (4, 4))]

VisitsMap

countByKey

Devuelve los datos al Driver en forma de Map con un contador por clave

Spark Core

(January, (3, 5, 7))

(March, (3))

(February, (5))

(June, (1, 2))

(March, (4, 4))

(January, (4, 4))

rddVisitsByMonth

countByKey

scala> val visitsMap = rddVisitsByMonth.countByKey

visitsMap: scala.collection.Map[String,Long]

{(January, 2),(March, 1),(June, 1),

(February, 1)}

foreach

Recorre todo el RDD ejecutando una acción. Esta acción no debe devolver ningún valor.

Spark Core

(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(_ + _)))

Variables compartidas:

Las variables compartidas son tipos de variables especiales que se pueden usar dentro de las tareas de Spark.

Aunque se crean en el Driver se actualizan y se les da uso en los Workers, dentro de cada tarea de Spark.

Se dividen en dos tipos:

● Contadores distribuidos: accumulator

● Variables distribuidas por el cluster: broadcast

Spark Core

Contadores distribuidos:

Spark Core

scala> val blankLines = sc.accumulator(0)

scala> val nonEmpty = file.flatMap(line => {if (line == "") blankLines += 1; line.split(" ")})

scala> ("Blank lines: " + blankLines.value)

res0: String = Blank lines: 0

scala> nonEmpty.collect

scala> ("Blank lines: " + blankLines.value)

res2: String = Blank lines: 2

rddFile

“Hi There”

“I’m fine”

“I’m great”

flatMap

nonEmpty

Variables Compartidas

scala> val correctionFactor = sc.broadCast(0.35)

scala> val prizesCorrected = prizes.map(idValue => (idValue._1, idValue._2 * correctionFactor.value))

rddPrizes

(art1, 1)

(art2, 0.5)

(art21, 0.5)

(art25, 4)

(art23, 2)

(art52, 40)

mapValues

(art1, 0.35)

(art2, 0.175)

(art21, 0.175)

(art25, 1.4)

(art23, 0.7)

(art52, 14)

prizesCorrected

Variables distribuidas por el cluster:

Spark Sql

case class Movie(movieId : Integer, name : String, genre : String)

case class Tag(userId : Integer, movieId : Integer, tag : String, timestamp : Long)

case class Rating(userId : Integer, movieId : Integer, rating : Float, timestamp : Long)

scala> val ratingCounter = ratingRdd.map(rating => (rating.movieId, 1).reduceByKey(

(counter1, counter2)=> counter1 + counter2)

scala> val idMovieRatingRdd = movieRdd.map(movie => (movie.movieId,

movie.name)).join(ratingCounter)

scala> idMovieRatingRdd.map(idMovieRating => (idMovieRating._2._2, idMovieRating._2._1))

.sortByKey(false).map(counterName => (counterName._2, counterName._1)).collect.head

Spark Sql

* Saca la película más vista

scala> val ratingCounter = ratingRdd.map(rating => (rating.movieId, 1).reduceByKey(

(counter1, counter2)=> counter1 + counter2)

scala> val idMovieRatingRdd = movieRdd.map(movie => (movie.movieId,

movie.name)).join(ratingCounter)

scala> idMovieRatingRdd.map(idMovieRating => (idMovieRating._2._2, idMovieRating._2._1))

.sortByKey(false).map(counterName => (counterName._2, counterName._1)).collect.head

Spark Sql

scala> val aux1 = ratingRdd.map(rating => (rating.movieId, rating.rating).combineByKey(

(rating: Int) => (rating, 1),

(comb: (Int, Int), rating) => (comb._1 + rating, comb._2 + 1),

comb._2)).map(idRatingSum => (idRatingSum._1, idRatingSum._2._1/ idRatingSum._2._2))

.filter(avgId => avgId._2 > 10)

scala> val aux2 = aux1.join(moviesRdd.map(movie => (movie.idMovie, (movie.name, movie.gender))))

scala> aux2.map(idAvgNameGender => (idAvgNameGender._2._1, idAvgNameGender._2._2))

.sortByKey(false).map(avgId => (avgId._2, avgId._1)).collect.head

Spark Sql

* Saca el nombre y género de la película con mejor media

scala> val aux1 = ratingRdd.map(rating => (rating.movieId, rating.rating).combineByKey(

(rating: Int) => (rating, 1),

(comb: (Int, Int), rating) => (comb._1 + rating, comb._2 + 1),

comb._2)).map(idRatingSum => (idRatingSum._1, idRatingSum._2._1/ idRatingSum._2._2))

.filter(avgId => avgId._2 > 10)

scala> val aux2 = aux1.join(moviesRdd.map(movie => (movie.idMovie, (movie.name, movie.gender))))

scala> aux2.map(idAvgNameGender => (idAvgNameGender._2._1, idAvgNameGender._2._2))

.sortByKey(false).map(avgId => (avgId._2, avgId._1)).collect.head

Spark Sql

Proyecto: FlightsDataset: AirlinesObjetivo: Rellenar los métodos de una DSL en Scala y que los tests pasen correctamente.

Repositorio: https://github.com/SparkCodemotion/Flights

Spark Sql

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

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

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

Spark Streaming

Spark Sql

import org.apache.spark.sql.functions._

import sqlContext.implicits._

val moviesDF = sc.textFile("/home/gmunoz/datasets/ml/movies.dat")

.map( line => line.split("::")).map(m => Movie(m(0).toInt,m(1),m(2))).toDF().cache()

val tagsDF = sc.textFile("/home/gmunoz/datasets/ml/tags.dat")

.map( line => line.split("::")).map(t =>

Tag(t(0).toInt,t(1).toInt,t(2),t(3).toLong)).toDF().cache()

val ratingsDF = sc.textFile("/home/gmunoz/datasets/ml/ratings.dat")

.map( line => line.split("::")).map(r =>

Rating(r(0).toInt,r(1).toInt,r(2).toFloat,r(3).toLong)).toDF().cache()

Spark Sql

ratingsDF.select('movieId).groupBy('movieId).agg(count('movieId) as "count").sort('count.desc)

.join(moviesDF.select('name, 'movieId), moviesDF("movieId") === ratingsDF("movieId"),

joinType = "inner")

.select('name, 'count).show(1)

Spark Sql

* Saca el nombre de la película más votada

joinType = "inner")

Spark Sql

joinType = "inner")

ratingsDF.select('movieId,'rating).groupBy('movieId).agg(avg('rating) as "avg", count('rating)

as "count")

.filter('count > 10)

.sort('avg.desc)

.join(moviesDF.select('name, 'movieId, 'genre), moviesDF("movieId") ===

ratingsDF("movieId"), joinType = "inner")

.select('name, 'genre, 'avg).show(2)

Spark Sql

joinType = "inner")

* Saca el nombre y género de la película con mejor media

ratingsDF.select('movieId,'rating).groupBy('movieId).agg(avg('rating) as "avg", count('rating)

as "count")

.filter('count > 10)

.sort('avg.desc)

.join(moviesDF.select('name, 'movieId, 'genre), moviesDF("movieId") ===

ratingsDF("movieId"), joinType = "inner")

.select('name, 'genre, 'avg).show(2)

Spark Streaming

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

SPARK STREAMING OVERVIEW

Spark Streaming

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.

• map(func),

• flatMap(func),

• filter(func),

• count()

• repartition(numPartitions)

• union(otherStream)

• reduce(func),

• countByValue(),

• reduceByKey(func, [numTasks])

• join(otherStream, [numTasks]),

• transform()

• window(windowLength, slideInterval)

• countByWindow(windowLength, slideInterval)

• reduceByWindow(func, windowLength, slideInterval)

• reduceByKeyAndWindow(func, windowLength, slideInterval, [numTasks])

• countByValueAndWindow(windowLength, slideInterval, [numTasks])

• print()

• foreachRDD(func)

• saveAsObjectFiles(prefix, [suffix])

• saveAsTextFiles(prefix, [suffix])

• saveAsHadoopFiles(prefix, [suffix])

TransformRDD ForeachRDD

def transform[U](transformFunc: (RDD[T]) ⇒ RDD[U]) : DStream[U]

def foreachRDD(foreachFunc: (RDD[T], Time) ⇒ Unit): Unit

• Mezclar batch con streaming• Usar DataFrames en Streaming• Machine Learning en Streaming• Reusar código existente de Batch

• Enviar datos a sistemas externos (ej. DB)• Usar datasources de Spark SQL

Spark Streaming

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.

Spark Streaming

UpdateStateByKey ReduceByKeyAndWindow

def updateStateByKey[S](updateFunc: (Seq[V], Option[S])

⇒ Option[S])def reduceByKeyAndWindow(reduceFunc: (V, V) ⇒ V,

windowDuration: Duration)

• Para cada clave K mantiene un Option[S]• Option a None elimina el estado.

• Es igual que un reduceByKey pero adicionalmente toma una ventana de tiempo.

Spark Streaming

Spark SQL Spark MLlib

Spark Sql

val sparkConf = new SparkConf().setAppName("TwitterPopularTags")

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()

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 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 taller. No obstante pasamos ahora a enumerar los

distintos algoritmos soportados por MlLib

Classification and regression

linear models (SVMs, logistic regression, linear regression)

naive Bayes

decision trees

ensembles of trees (Random Forests and Gradient-Boosted Trees)

isotonic regression

Dimensionality reduction

singular value decomposition (SVD)

principal component analysis (PCA)

Feature extraction and transformation

Frequent pattern mining

FP-growth

association rules

PrefixSpan

Collaborative filtering

alternating least squares (ALS)

Clustering

k-means

Gaussian mixture

power iteration clustering (PIC)

latent Dirichlet allocation (LDA)

streaming k-means

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)

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")

Spark Hands-on

Data & Analytics

Transcript of Spark Hands-on

Tytuł oryginału: Hands-On Machine Learning with Scikit ... · Dlaczego warto korzystać z uczenia maszynowego? 24 ... Uczenie sieci MLP za pomocą zaawansowanego interfejsu API

New Golden Media 990 CR HD PVR Spark LX Œ czyli Spark lub … Media 990 CR.pdf · 2011. 5. 27. · TECHNIKA 06.11 Ł TV-Sat Magazyn 9 bel zasilaj„cy 230 V, a w prawym rogu pojawiaj„cy

Poster Misi on Nut Rici On

Ms Spark Meeting - Cube Root

Tytuł oryginału: Database Design for Mere Mortals · Tytuł oryginału: Database Design for Mere Mortals: A Hands-On Guide to Relational Database Design (3rd Edition) Tłumaczenie:

EGEE-II INFSO-RI-031688 Enabling Grids for E-sciencE Data Management cluster summary Krzysztof Nienartowicz JRA1 All Hands meeting, Helsinki.

Rekurencyjne sieci neuronowe, LSTM i GRU · Hands-On Machine Learning with Scikit-Learn and TensorFlow: Concepts, Tools, and Techniques to Build Intelligent Systems, O’Reilly Media,

Shake Hands nr 9

Odprawa techniczna Gdynia, 9.08 · 2020. 9. 3. · Race Office –rules Approach the race office at the time declared in the survey. Put on a mask or visor, disinfect your hands,

Shake hands nr. 3

Beneath RDD in Apache Spark by Jacek Laskowski

Tchaikovski Romeo Et Juliette Piano 4 Hands

Sr Spark Cpt -14 Paper

spark k 39143 mifrat a 1 7/19/11 5:21:15 PMcertified.chevrolet.co.il/Models/Chevrolet/Spark/2011/Specification2011.pdf · umi.co.il chevrolet.co.il spark_k_39143_mifrat_a 4 7/19/11

02501484 Spark - Roxell

InfoMEET Katalog Katowice › wp-content › uploads › 2019 › 06 › ... · twórca rozwiązań open-source oraz aplikacji mobilnych. TEMAT Hands-on Azure DevOps – create, build

Porównanie wydajności i produktywności algorytmu tworzenia ...zeszyty-naukowe.wwsi.edu.pl/zeszyty/zeszyt15/Porownanie_wydajno… · stępu do danych. Podobnie jak środowisko Spark,

Le Corbusier's Hands

SPARK RC JR

Spark - Space