No tienes acceso a esta clase

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

Transformación de datos de transacciones

11/25
Recursos

¿Cómo transformar un DataFrame para un proceso ETL?

La transformación de un DataFrame es uno de los pasos fundamentales en cualquier proceso ETL (Extract, Transform, Load), especialmente cuando nos centramos en modelos de datos como las tablas de hechos y dimensiones. En esta clase nos enfocamos en cómo transformar un DataFrame que contiene la transaccionalidad de importación y exportación de varios países. Profundicemos en el código y veamos cómo se realiza paso a paso el proceso.

¿Cómo crear una tabla de dimensiones?

Para comenzar, es esencial separar las columnas de un DataFrame en métricas y dimensiones. En este caso, se identificaron columnas como flow, SQN, y año que necesitaban un tratamiento específico:

  • Flow: Indica si el comercio fue una importación o exportación.
  • SQN: Explica la métrica utilizada, si es por peso o por cantidades.
  • Año: No es una métrica sino una dimensión y, por lo tanto, debe ser separada.

Para conseguirlo, se creó una función llamada createDimension que transforma cada valor único de estas columnas en un nuevo DataFrame. A continuación, el código que lo ilustra:

def createDimension(dataframe, idName, valueName):
    listKeys = []  # Lista para almacenar llaves únicas
    valor = 1  # Inicialización de variable de iteración
    for value in dataframe:
        listKeys.append(valor)
        valor += 1
    return pd.DataFrame({idName: listKeys, 'values': dataframe})

¿Cómo realizar un merge de DataFrames con joins?

Al separar las métricas y las dimensiones, se vuelve crucial efectuar un merge para asegurar que estos datos pueden relacionarse efectivamente entre sí en futuras consultas y análisis. El proceso de merge sigue un patrón de left join, que asegura que todos los datos del DataFrame base se mantengan:

dfClean = dfClean.merge(dfQuantity, how='left', left_on='quantityName', right_on='values')
dfClean = dfClean.merge(dfFlow, how='left', left_on='flowName', right_on='values')

¿Cómo estructurar la tabla final de hechos?

La meta en este punto es crear una tabla que concentre las métricas y las llaves necesarias para conectar a las respectivas dimensiones. Esto se logra seleccionando solo las columnas esenciales y creando un identificador único para cada transacción:

dfClean['idTrades'] = dfClean.index + 1  # Creación de un ID único
dataset_final = dfClean[['idTrades', 'tradeUSD', 'kilogramos', 'quantity', 'productCode', 'countryCode', 'yearCode']].copy()

¿Cómo organizar las dimensiones country y code?

Para asegurar la calidad de nuestros datos, también se trabajaron las dimensiones Country y Code, organizándolas según sus atributos claves:

dfCountry = dfCountry[['idCountry', 'alfa3', 'alcountry', 'region', 'subregion']]
dfCodes = dfCodes[['idCode', 'clincode', 'description', 'parentDescription']]

Recomendaciones para la carga final

Una vez realizadas todas estas transformaciones con éxito, el último paso en el proceso ETL consiste en cargar este resultado en nuestro destino final. Aunque en este espacio hemos hecho un ejercicio práctico local, siempre es crucial entender el contexto del negocio en el que se trabaja, lo que puede implicar ajustes en el modelo de datos y lo que se busca analizar o resolver. ¡Anímate y continúa descubriendo el fascinante mundo del ETL!

Aportes 17

Preguntas 1

Ordenar por:

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

Me gustaría que el curso esté enfocado en un proyecto y una solución, creo que el profesor explica muy bien peero no veo una idea clara, se que él la sabe, sabe cuál es el objetivo pero yo no lo sé y solo me guío de lo que hace el profesor y no me da la libertad a mi de ir hacer una solución de una manera distinta.

Tal vez esto sirva para aclarar un poco,

