¿Qué son las transformaciones y acciones en Spark?

# ¿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 Transformation**Son 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 Transformation**Son 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 **reduceByKey**Agrupan elementos por clave y pieden requerir que los datos con la misma clave se muevan a la misma partición para ser procesados juntos. * **join**Une 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.

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

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

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** AspectoTransformacionesAcciones**Evaluación**Perezosa (lazy).Inmediata.**Resultado**Nuevo conjunto de datos.Resultado final o efecto secundario.**Propósito**Definir la lógica del cálculo.Obtener o guardar datos.**Ejemplos comunes**`map`, `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.

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

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. ```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. ```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. ```python \# 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`.

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