Transformaciones y Acciones en Apache Spark

Clase 7 de 25 • Curso de Databricks: Arquitectura Delta Lake

Resumen

¿Qué son las transformaciones en Apache Spark?

Las transformaciones en Apache Spark son esenciales para la manipulación y procesamiento de datos. Son modificaciones aplicadas a objetos dentro de este framework de procesamiento de datos distribuido. Imagina que tienes un objeto y decides aplicarle una serie de operaciones o transformaciones. Spark ofrece dos tipos de transformaciones: las nativas y las definidas por el usuario, conocidas como UDF (User Defined Functions).

¿Cuál es la diferencia entre transformaciones nativas y definidas por el usuario?

Transformaciones nativas: Estas son las funciones propias que Apache Spark ya ofrece. Ejemplos populares incluyen filter y map. Estas funciones están optimizadas para trabajar con datos y son altamente eficientes.
User Defined Functions (UDF): Son funciones personalizadas creadas por el usuario para realizar transformaciones específicas que no están cubiertas por las funciones nativas de Spark. Las UDF permiten flexibilidad, pero pueden ser menos eficientes que las transformaciones nativas.

¿Qué significa Lazy Evaluation en Spark?

Un concepto crucial en Spark es el de Lazy Evaluation o evaluación perezosa. Esto significa que las transformaciones no se ejecutan inmediatamente, sino que se acumulan hasta que una acción las desencadena. Solo al ejecutar una acción, Spark llevará a cabo todas las transformaciones asociadas, generando así las variables necesarias en memoria. Este enfoque asegura que el uso de recursos sea eficiente, evitando la ejecución innecesaria de transformaciones.

¿Cómo influyen las acciones en las transformaciones de Spark?

Las acciones en Apache Spark son operaciones que desencadenan la ejecución de todas las transformaciones acumuladas. Cuando se invoca una acción, como count o collect, Spark ejecuta las transformaciones predefinidas, creando las variables necesarias en memoria RAM. Es esencial ser cuidadoso al usar acciones, dado que pueden consumir recursos significativos y afectar el rendimiento de tu clúster.

¿Cuál es la importancia del uso de RAM en Spark?

Spark está diseñado para utilizar intensivamente la memoria RAM. La ejecución eficiente de transformaciones y acciones depende en gran medida de una gestión óptima de los recursos de memoria. Es por eso que entender cómo y cuándo usar transformaciones y acciones puede marcar una gran diferencia en el rendimiento de tus aplicaciones en Spark.

Ejemplo práctico de transformaciones y acciones

Transformaciones: Supongamos que tienes tres transformaciones a aplicar: un filter, un map y un flatMap. Estas transformaciones se acumulan sin ejecutarse.

Acción: Una vez que decides invocar una acción, por ejemplo, collect, Spark ejecuta todas las transformaciones acumuladas. Este proceso da como resultado la creación de variables necesarias en RAM, optimizando el procesamiento distribuido.

Recomendaciones para el manejo de acciones y transformaciones

Optimizaciones en UDF: Aunque son flexibles, deben usarse con moderación debido a sus menores niveles de eficiencia comparados con las transformaciones nativas.
Control de acciones: Dado que las acciones desencadenan la ejecución acumulada de transformaciones, es fundamental ser selectivo y consciente al utilizarlas para no agotar recursos innecesariamente.
Ampliar conocimiento en Wide y Narrow Transformations: Estos conceptos son claves para entender cómo las transformaciones afectan el movimiento de datos y el uso de recursos en Spark.

Explorar la documentación oficial de Apache Spark y practicar con ejercicios prácticos enriquecen el aprendizaje. Aprovecha los recursos adicionales para seguir avanzando y dominar las características avanzadas de este poderoso framework.

Emmanuel Aguilar

student•

¿Que son las transformaciones y acciones en Apache Spark?

En apache spark, las transformaciones y las acciones son dos tipos de operaciones que se pueden realizar sobre los RRDs (Resilient Distributed Datasets), que son las colecciones distribuidas y toleranes a fallos de elementos que pueden ser procesados en paralelo.

Transformaciones