Al final lo que hizo el profesor fue construir 3 dimensiones:

  • Una dimension es algo que describe o da contexto a una metrica, normalmente responde el ‘quien?’, ‘donde?’, ‘como?’, ‘cuando?’ de un ‘que?’
  • Por ejemplo, al hacer un pedido por amazon, puede haber una tabla de hechos (fact table) llamada ordenes, que va a tener metricas (precio, cantidades), para dar contexto a esta orden se tendrian estas dimensiones:
  • dimension cliente: (dim_customer) el usuario que compro esta orden, con informacion adicional, como su email, hace cuanto es cliente, el pais donde vive, etc.
  • dimension almacen: (dim_warehouse) el almacen desde donde se va a despachar el producto, su ubicacion, etc.
  • dimension vendedor: (dim_seller) quien es la persona que vende el producto en amazon, con datos adicionales sobre el.

NORMALMENTE estos datos vienen de una aplicacion, por ejemplo puede ser SAP, NetSuite, Stripe, Salesforce, y ya tienen sus primary keys y foreign keys creadas, por lo tanto ‘no seria necesario’ construir los ids de cada dimension.

En esta clase el profe Carlos constuye cada dimension a partir de los mismos atributos de la dimension,

  • para dim quantity crea un id unico apartir del quantity_name que es un string, porque nativamente no tenia identificadores unicos.
  • para dim flow crea un id unico a partir del ‘flow’, ya que tampoco tenia un identificador unico.

Code

df_trades_final = df_trades_clean[['id_trades', 'trade_usd', 'kg', 'quantity', 'id_code', 'id_country', 'id_quantity', 'id_flow', 'id_year']]
df_countries = df_countries[['id_country', 'alpha-3', 'country', 'region', 'sub-region']]
df_codes = df_codes[['id_code', 'clean_code', 'Description', 'parent_description']]

El curso empezó bien con la intro de la primera clase. Después no se aclaro el camino y se hizo de todo sin explicar por que ! No hubo enfoque solo procesos sin rumbo !

También podemos usar enumerate en la función:

def create_dimension(data, id_name):
    list_keys = []
    #value = 1

    for count, _ in enumerate(data):
        list_keys.append(count + 1)

    return pd.DataFrame({id_name: list_keys, 'values': data})

Creo que el error de esta clase no fue explicar la codificación que usa el profesor que aunque es valiosa, le falto explicar a mayor profundidad los conceptos de dimensiones , métricas y los hechos, ya que esta es la base conceptual de un ETL

Importante anotar que los identificadores unicos que utiliza el profesor no son suficientes para garantizar que no tenemos duplicados, pues pandas crea los index sin importar si 2 registros tienen los mismos valores, en este caso la mejor opcion es comparar los dos registros utilizando surrogate_keys.

df_trades_fact['surrogate_key'] = df_trades_fact.apply(lambda row: ''.join(hex(hash(row[col]))[2:] for col in df_trades_fact.columns), axis=1)

Muy buena la clase y todos lo aportes dados en la misma, pero en lo personal tuve problemas para conectar la base datos por Dataspell,y por tanto no podía seguir con el proyecto pero lo logre solucionar de esta forma.

<code> 
import psycopg2
import os
import pandas as pd

try:
      Connection=psycopg2.connect(host="localhot",
                                  
                                  user="postgres",
                                  
                                  password="",
                                  
                                  database="universida",
                                 
                                 puerto ="5432")
      
      print(f"conexion exitosa")
      cursor=Connection.cursos()
      cursor.execute("SELECT version()*")
      row=cursor.fetchone()
      print(row)
      cursor.execute("SELECT * FROM  curso")
      rows=cursor.fetchall()
      for row in rows:
          print(row)
except Exception as ex:
    print(ex)
finally:
    Connection.close()
    print("se termino la conexion")

Espero les sea de ayuda.

