Computación distribuida usando Python

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

Transcript

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

   View Slide

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
   

   View Slide

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
   

   View Slide

4. Introducción a la computación distribuida
   

   View Slide

5. Introducción a la computación distribuida
   

   View Slide

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

   View Slide

7. Comparando tecnologías de computación distribuida
   

   View Slide

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
   

   View Slide

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

   View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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
    

    View Slide

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.
    

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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.
    

    View Slide

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

    View Slide

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
    

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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
    

    View Slide

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++
    

    View Slide

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

    View Slide

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

    View Slide

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
    

    View Slide

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

    View Slide

35. Casos de uso en proyectos Big Data
    

    View Slide

36. Casos de uso en proyectos Big Data
    

    View Slide

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

    View Slide

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

    View Slide

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.
    

    View Slide

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.
    

    View Slide

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
    

    View Slide