Son operaciones que se aplican a un RDD y devuelven un nuevo RDD. Son operaciones “perezosas” (lazy), lo qye significa que no se ejecutan inmediatamente sino que Spark optimiza y planifica su ejecución hasta que se necesita producir un resultado.

En Apache Spark, las transformaciones se clasifican en dos tipos:

Narrow TransformationSon aquellas en que cada partición del nuevo RDD (Resilient Distributed Dataset) generado depende solo de una única partición del RDD original. Es decir, para realizar la transformación, Spark no necesita los datos de otras particiones, lo cual se traduce en menos movimientos de datos a traves del cluster. Estos hace que las Narrow Transformation senas eficientes y rapidas
Wide TransformationSon aquellas en las que los registros de salida pueden depender de registros de múltiples particiones del RDD original. En otras paalabras, estas transformaciones requieren que los datos se muevan (shuffled) entre distintas particiones y posiblemente entre diferentes nodos del cluster, lo cual puede ser costos en terminos de tiempo de computación debido al movimiento de red y a la escritura/lectura de disco implicada.Algunos ejemplos de Wide Transformations inclyen:
- groupBy y reduceByKeyAgrupan elementos por clave y pieden requerir que los datos con la misma clave se muevan a la misma partición para ser procesados juntos.
- joinUne dos RDDs por clave y puede requerir qye los registros con claves coincidientes se encuentren en la misma partición

En resumen, la diferencia clave entre “Narrow” y “Wide” Transformations reside en cómo las particiones de datos interactuan entre si durante la transformación.

Las “Narrow” requieren menos recursos y son más rápidas, ya que tranajan dentro de las particiones locales de datos.

Las “Wide” son más costosas en tperminos de recuros y tiempo, ya que implican una reorganización mas amplia y global de los datos a través del cluster.

Algunas transformaciones nativas más comunes:

map: aplica una función a cada elemento del RDD y devuelve un nuevo RDD con los emementos transformados.
filtrer: devuelve un nuevo RDD conteniendo solo aquellos elementos que cumplen una condición especifica
flatMap: similar a map, pero cada elemento de entrada puede mapearse a cero o más elementos de salida (aplanando los resultados en un nuevo RDD)
distinct: devuelve un nuevo RDD con elementos únicos.
sample: devuelve un subconjunto aleatorio de elementos de un RDD.

Acciones

Son operaciones son operaciones que desencadenan la ejecución y devuelven un valor al driver de Spark. Las acciones son las que producen un resultado a partir de la computación del RDD.

Algunas acciones comunes incluyen:

collect: devuelve todos los elementos de un RDD como un arreglo al driver
count: cuenta el número de elementos en un RDD.
take: devuelve los primeros n elementos de un RDD
reduce: combina los elementos de un RDD de forma especifica para un unico valor.
foreach: aplica una función a cada elemento de un RDD sin devolver un valor.

La interacción entre transformaciones y acciones es clave en Spark. Las transformaciones construyen un plan de ejcución, pero hasta que no se llama a una acción, Spark no ejecuta las operaciones. Esto permite a spark realizar una aplicación eficiente de la computación y optimzar el rendimiento general de la aplicación.

Layla Scheli

teacher•

Gracias :)

Nicolás Mantilla

student•

No se si me equivoco pero yo asemejo los comportamiento de las transformaciones a las funciones en SQL, tomando como analogía la transformación map a la función 'case', la transformación filtrer a la función where, flatmap a case anidados, distinct a select distinct.

Gerardo Mayel Fernández Alamilla

student•

hay un curso muy bueno aquí en PLatzi muy bueno por cierto se llama Spark para big data

JUAN DIEGO CUERVO GUTIERREZ

student•

No estoy de acuerdo, ese curso está muy desactualizado

Juliana Castillo Araujo

Team Platzi•

Es interesante conocer las transformaciones necesarias para tomar acciones en spark ⚡️

Layla Scheli

teacher•

Gracias Juliana, efectivamente es asi :)

Mario Alexander Vargas Celis

student•

En Apache Spark, las transformaciones y acciones son los dos tipos principales de operaciones que se pueden realizar sobre un conjunto de datos distribuido (RDD, DataFrame o Dataset). Estas operaciones son fundamentales para realizar análisis y procesamiento de datos.

