Saltar a contenido

Sesión 02 – Fundamentos de Spark

Tema: DataFrames, lazy evaluation, execution plan y procesamiento textual con RDD.

Dataset: biblia_ntv_.csv en /opt/data/.

Propósito práctico: Explorar datos con DataFrames, comprender la diferencia entre transformaciones y acciones, y aplicar procesamiento textual básico con RDD.

1. Crear la SparkSession

Para esta práctica trabajaremos en modo local dentro del contenedor Docker. Se usa local[*] para aprovechar los cores disponibles y una cantidad moderada de particiones de shuffle para evitar sobrecarga en un dataset pequeño.

from pyspark.sql import SparkSession

spark = (
    SparkSession.builder
    .appName("sesion2-fundamentos-spark")
    .master("local[*]")
    .config("spark.ui.port", "4040")
    .config("spark.sql.shuffle.partitions", "8")
    .getOrCreate()
)

spark

2. Cargar el dataset como DataFrame

El archivo está montado desde la carpeta data/ del proyecto hacia /opt/data/ dentro del contenedor.

df = spark.read.csv(
    "/opt/data/biblia_ntv_.csv",
    header=True,
    inferSchema=True
)

df

3. Explorar estructura y primeros registros

Aquí observamos el esquema y verificamos que el dataset contiene columnas como índice, libro, capítulo, verso y texto.

df.printSchema()
df.show(5, truncate=False)

4. Exploración con DataFrames

Aplicamos operaciones de selección y filtrado. Estas operaciones son transformaciones, por lo que Spark todavía no ejecuta todo inmediatamente.

df.select("libro", "capitulo", "verso").show(10, truncate=False)

df.filter(df.texto.contains("Dios")).select("libro", "capitulo", "verso", "texto").show(5, truncate=False)

5. Lazy evaluation y acciones

Construimos un flujo de transformaciones. La ejecución real ocurre recién cuando llamamos a una acción como show() o count().

df_transformado = (
    df.select("libro", "capitulo", "verso", "texto")
      .filter(df.texto.contains("amor") | df.texto.contains("fe") | df.texto.contains("Dios"))
)

# Hasta aquí Spark solo construye el plan
df_transformado
# Acción: aquí recién Spark ejecuta
df_transformado.show(10, truncate=False)

# Otra acción
df_transformado.count()

6. Analizar el plan de ejecución

Usamos explain() para observar cómo Spark organiza el procesamiento. Es una base importante para comprender rendimiento y optimización.

df_transformado.explain(True)

7. Paso de DataFrame a RDD

Ahora tomamos solo la columna texto y la convertimos a RDD para trabajar la lógica tipo MapReduce.

rdd = df.select("texto").rdd.map(lambda x: x.texto)
rdd.take(5)

8. Filtrar versículos por palabra clave

Buscamos versículos que contengan la palabra amor.

textos_amor = rdd.filter(lambda linea: "amor" in linea.lower())
textos_amor.take(5)

9. Aplicar flatMap + map + reduceByKey

Se implementa un conteo distribuido de palabras. Antes de contar, realizamos una limpieza básica para reducir ruido por signos de puntuación.

import re
from operator import add

palabras = rdd.flatMap(
    lambda linea: re.sub(r"[^\wáéíóúñüÁÉÍÓÚÑÜ]", " ", linea.lower()).split()
)

pares = palabras.filter(lambda p: p != "").map(lambda palabra: (palabra, 1))
conteo = pares.reduceByKey(add)

conteo.takeOrdered(20, key=lambda x: -x[1])

10. Reto de práctica

Resolver los siguientes puntos: 1. Obtener las 10 palabras más frecuentes. 2. Determinar cuántas veces aparece la palabra dios. 3. Extraer 5 versículos donde aparezca fe.

top10 = conteo.takeOrdered(10, key=lambda x: -x[1])
top10
conteo.filter(lambda x: x[0] == "dios").collect()
rdd.filter(lambda x: "fe" in x.lower()).take(5)

11. Cierre breve

Preguntas para reflexión: - ¿Qué parte resolviste con DataFrame y cuál con RDD? - ¿En qué momento Spark ejecutó realmente el trabajo? - ¿Qué observaste en explain() sobre el plan lógico y físico?

Entregable sugerido: notebook con resultados visibles e interpretación breve.