La computación distribuída es un nuevo modelo de computación que surgió con el objetivo de resolver problemas de computación masiva donde diferentes máquinas trabajan en paralelo formando un clúster de computación. En los últimos años han surgido diferentes frameworks como Apache Hadoop, Apache Spark y Apache Flink que permiten resolver este tipo de problemas donde tenemos datos masivos desde diferentes fuentes de datos. Dentro del ecosistema de Python podemos destacar las librerías de Pyspark y Dask de código abierto que permiten la ejecución de tareas de forma paralela y distribuida en Python. Entre los puntos a tratar podemos destacar: 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

1. Computación distribuida
usando Python
José Manuel Ortega Candel

2. 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

3. 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

4. Introducción a la computación distribuida

5. Introducción a la computación distribuida

6. Introducción a la computación distribuida
● Deslocalización
● Velocidad
● Recursos compartidos
● Tolerancia a fallos

7. Comparando tecnologías de computación distribuida

8. 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

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

10. Frameworks y módulos en Python para computación distribuida
● Velocidad: procesamiento en memoria
● Ejecución perezosa(Lazy execution)
● Map-Reduce

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

12. Frameworks y módulos en Python para computación distribuida
● DAG — Directed Acyclic Graph

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

14. Frameworks y módulos en Python para computación distribuida
from pyspark import SparkContext
sc = SparkContext.getOrCreate()
from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()
from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()
sc = spark.sparkContext

15. Frameworks y módulos en Python para computación distribuida
● RDD (Resilient Distributed Dataset)
● Transformaciones: tras aplicar una transformación,
obtenemos un nuevo y modificado 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.

16. Frameworks y módulos en Python para computación distribuida
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)]

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

18. Frameworks y módulos en Python para computación distribuida
● groupByKey(),reducesByKey()
● filter(),map,flatMap()

19. Frameworks y módulos en Python para computación distribuida
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.

20. Frameworks y módulos en Python para computación distribuida
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),

21. Frameworks y módulos en Python para computación distribuida
from pyspark.sql import SparkSession
# 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

22. Frameworks y módulos en Python para computación distribuida
https://colab.research.google.com/drive/1G894WS7ltIUTusWWmsCnF_zQhQqZCDOc

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

24. Frameworks y módulos en Python para computación distribuida
https://github.com/dask/distributed

25. Frameworks y módulos en Python para computación distribuida
● Lazy execution
○ compute()
○ persistent()
○ head()

26. Frameworks y módulos en Python para computación distribuida
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]))

27. Frameworks y módulos en Python para computación distribuida
https://distributed.dask.org/en/stable/examples/word-count.html
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])

28. Frameworks y módulos en Python para computación distribuida
https://distributed.dask.org/en/stable/examples/word-count.html
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])

29. Frameworks y módulos en Python para computación distribuida
● 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

30. Frameworks y módulos en Python para computación distribuida
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++

31. Casos de uso en proyectos Big Data
● Procesamiento en streaming

32. Casos de uso en proyectos Big Data
● Structured Streaming

33. Casos de uso en proyectos Big Data
from pyspark.sql import SparkSession
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

34. Casos de uso en proyectos Big Data
# 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()

35. Casos de uso en proyectos Big Data

36. Casos de uso en proyectos Big Data

37. Casos de uso en proyectos Big Data
● Construcción de ETL(Extract, Transform y Load)

38. Casos de uso en proyectos Big Data
● Construcción de ETL(Extract, Transform y Load)

39. 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 eficiencia de los
procesos.
● La computación distribuida es más eficiente 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.

40. 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.

41. ¡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