Transformaciones

Definición: Operaciones que crean un nuevo conjunto de datos a partir de uno existente, sin ejecutarse de inmediato. Son perezosas (lazy), lo que significa que Spark no las evalúa hasta que se llama a una acción.
Propósito: Especificar cómo transformar los datos, pero no realizar la transformación hasta que sea necesario.
Ejemplos:
1. map(función): Aplica una función a cada elemento del conjunto de datos y devuelve un nuevo RDD o DataFrame.
2. filter(función): Devuelve un nuevo conjunto de datos que contiene solo los elementos que cumplen con una condición.
3. flatMap(función): Similar a map, pero puede devolver múltiples valores por elemento (aplana los resultados).
4. groupByKey(): Agrupa los datos por clave.
5. reduceByKey(función): Combina los valores de cada clave usando una función.
6. distinct(): Elimina duplicados del conjunto de datos.
7. join(otherDataset): Une dos conjuntos de datos.
Resultado: Un nuevo conjunto de datos (RDD, DataFrame o Dataset).

Acciones

Definición: Operaciones que devuelven un resultado final o un efecto secundario (como guardar datos). Son evaluadas inmediatamente y desencadenan la ejecución de las transformaciones acumuladas.
Propósito: Recuperar datos o realizar tareas concretas, como almacenar resultados o calcular estadísticas.
Ejemplos:
1. collect(): Devuelve todos los elementos como una colección al controlador (driver).
2. count(): Devuelve el número total de elementos en el conjunto de datos.
3. take(n): Recupera los primeros n elementos.
4. saveAsTextFile(path): Guarda los datos en un archivo de texto en el sistema de archivos.
5. reduce(función): Aplica una función para combinar los elementos y devolver un único valor.
6. foreach(función): Aplica una función a cada elemento del conjunto de datos (no devuelve nada).

Diferencias Clave

AspectoTransformacionesAccionesEvaluaciónPerezosa (lazy).Inmediata.ResultadoNuevo conjunto de datos.Resultado final o efecto secundario.PropósitoDefinir la lógica del cálculo.Obtener o guardar datos.Ejemplos comunesmap, filter, reduceByKey.collect, count, saveAsTextFile.

Cómo funcionan juntas

Las transformaciones se encadenan para definir un flujo de procesamiento.
Una acción desencadena la ejecución del flujo completo.

Ejemplo:

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("TransformacionesYAcciones").getOrCreate()

# Crear un RDD data = [1, 2, 3, 4, 5] rdd = spark.sparkContext.parallelize(data)

# Transformaciones (no ejecutadas aún) rdd_filtered = rdd.filter(lambda x: x % 2 == 0) # Filtrar números pares rdd_squared = rdd_filtered.map(lambda x: x**2) # Elevar al cuadrado

# Acción (se ejecuta todo el flujo) result = rdd_squared.collect() print(result) # Output: [4, 16]

En este ejemplo:

Las transformaciones (filter y map) definen cómo procesar los datos.
La acción (collect) desencadena la ejecución y devuelve el resultado.

Daniel Santiago Merchán

student•

Transformaciones Narrow

Las transformaciones Narrow son aquellas en las que cada partición del RDD (Resilient Distributed Dataset) de entrada se mapea a una única partición en el RDD de salida. Esto significa que no se requiere un movimiento de datos entre particiones. Ejemplos comunes incluyen funciones como map y filter.

Transformaciones Wide

Las transformaciones Wide requieren que Spark reorganice los datos entre particiones, lo que puede implicar un shuffle. Esto ocurre cuando se necesita combinar datos de diferentes particiones. Ejemplos comunes incluyen reduceByKey, groupBy, o join

Luis Quiroz Prada

student•

Las funciones filter, map y flatMap son transformaciones que operan sobre Resilient Distributed Datasets (RDDs). Aquí está lo que hacen:

- filter(func): Esta función devuelve un nuevo RDD formado por seleccionar solo los elementos del RDD de origen en los que func devuelve True. Es similar a la función filter() en Python.


\# Ejemplo en Spark

rdd = sc.parallelize(\[1, 2, 3, 4, 5])

