Computación distribuida usando Python

Computación distribuida
usando Python
José Manuel Ortega Candel

Agenda
● Introducción a la computación distribuida
● Comparando tecnologías de computación
distribuida
● Frameworks y módulos en Python para
computación distribuida
● Casos de uso en proyectos Big Data

Introducción a la computación distribuida
● Grandes volúmenes de datos
● Necesidad de procesar esos datos de
manera rápida
● Tipos de datos complejos

● Deslocalización
● Velocidad
● Recursos compartidos
● Tolerancia a fallos

Comparando tecnologías de computación distribuida

Comparando tecnologías de computación distribuida
Apache Hadoop Apache Spark Apache Flink
Velocidad de
procesamiento
Más lento que Spark
y Flink
100 veces más rápido
que Hadoop
Más rápido que Spark
Modelo de
programación
Map Reduce RDD(Conjuntos de
datos resilientes)
Flujos de datos
Procesamiento de
datos
Por lotes Por micro-lotes y
secuencial*
Por lotes
Soporte Streaming N/A Spark Streaming Flink Streaming
Soporte ML N/A Spark ML Flink ML

Frameworks y módulos en Python para computación distribuida

● Velocidad: procesamiento en memoria
● Ejecución perezosa(Lazy execution)
● Map-Reduce

● DAG — Directed Acyclic Graph

from pyspark import SparkContext
sc = SparkContext.getOrCreate()
from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()
spark = SparkSession.builder.getOrCreate()
sc = spark.sparkContext

● RDD (Resilient Distributed Dataset)
● Transformaciones: tras aplicar una transformación,
obtenemos un nuevo y modiﬁcado RDD basado en el
original.
● Acciones: una acción consiste en aplicar una
operación sobre un RDD y obtener un valor como
resultado, que dependerá del tipo de operación.

lista = ['uno','dos','dos','tres','cuatro']
listardd = sc.parallelize(lista)
listardd = sc.parallelize(lista,4)
print(listardd.collect()) # Visualizar la colección RDD
rdd_fichero = sc.textFile("/home/fichero.txt")
rdd_text = sc.parallelize(['red', 'red', 'blue', 'green', 'green','yellow'])
rdd_aux = rdd_text.map(lambda x: (x,1))
rdd_result = rdd_aux.reduceByKey(lambda x,y: x+y)
print (rdd_result.collect())
[('blue', 1), ('green', 2), ('yellow', 1), ('red', 2)]

● groupByKey(),reducesByKey()
● ﬁlter(),map,ﬂatMap()

Sobre los RDD de pares, podemos realizar las siguientes
transformaciones:
● keys: devuelve las claves
● values: devuelve los valores
● mapValues: Aplica la función sobre los valores
● flatMapValues: Aplica la función sobre los valores y los
aplana.

listaTuplas = [('a',1), ('z',3), ('b',4), ('c',3), ('a',4)]
rddTuplas= sc.parallelize(listaTuplas)
claves = rddTuplas.keys() # ['a', 'z', 'b', 'c', 'a']
valores = rddTuplas.values() # [1, 3, 4, 3, 4]
rddMapValues = rddTuplas.mapValues(lambda x: (x,x*2))
# [('a', (1, 2)), ('z', (3, 6)), ('b', (4, 8)), ('c', (3, 6)), ('a', (4, 8))]
rddFMV = rddTuplas.flatMapValues(lambda x: (x,x*2))
# [('a', 1),
# ('a', 2),
# ('z', 3),
# ('z', 6),
# ('b', 4),

# Iniciamos Spark de manera local
spark = (SparkSession
.builder
.master("local[*]")
.appName("Hola Mundo")
.getOrCreate())
# Paralelizamos una lista del 0 al 9 y computamos la suma de los números
result = (spark
.sparkContext
.parallelize(range(10))
.reduce(lambda x, y: x + y))
# Imprimimos el resultado
print(f"La suma es {result}")
$ spark-submit script.py

https://colab.research.google.com/drive/1G894WS7ltIUTusWWmsCnF_zQhQqZCDOc

https://github.com/dask/distributed

● Lazy execution
○ compute()
○ persistent()
○ head()

https://distributed.dask.org/en/stable/examples/word-count.html
import hdfs3
from collections import defaultdict, Counter
from distributed import Client
from distributed.diagnostics.progressbar import progress
hdfs = hdfs3.HDFileSystem('NAMENODE_HOSTNAME', port=NAMENODE_PORT)
client = Client('SCHEDULER_IP:SCHEDULER:PORT')
filenames = hdfs.glob('/tmp/enron/*/*')
print(filenames[:5])
print(hdfs.head(filenames[0]))

