Introduction:
Des tests complets sont essentiels pour les applications basées sur les données, mais ils nécessitent souvent de disposer des bons ensembles de données, qui ne sont pas toujours disponibles. Que vous développiez des applications Web, des modèles d'apprentissage automatique ou des systèmes backend, des données réalistes et structurées sont essentielles pour une validation appropriée et garantir des performances robustes. L'acquisition de données réelles peut être limitée en raison de problèmes de confidentialité, de restrictions de licence ou simplement de l'indisponibilité des données pertinentes. C'est là que les données synthétiques deviennent précieuses.

Dans ce blog, nous explorerons comment Python peut être utilisé pour générer des données synthétiques pour différents scénarios, notamment :

1. Tables interdépendantes : représentant des relations un-à-plusieurs.
2. Données hiérarchiques : souvent utilisées dans les structures organisationnelles.
3. Relations complexes : telles que les relations plusieurs-à-plusieurs dans les systèmes d'inscription.

Nous exploiterons les bibliothèques Faker et Pandas pour créer des ensembles de données réalistes pour ces cas d'utilisation.

Exemple 1 : Création de données synthétiques pour les clients et les commandes (relation un-à-plusieurs)

Dans de nombreuses applications, les données sont stockées dans plusieurs tables avec des relations de clé étrangère. Générons des données synthétiques pour les clients et leurs commandes. Un client peut passer plusieurs commandes, ce qui représente une relation un-à-plusieurs.

Génération de la table Clients

La table Clients contient des informations de base telles que l'ID client, le nom et l'adresse e-mail.

import pandas as pd
from faker import Faker
import random

fake = Faker()

def generate_customers(num_customers):
    customers = []
    for _ in range(num_customers):
        customer_id = fake.uuid4()
        name = fake.name()
        email = fake.email()
        customers.append({'CustomerID': customer_id, 'CustomerName': name, 'Email': email})
    return pd.DataFrame(customers)

customers_df = generate_customers(10)

Ce code génère 10 clients aléatoires en utilisant Faker pour créer des noms et des adresses e-mail réalistes.

Génération du tableau des commandes

Maintenant, nous générons la table Commandes, où chaque commande est associée à un client via CustomerID.

def generate_orders(customers_df, num_orders):
    orders = []
    for _ in range(num_orders):
        order_id = fake.uuid4()
        customer_id = random.choice(customers_df['CustomerID'].tolist())
        product = fake.random_element(elements=('Laptop', 'Phone', 'Tablet', 'Headphones'))
        price = round(random.uniform(100, 2000), 2)
        orders.append({'OrderID': order_id, 'CustomerID': customer_id, 'Product': product, 'Price': price})
    return pd.DataFrame(orders)

orders_df = generate_orders(customers_df, 30)

Dans ce cas, la table Commandes relie chaque commande à un client à l'aide du CustomerID. Chaque client peut passer plusieurs commandes, formant ainsi une relation un-à-plusieurs.

Exemple 2 : Génération de données hiérarchiques pour les départements et les employés

Les données hiérarchiques sont souvent utilisées dans les contextes organisationnels, où les départements comptent plusieurs employés. Simulons une organisation avec des départements, chacun comptant plusieurs employés.

Génération de la table des départements

La table Départements contient l'ID de service, le nom et le responsable uniques de chaque département.

def generate_departments(num_departments):
    departments = []
    for _ in range(num_departments):
        department_id = fake.uuid4()
        department_name = fake.company_suffix()
        manager = fake.name()
        departments.append({'DepartmentID': department_id, 'DepartmentName': department_name, 'Manager': manager})
    return pd.DataFrame(departments)

departments_df = generate_departments(10)

Génération de la table des employés

Ensuite, nous générons l'Employeestable, où chaque employé est associé à un service via DepartmentID.

def generate_employees(departments_df, num_employees):
    employees = []
    for _ in range(num_employees):
        employee_id = fake.uuid4()
        employee_name = fake.name()
        email = fake.email()
        department_id = random.choice(departments_df['DepartmentID'].tolist())
        salary = round(random.uniform(40000, 120000), 2)
        employees.append({
            'EmployeeID': employee_id,
            'EmployeeName': employee_name,
            'Email': email,
            'DepartmentID': department_id,
            'Salary': salary
        })
    return pd.DataFrame(employees)