filtered\_rdd = rdd.filter(lambda x: x % 2 == 0)  # Filtra los números pares

- map(func): Esta función devuelve un nuevo RDD formado al pasar cada elemento del RDD de origen a través de una función func. Es similar a la función map() en Python.


\# Ejemplo en Spark

rdd = sc.parallelize(\[1, 2, 3, 4, 5])

mapped\_rdd = rdd.map(lambda x: x \* 2)  # Multiplica cada número por 2

- flatMap(func): Similar a map(), pero cada entrada en el RDD de origen puede ser asignada a múltiples elementos de salida (0 o más). Después de aplicar la función, los resultados se aplanan en un nuevo RDD.


\# Ejemplo en Spark

rdd = sc.parallelize(\["hello world", "I am learning Spark"])

flatmapped\_rdd = rdd.flatMap(lambda x: x.split(" "))  # Divide cada frase en palabras

En todos los ejemplos, sc es una instancia de SparkContext.

Daniel Guardia

student•

ya pero sin chatgpt pues

Ruben Dario Toro Gutierrez

student•

Narrow transformation (Transformación estrecha) es una transformación en la que cada partición del RDD de salida depende solo de una o muy pocas particiones del RDD de entrada, no requiere mezclar datos de múltiples particiones para producir un resultado. Al no requerir mezclar datos las Narrow transformation en general son más eficientes que las wide transformation. Algunos ejemplos serían map(), filter(), sample().

Wide transformation (Transformación amplia) cada partición del RDD de salida puede depender de muchas particiones del RDD de entrada, por lo que es necesario mezclar o redistribuir datos entre las particiones. Ejemplos: groupByKey(), join().

Jhon Alexander Túquerres Jiménez

student•

Analyzing Data with SQL and Visualizations in Databricks

https://www.youtube.com/watch?v=3DZQopaf8xA

Jhon Alexander Túquerres Jiménez

student•

Working with Data in Databricks (Free Edition)

https://www.youtube.com/watch?v=QSzqvW4amMc

Wilder Leoncio Correa Sánchez

student•

Resilient Distributed Datasets (RDD) es un concepto clave en el ecosistema de Apache Spark, una plataforma de procesamiento de datos de código abierto. Los RDD son colecciones inmutables y distribuidas de elementos que pueden ser procesados en paralelo a través de un clúster de máquinas.

Las principales características de los RDD son:

Inmutabilidad: Los RDD son conjuntos de datos inmutables, lo que significa que una vez creados, no pueden ser modificados. Esto permite la recuperación eficiente de datos en caso de fallo.
Transformaciones y acciones: Los RDD admiten dos tipos de operaciones: transformaciones (que crean nuevos RDD a partir de los existentes) y acciones (que devuelven un valor al controlador).
Particionamiento y paralelismo: Los RDD se dividen en particiones que se pueden procesar en paralelo en un clúster de máquinas, lo que permite un procesamiento eficiente de grandes volúmenes de datos.
Persistencia y caché: Los RDD pueden ser persistidos en la memoria o en el disco para mejorar el rendimiento de las consultas repetidas.
Tolerancia a fallos: Si una partición de un RDD se pierde, Spark puede reconstruirla a partir de los RDD de los que depende, gracias a su linaje.

Estas características hacen que los RDD sean una herramienta poderosa para el procesamiento de datos a gran escala de manera eficiente y confiable.

Catalina Hernandez

student•

Catalina Hernandez

student•

Brenda Odeth Lemus Vallarta

student•

Existen dos tipos de transformaciones en Apache Spark: Wide y Narrow.

Narrow Transformations: En este tipo, cada partición de entrada produce exactamente una partición de salida. No requiere que Spark redistribuya los datos entre particiones, lo que lo hace más eficiente. Ejemplos incluyen map y filter.
Wide Transformations: Aquí, los datos deben ser reagrupados, lo que implica que las particiones de entrada pueden producir múltiples particiones de salida. Esto puede requerir un proceso de "shuffle" en el que los datos se redistribuyen, como en groupByKey o reduceByKey.

Comprender esta diferencia es crucial para optimizar el rendimiento de tus aplicaciones en Spark.