def count_words(fn):
word_counts = defaultdict(int)
with hdfs.open(fn) as f:
for line in f:
for word in line.split():
word_counts[word] += 1
return word_counts
counts = count_words(filenames[0])
print(sorted(counts.items(), key=lambda k_v: k_v[1], reverse=True)[:10])
future = client.submit(count_words, filenames[0])
counts = future.result()
print(sorted(counts.items(), key=lambda k_v: k_v[1], reverse=True)[:10])

futures = client.map(count_words, filenames)
len(futures)
futures[:5]
progress(futures)
def top_items(d):
items = sorted(d.items(), key=lambda kv: kv[1], reverse=True)[:10000]
return dict(items)
futures2 = client.map(top_items, futures)
results = client.gather(iter(futures2))
all_counts = Counter()
for result in results:
all_counts.update(result)
print(len(all_counts))
print(sorted(all_counts.items(), key=lambda k_v: k_v[1], reverse=True)[:10])

● Documentación https://docs.dask.org
● Dask.distributed https://distributed.dask.org
● Blog de desarrollo https://blog.dask.org
● Algoritmos de Machine Learning implementados
en Dask https://github.com/dask/dask-ml

Apache Spark Dask
Modelo de programación Map Reduce Tasks
DataFrames Spark DataFrame tiene
su propia API y modelo
de memoria
Dask DataFrame
reutiliza la API y el
modelo de memoria de
Pandas.
Soporte ML Mllib Dask ML
Soporte lenguajes Scala,Python,R Python,C,C++

Casos de uso en proyectos Big Data
● Procesamiento en streaming

● Structured Streaming

spark = SparkSession
.builder
.appName("Streaming WordCount")
.master("local[2]")
.getOrCreate()
# Creamos un flujo de escucha sobre netcat en localhost:9999
# En Spark Streaming, la lectura se realiza mediante readStream
lineasDF = spark.readStream
.format("socket")
.option("host", "localhost")
.option("port", "9999")
.load()
$ nc -lk 9999

# Leemos las líneas y las pasamos a palabras.
# Sobre ellas, realizamos la agrupación count (transformación)
from pyspark.sql.functions import explode, split
palabrasDF = lineasDF.select(explode(split(lineasDF.value, ' ')).alias('palabra'))
cantidadDF = palabrasDF.groupBy("palabra").count()
# Mostramos las palabras por consola
# En Spark Streaming, la persistencia se realiza mediante writeStream y en vez de
realizar un save, ahora utilizamos start
wordCountQuery = cantidadDF.writeStream
.format("console")
.outputMode("complete")
.start()
# dejamos Spark a la escucha para que cierre el el flujo cuando termine de procesar
wordCountQuery.awaitTermination()

● Construcción de ETL(Extract, Transform y Load)

Conclusiones
● La distribución de la carga de trabajo entre los
distintos nodos de un cluster en una solución Big
Data, permite realizar las tareas en paralelo,
consiguiendo grandes mejoras en la eﬁciencia de los
procesos.
● La computación distribuida es más eﬁciente en
escenarios con unos cálculos a realizar sobre un gran
conjunto de datos. De esta manera se paraleliza el
trabajo y se reduce el tiempo total de cálculo.

Conclusiones
● A la hora de diseñar la arquitectura de un sistema Big
Data, es conveniente tener en cuenta el grado de
paralelización de las tareas, que será función del número
de procesadores y cores disponibles en el sistema. Si el
grado de paralelización es bajo, el rendimiento en según
qué tareas, puede acabar siendo también muy bajo.
● Con soluciones como PySpark y Dask podemos realizar
cálculos y transformaciones sobre grandes volúmenes de
datos, de forma distribuida sobre un cluster y trabajar con
procesamiento en paralelo.

¡Gracias!
@jmortegac
https://www.linkedin.com/in/j
mortega1
https://jmortega.github.io
https://www.ra-ma.es/libro/big-data-ma
chine-learning-y-data-science-en-pytho
n_145747

Computación distribuida usando Python

Más contenido relacionado

Similar a Computación distribuida usando Python

Más de Jose Manuel Ortega Candel

Último

Computación distribuida usando Python