employees_df = generate_employees(departments_df, 100)

Cette structure hiérarchique relie chaque employé à un département via DepartmentID, formant une relation parent-enfant.

Exemple 3 : simulation de relations plusieurs-à-plusieurs pour les inscriptions à des cours

Dans certains scénarios, il existe des relations plusieurs-à-plusieurs, dans lesquelles une entité est liée à plusieurs autres. Simulons cela avec des étudiants s'inscrivant à plusieurs cours, où chaque cours compte plusieurs étudiants.

Génération du tableau des cours

def generate_courses(num_courses):
    courses = []
    for _ in range(num_courses):
        course_id = fake.uuid4()
        course_name = fake.bs().title()
        instructor = fake.name()
        courses.append({'CourseID': course_id, 'CourseName': course_name, 'Instructor': instructor})
    return pd.DataFrame(courses)

courses_df = generate_courses(20)

Génération de la table des étudiants

def generate_students(num_students):
    students = []
    for _ in range(num_students):
        student_id = fake.uuid4()
        student_name = fake.name()
        email = fake.email()
        students.append({'StudentID': student_id, 'StudentName': student_name, 'Email': email})
    return pd.DataFrame(students)

students_df = generate_students(50)
print(students_df)

Génération du tableau des inscriptions aux cours

Le tableau CourseEnrollments capture la relation plusieurs-à-plusieurs entre les étudiants et les cours.

def generate_course_enrollments(students_df, courses_df, num_enrollments):
    enrollments = []
    for _ in range(num_enrollments):
        enrollment_id = fake.uuid4()
        student_id = random.choice(students_df['StudentID'].tolist())
        course_id = random.choice(courses_df['CourseID'].tolist())
        enrollment_date = fake.date_this_year()
        enrollments.append({
            'EnrollmentID': enrollment_id,
            'StudentID': student_id,
            'CourseID': course_id,
            'EnrollmentDate': enrollment_date
        })
    return pd.DataFrame(enrollments)

enrollments_df = generate_course_enrollments(students_df, courses_df, 200)

Dans cet exemple, nous créons une table de liaison pour représenter les relations plusieurs-à-plusieurs entre les étudiants et les cours.

Conclusion:
En utilisant Python et des bibliothèques comme Faker et Pandas, vous pouvez générer des ensembles de données synthétiques réalistes et diversifiés pour répondre à une variété de besoins de tests. Dans ce blog, nous avons couvert :

1. Tableaux interdépendants : démontrant une relation un-à-plusieurs entre les clients et les commandes.
2. Données hiérarchiques : illustrant une relation parent-enfant entre les départements et les employés.
3. Relations complexes : simulation de relations plusieurs-à-plusieurs entre les étudiants et les cours.

Ces exemples jettent les bases de la génération de données synthétiques adaptées à vos besoins. D'autres améliorations, telles que la création de relations plus complexes, la personnalisation des données pour des bases de données spécifiques ou la mise à l'échelle d'ensembles de données pour les tests de performances, peuvent faire passer la génération de données synthétiques à un niveau supérieur.

Ces exemples fournissent une base solide pour générer des données synthétiques. Cependant, d'autres améliorations peuvent être apportées pour accroître la complexité et la spécificité, telles que :

1. Données spécifiques à la base de données : personnalisation de la génération de données pour différents systèmes de bases de données (par exemple, SQL ou NoSQL).
2. Relations plus complexes : création d'interdépendances supplémentaires, telles que des relations temporelles, des hiérarchies à plusieurs niveaux ou des contraintes uniques.
3. Mise à l'échelle des données : génération d'ensembles de données plus volumineux pour les tests de performances ou les tests de résistance, garantissant que le système peut gérer les conditions du monde réel à grande échelle. En générant des données synthétiques adaptées à vos besoins, vous pouvez simuler des conditions réalistes pour développer, tester et optimiser des applications sans avoir recours à des ensembles de données sensibles ou difficiles à acquérir.

Si vous aimez l'article, partagez-le avec vos amis et collègues. Vous pouvez me contacter sur LinkedIn pour discuter d'autres idées.