Il peut arriver que vous ayez un dashboard à faire mais que le dataset ne soit pas encore prêt.
Pour gagner du temps et ne pas se retrouver à bâcler l’étape dashboarding à la fin du projet, je vous propose une solution pour générer un dataset avec des fausses données et pouvoir commencer votre dashboard dès maintenant !
Dans cet article, je vais vous expliquer ce qu’est Faker et comment l’utiliser directement dans BigQuery et Snowflake.
Faker : qu’est ce que c’est ?
Faker, c’est tout simplement un package python qui génère de la fausse donnée.
Pour que notre faux dataset paraisse plus réaliste, on peut spécifier en argument une variable locale lorsqu’on créé l’instance de Faker pour que les fausses données générées correspondent à un certains pays (par exemple fr_FR pour la France). Un exemple de l’utilité de ceci est pour que les noms ou adresses générées correspondent au format du pays en question. La locale par défaut est l’anglais américain (en_US). Il est aussi possible de spécifier plusieurs locales (si par exemple le dataset que vous attendez contiendra des données de France, d’Italie, et d’Angleterre (['fr_FR', 'it_IT', 'en_GB']).
Il y a de nombreuses possibilités de type de données que Faker génère, ils sont appelés des providers. La liste de tous les providers est disponible ici. En plus, il y a des providers additionnels (community providers) sur des sujets spécifiques tels que les aéroports, la biologie, etc. qui peuvent être trouvés ici.
Bien que de nombreuses possibilités soient mises à disposition par Faker nativement, vous aurez parfois besoin d’un champ customisé. Pour ça, pas de soucis ! Je vous présente les custom providers. Pour en créer un, il faut tout d’abord s’assurer d’importer la classe DynamicProvider du module faker.providers. Ensuite, il faut le déclarer avant d’appeler l’instance de Faker. Et enfin, spécifier qu’on veut utiliser notre dynamic provider. Voilà un exemple d’un dynamic provider animals, qui nous donne un des animaux listés au hasard. ⬇️
python
from faker import Faker
from faker.providers import DynamicProvider
animal_provider =DynamicProvider(
provider_name='animals',
elements=['cat','dog','girafe','pig','fish'])
fake=Faker()
fake.add_provider(animal_provider)
Pour l’exemple, on va imaginer qu’on veut créer une table avec tous les clients de notre shop, et on l’appelle customer. Pour cela il faut :
une instance de Faker pour pouvoir par la suite l’utiliser pour générer de la fausse donnée
un dataframe vide appelé fake_data (ici on utilise pandas) pour qu’on puisse le remplir plus tard
une boucle pour spécifier le nombre de ligne à générer (ici on a choisi 10)
python
import pandas as pd
import faker
from faker import Faker
def fake_dataset():
fake =Faker()
customer = pd.DataFrame()for i inrange(0,10):
customer.loc[i,'customer_id']= fake.random(fix_len=True, digit=7)
customer.loc[i,'customer_first_name']= fake.first_name()
customer.loc[i,'customer_last_name']= fake.last_name()print(customer)
Vous pouvez combiner Faker avec d’autres packages comme random qui génère des nombres aléatoirement
Bien qu’on puisse générer un .csv et brancher ça à notre dashboard, on peut faire autrement et utiliser nos warehouse : BigQuery et Snowflake. Pourquoi passer par là ?
Mettre en place en amont la connection entre l’outil de visualisation et la warehouse
D’autres utilisateurs peuvent facilement utiliser votre dataset
Faker dans BigQuery
Dans BigQuery Studio, comme pour les fichiers SQL, on peut également créer des notebooks python (doc Google Cloud).
Pour pouvoir accueillir votre faux dataset, il faut en amont que vous ayez créé une table (et potentiellement un dataset) (doc Google Cloud).
Si Faker n’est pas installé dans BigQuery, on peut faire un pip install Faker directement dans le notebook.
Maintenant que tout est prêt, vous pouvez commencer à remplir votre dataset.
Pour que votre dataframe atterrisse dans votre table vide fraichement créée, il faut s’assurer d’avoir importé les packages google.cloud et google.oauth2.
Pour uploader un dataframe Pandas dans une table BigQuery, vous pouvez utiliser la fonction pandas_gbq.to_gbq() (donc il vous faudra importer le package pandas_gbq).
Pour mettre un peu de contexte dans tout ça, voici un exemple. ⬇️
python
from google.cloud import bigquery
from google.oauth2 import service_account
import pandas as pd
import faker
import random
from faker import Faker
from faker.providers import DynamicProvider
from random import randint
import pandas_gbq
def fake_dataset():
animal_provider =DynamicProvider(
provider_name='animals',
elements=['cat','dog','girafe','pig','fish'])
fake=Faker() ## or fake=Faker(locale='fr_FR')if you want to use a locale
fake.add_provider(animal_provider)
## add the dynamics providers
fake_dataset = pd.DataFrame()for i inrange(0,10):
fake_dataset.loc[i,'customer_id']= fake.random_number(fix_len=True, digits=7)
fake_dataset.loc[i,'customer_first_name']=fake.first_name()
fake_dataset.loc[i,'customer_last_name']=fake.last_name()
fake_dataset.loc[i,'customer_address']=fake.address()
fake_dataset.loc[i,'customer_pet']=fake.animals()return fake_dataset
pandas_gbq.to_gbq(fake_dataset(), table_id, project_id = project_id, if_exists ='replace')
Le project_id se trouve est à remplacer par l’identifiant du projet et le table_id est l’identifiant de la table dans laquelle on veut mettre les données, les deux avec des guillemets.
On peut utiliser plusieurs arguments dans le paramètre if_exists pour choisir comment on ajoute les données à la table (fail, replace, append).
Faker dans Snowflake
Dans Snowflake, un peu comme dans BigQuery, on peut créer des Python Worksheets en utilisant Snowpark.
Ici, il faut utiliser la handler function appelée main par défaut et qui est pré-remplie automatiquement lors de la création de la python worksheet.
Il faut bien faire le set-up du fichier en indiquant la database dans laquelle on veut que notre nouvelle table se trouve et en sélectionnant les packages à installer.
Le package snowflake.snowpark est indispensable car il permet à Snowflake de prendre en charge des languages non-SQL comme le python.
Ici, pas besoin de créer en amont une table vide car snowpark nous permet de créer un dataframe grâce à la fonction session.create_dataframe(). Ensuite on utilise la fonction df.write.mode() pour spécifier comment la donnée va être écrite dans sa destination. On a le choix entre overwrite, append, error, ou ignore. Combiné à save_as_table, on précise le nom de la table dans laquelle on veut mettre nos données. Si la table existe déjà, alors les nouvelles données sont ajoutées à celle-ci en fonction de la méthode choisie (e.g. overwrite) et si la table n’existe pas, elle est alors automatiquement créée.
Pour mettre un peu de contexte dans tout ça, voici un exemple. ⬇️
python
import snowflake.snowpark as snowpark
import pandas as pd
import faker
import random
from faker import Faker
from faker.providers import DynamicProvider
from random import randint
def main(session: snowpark.Session):
animal_provider =DynamicProvider(
provider_name='animals',
elements=['cat','dog','girafe','pig','fish'])
fake =Faker() # If you want data from a specific country, use fake =Faker(locale='en_IN') instead. Here it is going to be for english
# Add the dynamics providers
fake.add_provider(animal_provider)
fake_dataset = pd.DataFrame()for i inrange(0,10):
fake_dataset.loc[i,'customer_id']= fake.random_number(fix_len=True, digits=7)
fake_dataset.loc[i,'customer_first_name']=fake.first_name()
fake_dataset.loc[i,'customer_last_name']=fake.last_name()
fake_dataset.loc[i,'customer_address']=fake.address()
fake_dataset.loc[i,'customer_pet']=fake.animals()
df = session.create_dataframe(fake_dataset)
df.write.mode('overwrite').save_as_table('fake_data_table')
# Return value will appear in the Results tab.return df
Et voilà ! Vous savez maintenant tout pour générer votre dataset et commencer votre dashboard !
✍️
L’auteure : Eva Despesse
BI Engineer chez UnNest, Eva est en charge des sujets de modélisation de la donnée et du dashboarding, notamment sur Tableau.
Ayant commencé dans une start-up, j’ai pu toucher aux flux de données de bout en bout. J’apprécie particulièrement faire les modélisations en bout de chaine avec le dashboarding pour suivre toute la chaine de transformation de données en information.
