Aproveche algunas ecuaciones simples para generar columnas relacionadas en tablas de prueba.
Recientemente estuve jugando con Databricks Labs Data Generator para crear conjuntos de datos completamente sintéticos desde cero. Como parte de esto, analicé la creación de datos de ventas en diferentes tiendas, empleados y clientes. Como tal, quería crear relaciones entre las columnas que estaba completando artificialmente, como asignar empleados y clientes a una determinada tienda.
Mediante el uso de UDF de PySpark y un poco de lógica, podemos generar columnas relacionadas que siguen una relación de muchos a uno. Con un poco de magia, incluso podemos ampliar la lógica para dar cierta variación en este mapeo, como un cliente que generalmente compra en su tienda local pero a veces en una tienda diferente.
Utilice el generador de datos de Databricks Labs para generar nuestro marco de datos básico
Nota: ¡Puede omitir esta sección si no es necesario!
Primero, necesitamos crear un DataFrame con nuestra primera columna generada aleatoriamente. En nuestro caso vamos a empezar por la tienda, ya que lógicamente tendremos “muchos empleados por tienda” y “muchos clientes comprando repetidamente en una tienda”.
Con un modelo de datos de esquema en estrella en mente, comenzaremos con nuestra tabla de hechos de ventas: una tabla transaccional que contendrá valores clave para el ID de venta, el ID de la tienda, el ID del empleado y el ID del cliente, el monto de la venta junto con una fecha y hora. datos para la compra. Luego podemos completar los detalles sobre la Tienda, el Empleado y el Cliente en las tablas de dimensiones más adelante.
Empezaremos poco a poco: una tabla con 1000 ventas será suficiente. Ahora debemos decidir cómo dividir estas ventas entre tiendas, empleados y clientes. Sugerimos lo siguiente:
- # Tiendas = 20
- # Empleados = 100
- # Clientes = 700
También podemos decir que las ventas se registrarán a lo largo del último mes:
- Fecha de primera venta = 2023–11–01
- Fecha de última venta = 2023–11–30
El ID de venta debe ser una columna única para que podamos generar una columna de ID para esto. Ahora necesitamos distribuir las 1000 ventas en las 20 tiendas. Por simplicidad asumiremos que esto es aleatorio.
Usando Databricks Lab Generator podemos hacer esto con el siguiente código:
https://medium.com/media/1dbbf19e973a3afea5526d7c613ffc8d/hrefhttps://medium.com/media/b66c9f36f7f8e0378e89d2839eab7dfa/hrefhttps://medium.com/media/87284680b5d1453a517dc9ba491d5169/href
Ahora agregue algún código para registrar cuándo se realizaron las ventas y su monto. Para simplificar las cosas, redondearemos la marca de tiempo de la venta a la hora más cercana.
https://medium.com/media/7a068c3c2af10db25a149bc117aa9831/href
Para calcular el monto de la venta, podemos usar el parámetro “expr” en nuestra expresión withColumn para permitirnos generar un número aleatorio, con algunas reglas/límites.
https://medium.com/media/527be3b6e46203b82d69b71f3e118c05/href
En este caso, la expresión es bastante sencilla: genera un número aleatorio (entre 0 y 1), suma 0,1 (asegurándote de que los valores de venta no sean 0) y multiplica por 350.
Ya tenemos nuestra forma básica para el DataFrame, así que júntelo todo:
https://medium.com/media/0dcda45fd358954946a751d2277a66d3/href
Podemos crear un perfil de datos rápido para ver la distribución de valores en las columnas:
Podemos ver que la distribución de StoreId es relativamente uniforme en las 20 tiendas, sin valores faltantes ni promedios alrededor del centro como era de esperar. Lo mismo ocurre con las marcas de tiempo y los valores de importe.
Agregar una columna dependiente de muchos a uno
Ahora podemos agregar nuestra columna de Id. de empleado al marco de datos. Ya hemos terminado con Databricks Lab Data Generator, por lo que solo usaremos operaciones de PySpark para agregar columnas al DataFrame.
Volviendo al código, queremos modelar esto como las siguientes declaraciones:
- Hay 20 tiendas.
- Cada tienda tiene más de 1 empleado.
- Cada empleado trabaja únicamente en una única tienda.
Primero necesitamos dividir a los empleados entre las tiendas. Para ello se puede utilizar la siguiente función de Python:
https://medium.com/media/ccc1120174ff30fa5f4b3fbc78243d85/href
Ahora que tenemos nuestra distribución de empleados para cada tienda, ¡comencemos a asignar ID!
La lista de empleados por tienda garantiza que los ID de los empleados por tienda no se superpongan. Podemos usar esto para asignar aleatoriamente un ID de empleado a una venta en la tabla con la siguiente ecuación:
https://medium.com/media/de106d99c7675d2dcadbaa794a484ca3/href
Actualmente, esta función solo funciona para un único valor; debemos poner esto en algo con lo que un PySpark DataFrame pueda funcionar (¡funcional y rápidamente!)
Podemos pasar las UDF de PySpark al con columna método, así que reformateemos esta lógica en una función y configurémosla en una UDF:
https://medium.com/media/5061f4dc681c9a78a07158aa452cd14d/href
Ahora llame a esto como una nueva columna en el DataFrame:
https://medium.com/media/c0ab8deeb651ff670c54ce53e136881e/href
Podemos probar rápidamente que esto parece correcto utilizando la herramienta de visualización en Databricks para ver el recuento distinto de identificadores de empleado por identificador de tienda. Esta es mi preferencia, pero también puede usar agrupar por lógica u otros módulos de trazado, si lo desea.
Nota IMPORTANTE: Esta lógica permite que los empleados sean omitido de los resultados. Esto significa que es posible que un empleado realice 0 ventas y, por lo tanto, no esté incluido en el DataFrame. Veremos cómo garantizar que todos los clientes tengan registradas sus ventas en la siguiente sección.
Agregar la columna de clientes
La columna de clientes es un poco diferente… si bien nuestro caso de uso sugiere que es común que un cliente compre en una sola tienda varias veces, es muy posible que algún día haya llegado a una tienda diferente. ¿Cómo modelamos esto?
Tenemos los puntos de partida con la columna del trabajo realizado para nuestros empleados, por lo que podemos repetir el obtener_empleados función y lógica UDF para clientes como se muestra a continuación:
https://medium.com/media/38ba0fef63c1b950c9dc9ffe815daa94/href
Es posible que nuevamente hayamos perdido a algunos clientes aquí. Aquí hay algunos enfoques para rectificar esto:
- Recalcular en mientras bucle hasta que converja en un DataFrame que contiene todos los clientes (ineficiente, costoso, podría ejecutarse indefinidamente)
- Actualizar aleatoriamente los ID de los clientes en mientras bucle hasta que todos los clientes en DataFrame (requiere lógica para sobrescribir solo las mismas tiendas, también podría ejecutarse indefinidamente)
- Devuelva una lista de todos los ID de clientes con más de 1 registro en la tabla de ventas y sobrescriba aleatoriamente hasta que se agreguen todos los ID faltantes (también necesita lógica para sobrescribir clientes en la misma tienda, también puede requerir mientras lógica de bucle)
- Invierta el proceso y comience con los empleados. Esto garantiza que cada empleado sea asignado aleatoriamente a las filas. Luego podemos usar el mapeo y aplicar la identificación de la tienda.
Con suerte, queda claro por qué la última opción es la que requiere el menor esfuerzo de cálculo: tenemos todo el código necesario, por lo que solo necesitamos reformatear ligeramente las cosas.
Nuestros nuevos scripts tienen el siguiente aspecto:
https://medium.com/media/0637493d35285e5e960557956c07ab6e/hrefhttps://medium.com/media/1fb4045e2ea95a78910da70d0ee5dc0f/href
Agregar aleatoriedad a los clientes
Lo que necesitamos ahora es un poco de aleatoriedad, que debemos definir. Para nuestro ejemplo, digamos que cada cliente tiene un 90% de posibilidades de comprar en la tienda habitual (la tienda “local”). Si no necesitamos que todos los clientes aparezcan en el conjunto de resultados, simplemente podemos ajustar nuestra clientes_udf como sigue y utilice df2:
https://medium.com/media/3bfdda7d48a67575403095322d4782eb/href
La lógica implica utilizar el elecciones.aleatorias función para proporcionar una lista ponderada y devolver un valor único.
Para calcular la lista ponderada, tenemos el peso de nuestra tienda “local” para el cliente, en este caso el 90%, por lo que debemos asignar el 10% restante a las otras tiendas, en este caso 19 tiendas. Por lo tanto, la probabilidad de que se seleccionen las demás tiendas será 10/19 = 0,526%. Podemos completar una matriz con estos porcentajes, que se vería así:[0.526,0.526,0.526,…,90,0.526,…0.526]
Al pasar esto a random.choices, luego seleccionamos aleatoriamente un ID de tienda de la lista con los pesos correspondientes y lo usamos como entrada para el Identificación del cliente variable, como antes.
Nota: La salida de random.choices devuelve una lista (ya que puede solicitar k resultados), así que acceda al elemento 0 de la lista para obtener store_id como un valor entero.
Si necesitamos combinar esta lógica con un DataFrame que incluya a todos los clientes, podemos revertir ligeramente el proceso. La lógica de pesos sigue siendo válida, por lo que podemos simplemente conectar esto para seleccionar aleatoriamente una tienda y devolver esto como resultado:
https://medium.com/media/ead16819022b7f36be7f734b577bf9fa/href
Conclusión
¡Ahí lo tenemos! Un DataFrame creado sintéticamente con asignaciones estrictas y flexibles entre columnas. Ahora puede avanzar en los siguientes pasos para completar tablas relacionadas que pueden contener más información descriptiva, como tablas de dimensiones de nombres de tiendas, direcciones, nombres de empleados, roles, etc. Esto también se puede hacer usando Databricks Labs Data Generator o cualquier otra herramienta. proceso con el que se sienta cómodo.
Hay algunos ejemplos excelentes en el generador de datos de Databricks Labs. Repositorio de GitHub junto con la documentación, así que eche un vistazo a esto si tiene curiosidad por obtener más información.
Se puede acceder a todo mi código desde lo siguiente Repositorio de GitHub.
Si tiene alguna idea, comentario o alternativa a esta demostración, comuníquese con nosotros en los comentarios. ¡Gracias!
Cree relaciones de muchos a uno entre columnas en una tabla sintética con UDF de PySpark fue publicado originalmente en Hacia la ciencia de datos en Medium, donde las personas continúan la conversación resaltando y respondiendo a esta historia.