No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Operaciones Numéricas con RDDs en Juegos Olímpicos

12/25
Recursos

¿Cómo realizar operaciones numéricas con RDDs?

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.

¿Cómo asignar puntajes a las medallas olímpicas?

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:

  • Medallas de oro: 7 puntos
  • Medallas de plata: 5 puntos
  • Medallas de bronce: 4 puntos

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}

¿Cómo extraer y preparar datos de los RDDs?

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]))

¿Cómo calcular los puntajes de los países con RDDs?

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.

  1. Reducir por llave (reduceByKey): combina los valores de las mismas claves (en este caso, los países).
  2. Sumar puntos con 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)

¿Cómo ordenar y mostrar los resultados?

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)

¿Qué hacer si hay discrepancias en las sumas?

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

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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

Crear una instancia de SparkSession

spark = SparkSession.builder
.appName(“Mi aplicacion de Spark”)
.getOrCreate()

Obtener el contexto de Spark

sc = spark.sparkContext

Ruta del archivo CSV

path = “C:\Users\Benja\OneDrive\Escritorio\curso-apache-spark-platzi-master\files\”

Leer el archivo CSV y aplicar la transformación

equiposOlimpicosRDD = sc.textFile(path + “paises.csv”)
.map(lambda line: line.split(","))

Leer el archivo de resultados

resultado = sc.textFile(path + “resultados.csv”)
.map(lambda line: line.split(","))

Filtrar resultados y obtener ganadores

resultadoGanador = resultado.filter(lambda line: ‘NA’ not in line[1])

Obtener valores de las medallas

valoresMedallas = {
‘Gold’: 7,
‘Silver’: 5,
‘Bronze’: 4
}

Realizar join entre deportistas, países y resultados

deportistapaises = deportistaOlimpicoRDD.map(lambda l: [l[-1], l[:-1]])
.join(equiposOlimpicosRDD.map(lambda x: [x[0], x[2]]))

paisesMedallas = deportistapaises.join(resultadoGanador)

Calcular la suma de las medallas por país

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)

Obtener el resultado

resultado_final = conclusion.collect()

Imprimir el resultado

for pais, medallas in resultado_final:
print(pais, medallas)

interesante

Aca mis resultados.
Aun me sigue costando entender la funcion Lambda-Map-Reduce