El objetivo de la clase fue enseñar a los estudiantes cómo transformar un dataframe de transacciones de importación y exportación en una estructura de tabla de hechos adecuada para análisis y machine learning. Se abordaron conceptos como la creación de dimensiones y la utilización de joins para relacionar métricas y dimensiones, preparando los datos para su posterior carga en un sistema. Esto es fundamental en el flujo ETL que se utiliza en la ingeniería de datos.
La \*\*transformación de datos de transacciones\*\* es un paso clave dentro de un proceso de \*\*ETL\*\* (Extracción, Transformación y Carga) en el que los datos se procesan para que sean más útiles y adecuados para su análisis posterior. En el contexto de las transacciones financieras o de ventas, este paso implica la conversión de datos crudos provenientes de diferentes fuentes en un formato más estandarizado, limpio y estructurado. Aquí te dejo algunos aspectos clave y ejemplos de cómo se realiza la transformación de datos de transacciones: \### 1. \*\*Limpieza de Datos\*\* La limpieza es fundamental para asegurar que no haya errores en los datos antes de cargarlos a la base de datos o al sistema de análisis. \- \*\*Eliminar registros duplicados\*\*: Si tienes registros de transacciones duplicados, necesitarás eliminarlos. \- \*\*Rellenar valores nulos\*\*: Algunas transacciones pueden tener valores faltantes, como un monto o una fecha. Dependiendo de las reglas del negocio, podrías decidir rellenar estos valores con un valor predeterminado o eliminarlos. \- \*\*Formato de fechas\*\*: Es posible que las fechas de las transacciones vengan en diferentes formatos (por ejemplo, `DD/MM/YYYY` o `MM-DD-YYYY`). Se deben estandarizar en un formato único. \*\*Ejemplo en Python (Pandas)\*\*: ```python import pandas as pd \# Eliminar duplicados df = df.drop\_duplicates(subset=\["transaction\_id"]) \# Rellenar valores nulos df\["transaction\_amount"].fillna(0, inplace=True) \# Convertir fechas df\["transaction\_date"] = pd.to\_datetime(df\["transaction\_date"], format="%Y-%m-%d") ``` \### 2. \*\*Agregación de Datos\*\* Las transacciones a menudo deben agregarse para obtener métricas clave como el total de ventas por día, el total de transacciones por usuario, etc. Esto se hace mediante operaciones como la suma, el promedio, el conteo, etc. \- \*\*Total de ventas diarias\*\*: Si cada transacción tiene un monto asociado, puedes agregar las ventas por día. \- \*\*Transacciones por usuario\*\*: Puedes contar el número de transacciones realizadas por cada cliente o usuario. \*\*Ejemplo en Python (Pandas)\*\*: ```python \# Total de ventas por día df\_daily\_sales = df.groupby("transaction\_date")\["transaction\_amount"].sum().reset\_index() \# Número de transacciones por cliente df\_transactions\_per\_user = df.groupby("user\_id")\["transaction\_id"].count().reset\_index() ``` \### 3. \*\*Normalización y Estandarización\*\* Los datos de transacciones pueden tener diferentes unidades o escalas. Es importante estandarizar estos valores para que sean consistentes. \- \*\*Normalización de montos\*\*: Si tienes transacciones en diferentes monedas, deberías convertirlas a una moneda común. \- \*\*Transformar categorías\*\*: Las categorías de productos o servicios pueden tener diferentes etiquetas (por ejemplo, "Electrónica", "Electrodomésticos", "Tech"). Puedes agruparlos bajo categorías estandarizadas. \*\*Ejemplo en Python (Pandas)\*\*: ```python \# Convertir montos a una moneda común (suponiendo una tasa de cambio de 1 USD = 0.85 EUR) df\["transaction\_amount\_usd"] = df\["transaction\_amount"] \* 0.85 \# Estandarizar categorías de productos category\_map = {"Electrodomésticos": "Electronics", "Tech": "Electronics"} df\["product\_category"] = df\["product\_category"].replace(category\_map) ``` \### 4. \*\*Cálculo de Métricas Derivadas\*\* Las métricas derivadas son cálculos adicionales basados en los datos de transacciones que pueden ayudar a tomar decisiones o hacer análisis. \- \*\*Monto de transacciones por usuario\*\*: Calcular cuánto ha gastado cada usuario. \- \*\*Margen de beneficio\*\*: Si tienes datos sobre el costo y el precio de los productos, puedes calcular el margen de beneficio. \*\*Ejemplo en Python (Pandas)\*\*: ```python \# Calcular el monto total por usuario df\_user\_spending = df.groupby("user\_id")\["transaction\_amount"].sum().reset\_index() \# Calcular margen de beneficio df\["profit\_margin"] = (df\["transaction\_amount"] - df\["cost\_amount"]) / df\["transaction\_amount"] ``` \### 5. \*\*Enriquecimiento de Datos\*\* A veces es necesario enriquecer los datos de transacciones con información adicional que provenga de otras fuentes. Esto podría incluir detalles sobre el usuario, ubicación, productos o promociones. \- \*\*Datos de cliente\*\*: Puedes agregar información sobre los clientes, como el nombre, la ubicación o su nivel de fidelidad. \- \*\*Categorías de productos\*\*: Si tienes una lista de productos con su categoría, puedes añadirla a cada transacción. \*\*Ejemplo en Python (Pandas)\*\*: ```python \# Suponiendo que tienes un DataFrame con información de clientes df\_customers = pd.DataFrame({"user\_id": \[1, 2], "customer\_name": \["Alice", "Bob"]}) \# Unir la información de los clientes con las transacciones df = pd.merge(df, df\_customers, on="user\_id", how="left") ``` \### 6. \*\*Formato de Salida\*\* Finalmente, los datos de transacciones transformados deben estar en el formato adecuado para su almacenamiento o análisis posterior. Pueden almacenarse en bases de datos, archivos CSV, formatos como JSON o Parquet, entre otros. \*\*Ejemplo en Python (Pandas)\*\*: ```python \# Guardar los datos transformados en un archivo CSV df.to\_csv("transacciones\_transformadas.csv", index=False) ``` \### Resumen del Proceso de Transformación de Datos de Transacciones: 1\. \*\*Limpieza de datos\*\*: Eliminar duplicados, rellenar valores nulos, convertir fechas. 2\. \*\*Agregación de datos\*\*: Sumar transacciones por fecha, contar transacciones por usuario. 3\. \*\*Normalización\*\*: Convertir unidades (como moneda) y estandarizar categorías. 4\. \*\*Cálculo de métricas derivadas\*\*: Calcular métricas adicionales como el gasto total por cliente o el margen de beneficio. 5\. \*\*Enriquecimiento de datos\*\*: Agregar datos adicionales como la información del cliente. 6\. \*\*Exportación y almacenamiento\*\*: Guardar los datos en el formato deseado (CSV, base de datos, etc.). Este proceso de transformación es clave para preparar los datos para su análisis o para generar informes de negocio confiables.
Aplicando listas comprensivas ```js def create_dimension(data, id_name): list_keys = [ value + 1 for value in range(len(data)) ] return pd.DataFrame({ id_name: list_keys, "values": data }) ```
Pense que este profesor era mas del corte de los que intenta enseñar, y creo quiere mostrar que tan bueno es el, no recomiendo para nada este curso, el cual me tomo una semana aprendiendo por otro lado a crear u bash para cargar la sql tan grandem, que lo unico que hace es en el Coolab bloquear mi pc, ojala puedan mejorar este curso y trabajar en como enseña el profesor que no enseño nada sino el codea aplicando unas funciones a base de conceptos muy cortos que son llaves unicas para mejorar complementar las tablas con relaciones lo cuale s poderoso pero necesitaba todo lo anterior para enseñar de zero a hero, OJALA mejore Platzi me estoy cansando
Eso fue muy hermoso
Alguien sabe como en DataSpell uno puede guardar cambios ? no encuentro ningun comando al estilo Control + S, para ir guardando los cambios en el notebook, siempre me ha tocado confiar en que se autoguarda. Pero me da miedo, ya que no veo ninguna indicación en el entorno dataSepell que me lo indique. Help !!

Ahora capté mejor lo que involucra la transformación y en sí el ETL. Muy lindo el curso

Una forma de hacerlo mas corto

def create_dimension(data, id_name):
    list_keys = [ i+1 for i in range(data.size) ]
    return pd.DataFrame({id_name:list_keys, "values": data})
def create_dimension(data, id_name):
    list_keys = []
    value =1
    for _ in data:
        list_keys.append(value)
        value = value + 1  
    
    return pd.DataFrame({id_name:list_keys,'values':data})