Conociendo Apache Spark
Fundamentos de Apache Spark: ETL y Limpieza de Datos
Introducción a Apache Spark y sus diferencias con Hadoop
Diferencias entre RDDs y DataFrames en Apache Spark
Configuración
Instalación de Spark y Anaconda en Linux
Ejecución y Configuración de Spark en Línea de Comando y Anaconda
Configuración de PySpark con Jupyter y Anaconda
Operaciones RDDs
Transformaciones y Acciones en RDD de Spark
Transformaciones y acciones
Interacción con RDDs en Spark: Operaciones Básicas y Avanzadas
Operaciones avanzadas con RDDs en Spark: Uniones y Joins
Unión de Datos en RDD para Deportistas Olímpicos
Operaciones Numéricas con RDDs en Juegos Olímpicos
Data Frames y SQL
Creación y Gestión de Data Frames en PySpark
Creación de DataFrame desde RDD en PySpark
Manipulación de Data Frames en PySpark
Joins y Selección de Datos en DataFrames con PySpark
Filtrado y Join de Datos Olímpicos en Pandas
Funciones de Agregación en Spark para DataFrames
Uso de SQLContext para Registro y Consultas con DataFrames en Spark
Creación y Uso de Funciones UDF en Spark
Creación y uso de UDFs en PySpark para manejo de datos faltantes
Persistencia y particionado
Particionado y Replicación de Datos en Spark RDDs
Persistencia y Particionado de Datos en Spark
Particionamiento de RDDs y DataFrames en Spark con PySpark
Conclusiones
Uso de RDDs y DataFrames en Apache Spark
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Las operaciones numéricas en RDDs (Resilient Distributed Datasets) son esenciales para procesar y analizar grandes volúmenes de datos de manera eficiente en entornos distribuidos. Aprovechando la flexibilidad y capacidad de escalado de RDDs, es posible obtener información valiosa de datos numéricos. En este caso, nos centraremos en analizar los puntajes de los países que han competido en los Juegos Olímpicos mediante RDDs. Vamos a analizar el proceso, paso a paso, proporcionándote un entendimiento claro de cómo trabajar con estas estructuras de datos.
Para comenzar nuestro análisis, necesitamos un sistema de puntuación que refleje los logros de los países en los Juegos Olímpicos. La Comisión de los Juegos Olímpicos asigna puntajes en base a las medallas ganadas:
Estos valores los almacenamos en un diccionario para utilizarlos fácilmente durante los cálculos en nuestro ejercicio.
valores_medallas = {'Oro': 7, 'Plata': 5, 'Bronce': 4}
Una vez definido el sistema de puntuación, el siguiente paso es extraer la información relevante de los RDDs. En nuestro caso, partimos de una estructura de datos que incluye varios valores, y nos interesa centrarnos en el país y el tipo de medalla que ha ganado. Usamos los métodos de manipulación de RDDs para acceder a estos datos.
# Extraer el país y la medalla de la subtupla
pais_medalla = rdd.map(lambda x: (x[1][0], x[1][1]))
Para calcular el puntaje total acumulado por cada país, debemos sumar los puntos asignados a cada tipo de medalla. Primero, necesitamos las importaciones necesarias para sumar los valores. Utilizamos métodos de reducción disponibles en Spark.
operator.add: usando la función de sumas de la librería operator.from operator import add
paises_medallas = pais_medalla.map(lambda x: (x[0], valores_medallas[x[1]]))
resultado = paises_medallas.reduceByKey(add)
Finalmente, después de calcular los puntajes, es fundamental presentar la información de manera ordenada para una fácil comprensión. Podemos ordenar los resultados alfabéticamente o por puntaje de manera ascendente o descendente, utilizando sortBy.
# Ordenar los resultados por puntaje en orden descendente
resultado_ordenado = resultado.sortBy(lambda x: x[1], ascending=False)
# Mostrar los resultados
for pais in resultado_ordenado.collect():
print(pais)
Es posible que encuentres ciertas inconsistencias en los resultados debido a la forma en que se manejan los nombres y siglas de los países en los sistemas de puntuación olímpica. Algunas veces, diferentes equipos del mismo país pueden tener siglas idénticas, lo cual puede llevar a errores en los conteos. Se recomienda explorar y comprender bien los RDDs y considerar posibles soluciones para corregir estos errores.
Continuar aprendiendo sobre RDDs te proporcionará habilidades invaluables para gestionar y analizar grandes conjuntos de datos. Los RDDs son fundamentales en la analítica de datos y te invito a seguir avanzando en tu dominio de estas herramientas.
Aportes 12
Preguntas 1
Este es mi resultado de conclusionRDD.
¿ A quien le dio el mismo resultado?
[('USA', 32137),
('URS', 14834),
('GBR', 10925),
('GER', 10896),
('FRA', 9265),
('ITA', 8755),
('SWE', 8110),
('CAN', 7209),
('AUS', 6755),
('HUN', 6142),
('GDR', 5992),
('NOR', 5627),
('CHN', 5362),
('NED', 5351),
('RUS', 5298),
('JPN', 4702),
('FIN', 4464),
('SUI', 3530),
('KOR', 3472),
('ROU', 3317)]```
Hice un gráfico con los puntos acumulados de los 50 países con más puntos
Si les interesa el código es este:
plt.figure(figsize=(10,5))
plt.scatter(resultado_valor_pais.map(lambda x:x[0]).take(50),resultado_valor_pais.map(lambda x:x[1]).take(50)
, color='r')
plt.xticks(rotation=90)
plt.xlabel('Paises',labelpad=15)
plt.ylabel('Puntos',labelpad=15)
plt.show()
Aqui mi resultado:
[('ITA', 74920),
('NED', 65560),
('GER', 22323),
('JPN', 19950),
('NZL', 9220),
('TCH', 8160),
('BLR', 5012),
('RSA', 4735),
('TUR', 3965),
('GHA', 3430)]
Creo que para comodidad de todos, y poder entender spark. Creo que es importante saber algo de programción funcional. Platzi tiene uno con scala, veanlo para sacarle más provecho es estas clases
Me da el mismo resultado de los que hicieron la modificación en el código:
conclusion = PaisesMedallas3.reduceByKey((add)).sortBy(lambda x: [x[1]], ascending=False)
conclusion.take(5)
[('USA', 32137), ('URS', 14834), ('GBR', 10925), ('GER', 10896), ('FRA', 9265)]
Mi solución, sin usar:
from operator import add
Aquí está el código que usé para obtener el mismo resultado, pero sin importar operator:
paises_medallas.groupByKey().mapValues(sum).sortBy(lambda row:row[1],ascending=False)
En una situación de la vida real es importante tener sensibilidad de los números del negocio y hacer una conciliación con alguna cifra conocida, por ejemplo en este caso habría que dudar del resultado, si tenemos el contexto de que Estados Unidos y Rusia han sido punteros siempre en juegos Olímpicos, situación que el resultado del código no refleja.
A mi me dio uno muy parecido jose
from pyspark.sql import SparkSession
from operator import add
spark = SparkSession.builder
.appName(“Mi aplicacion de Spark”)
.getOrCreate()
sc = spark.sparkContext
path = “C:\Users\Benja\OneDrive\Escritorio\curso-apache-spark-platzi-master\files\”
equiposOlimpicosRDD = sc.textFile(path + “paises.csv”)
.map(lambda line: line.split(","))
resultado = sc.textFile(path + “resultados.csv”)
.map(lambda line: line.split(","))
resultadoGanador = resultado.filter(lambda line: ‘NA’ not in line[1])
valoresMedallas = {
‘Gold’: 7,
‘Silver’: 5,
‘Bronze’: 4
}
deportistapaises = deportistaOlimpicoRDD.map(lambda l: [l[-1], l[:-1]])
.join(equiposOlimpicosRDD.map(lambda x: [x[0], x[2]]))
paisesMedallas = deportistapaises.join(resultadoGanador)
paisesMedallas_rdd = paisesMedallas.map(lambda x: (x[1][0][-1], valoresMedallas[x[1][1]]))
conclusion = paisesMedallas_rdd.groupByKey().mapValues(sum).sortBy(lambda row: row[1], ascending=False)
resultado_final = conclusion.collect()
for pais, medallas in resultado_final:
print(pais, medallas)
interesante
Aca mis resultados.
Aun me sigue costando entender la funcion Lambda-Map-Reduce
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?