Las transformaciones y acciones en Spark se presentan como una gran estrategia para el análisis de la información dentro del mundo Big Data. Su desarrollo resulta necesario si planeas emplear este sistema de computación Apache Spark.
Por esta razón, desde KeepCoding te introducimos a cuáles son las transformaciones y acciones en Spark como parte del mundo Big Data.
¿Cuáles son las Transformaciones y Acciones en Spark?
A continuación, te compartimos cuáles son las transformaciones y acciones en Spark, de manera que aprendas a emplearlo en tu procesamiento de datos.
Transformaciones en Spark
En primer lugar, dentro del transformaciones y acciones en Spark, se encuentran las funciones de transformaciones en Spark:
- map(func): devuelve un nuevo RDD tras pasar cada elemento del RDD original a través de una función. Acá vemos la opción de parallelize spark.
val v1 = sc.parallelize(List(2, 4, 8))
val v2 = v1.map(_ * 2)
v2.collect
res0: Array[Int] = Array(4, 8, 16)
- filter(func): realiza un filtrado de los elementos del RDD original para devolver un nuevo RDD con los datos filtrados. Acá vemos la opción de parallelize spark.
val v1 = sc.parallelize(List(“ABC”, “BCD”, “DEF”))
val v2 = v1.filter(_.contains(“A”))
v2.collect
res0: Array[String] = Array(ABC)
- flatMap(func): parecido a la operación map, pero esta función devuelve una secuencia de valores. Acá vemos la opción de parallelize spark.
val x = sc.parallelize(List(“Ejemplo proyecto Alejandro”,
“Hola mundo”), 2)
val y = x.map(x => x.split(” “)) // split(” “) returns an
array of words y.collect
res0: Array[Array[String]] = Array(Array(Ejemplo,
proyecto, Alejandro), Array(Hola, mundo))
val y = x.flatMap(x => x.split(” “))
y.collect
res1: Array[String] = Array(Ejemplo, proyecto,
Alejandro, Hola, mundo)
- mapPartitions (func): similar a la operación map, pero se ejecuta por separado en cada partición del RDD.
val a = sc.parallelize(1 to 9, 3)
def myfunc[T](iter: Iterator[T]) : Iterator[(T, T)] = { var
res = List[(T, T)]()
var pre = iter.next while (iter.hasNext)
{val cur = iter.next; res .::= (pre, cur)
pre = cur;} res.iterator}
a.mapPartitions(myfunc).collect
res0: Array[(Int, Int)] = Array((2,3), (1,2), (5,6), (4,5),
(8,9), (7,8))
- sample(withReplacement, fraction, seed): muestra una fracción de los datos, con o sin remplazo, utilizando una semilla que genera número aleatorios.
val randRDD = sc.parallelize(List( (7,”cat”), (6,
“mouse”),(7, “cup”), (6, “book”), (7, “tv”), (6, “screen”),
(7, “heater”)))
val sampleMap = List((7, 0.4), (6, 0.6)).toMap
randRDD.sampleByKey(false,
sampleMap,42).collect
res0: Array[(Int, String)] = Array((6,book), (7,tv),
(7,heater))
- union(otherDataset): devuelve un nuevo RDD con la unión de los elementos de los RDD seleccionados.
val a = sc.parallelize(1 to 3, 1) val b = sc.parallelize(5
to 7, 1) a.union(b).collect()
res0: Array[Int] = Array(1, 2, 3, 5, 6, 7)
- intersection(otherDataset): devuelve los elementos de los RDD que son iguales.
val x = sc.parallelize(1 to 20) val y = sc.parallelize(10
to 30) val z = x.intersection(y) z.collect
es0: Array[Int] = Array(16, 14, 12, 18, 20, 10, 13, 19,
15, 11, 17)
Acciones en Apache Spark
Estas hacen referencia a las funciones encontradas en Transformaciones y Acciones en Spark.
- reduce(func): agrega los elementos del dataset usando una función. Esta función debe ser conmutativa y asociativa para que pueda calcularse correctamente en paralelo.
val a = sc.parallelize(1 to 100, 3)
a.reduce(_ + _)
res0: Int = 5050
- collect(): convierte un RDD en un array y lo muestra en pantalla.
val c = sc.parallelize(List(“Gnu”,
“Cat”, “Rat”, “Dog”, “Gnu”, “Rat”),
2)
c.collect
res0: Array[String] = Array(Gnu,
Cat, Rat, Dog, Gnu, Rat)
- count(): devuelve el número de elementos del dataset.
val a = sc.parallelize(1 to 4)
a.count
res0: Long = 4
- first(): devuelve el primer elemento del conjunto de datos.
val c = sc.parallelize(List(“Gnu”,
“Cat”, “Rat”, “Dog”), 2)
c.first
res0: String = Gnu
- take(n): devuelve un array con los primeros elementos del dataset. Acá vemos la opción de parallelize en spark.
val b = sc.parallelize(List(“dog”,
“cat”, “ape”, “salmon”, “gnu”), 2)
b.take(2)
res0: Array[String] = Array(dog, cat)
- takeSample(withReplacement, num, [seed]): devuelve un array con una muestra aleatoria de elementos numéricos del dataset, con o sin sustitución, con la opción de especificar opcionalmente una semilla de generador de números aleatorios. Acá vemos la opción de parallelize en spark.
val x = sc.parallelize(1 to 200, 3)
x.takeSample(true, 20, 1)
res0: Array[Int] = Array(74, 164,
160, 41, 123, 27, 134, 5, 22, 185,
129, 107, 140, 191, 187, 26, 55,
186, 181, 60)
- takeOrdered(n, [ordering]): devuelve los primeros n elementos del RDD usando su orden original o un comparador personalizado. Acá vemos la opción de parallelize en spark.
val b = sc.parallelize(List(“dog”,
“cat”, “ape”, “salmon”, “gnu”), 2)
b.takeOrdered(2)
res0: Array[String] = Array(ape,
cat)
- saveAsTextFile(path): guarda el RDD como un archivos de texto. Acá vemos la opción de parallelize en spark.
val a = sc.parallelize(1 to 10000, 3)
a.saveAsTextFile(“/home/usuario/datos”)
root@master:/home/usuario/datos
# is
part-00000 part-00001 part-
00002 _SUCCESS
Aprende más sobre el procesamiento Big Data
En este post, te presentamos cuáles son las transformaciones y acciones en Spark, de manera que ahora puedas emplearlas en tu procesamiento de datos. Sin embargo, el desarrollo de Apache Spark posee más alternativas. Por ello, te aconsejamos profundizar en estos conocimientos y aprender a desarrollarlos de manera práctica.
Nuestro Big Data Bootcamp te permitirá consolidar tus conocimientos y poner a prueba tus destrezas en este ámbito de transformaciones y acciones en Spark. En el transcurso de este bootcamp, aprenderás a utilizar sus métodos de inteligencia artificial, aprendizaje automático, estadística y sistemas de bases de datos. ¡No lo dudes más, matricúlate y empieza ahora!
