Einführung:
Umfassende Tests sind für datengesteuerte Anwendungen unerlässlich, erfordern jedoch häufig die Verfügbarkeit der richtigen Datensätze, die möglicherweise nicht immer verfügbar sind. Unabhängig davon, ob Sie Webanwendungen, Modelle für maschinelles Lernen oder Backend-Systeme entwickeln, sind realistische und strukturierte Daten für eine ordnungsgemäße Validierung und die Gewährleistung einer robusten Leistung von entscheidender Bedeutung. Die Erfassung realer Daten kann aufgrund von Datenschutzbedenken, Lizenzbeschränkungen oder einfach der Nichtverfügbarkeit relevanter Daten eingeschränkt sein. Hier werden synthetische Daten wertvoll.

In diesem Blog werden wir untersuchen, wie Python zum Generieren synthetischer Daten für verschiedene Szenarien verwendet werden kann, darunter:

1. Zusammenhängende Tabellen: Darstellung von Eins-zu-vielen-Beziehungen.
2. Hierarchische Daten: Wird häufig in Organisationsstrukturen verwendet.
3. Komplexe Beziehungen: Beispielsweise viele-zu-viele-Beziehungen in Registrierungssystemen.

Wir werden die Faker- und Pandas-Bibliotheken nutzen, um realistische Datensätze für diese Anwendungsfälle zu erstellen.

Beispiel 1: Erstellen synthetischer Daten für Kunden und Bestellungen (Eins-zu-Viele-Beziehung)

In vielen Anwendungen werden Daten in mehreren Tabellen mit Fremdschlüsselbeziehungen gespeichert. Lassen Sie uns synthetische Daten für Kunden und ihre Bestellungen generieren. Ein Kunde kann mehrere Bestellungen aufgeben, was eine Eins-zu-Viele-Beziehung darstellt.

Erstellen der Kundentabelle

Die Kundentabelle enthält grundlegende Informationen wie Kunden-ID, Name und E-Mail-Adresse.

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)

Dieser Code generiert mithilfe von Faker 10 zufällige Kunden, um realistische Namen und E-Mail-Adressen zu erstellen.

Erstellung der Auftragstabelle

Jetzt generieren wir die Tabelle „Bestellungen“, in der jede Bestellung über die Kunden-ID einem Kunden zugeordnet ist.

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)

In diesem Fall verknüpft die Tabelle „Bestellungen“ jede Bestellung mithilfe der Kunden-ID mit einem Kunden. Jeder Kunde kann mehrere Bestellungen aufgeben und so eine Eins-zu-Viele-Beziehung aufbauen.

Beispiel 2: Hierarchische Daten für Abteilungen und Mitarbeiter generieren

Hierarchische Daten werden häufig in Organisationsumgebungen verwendet, in denen Abteilungen mehrere Mitarbeiter haben. Lassen Sie uns eine Organisation mit Abteilungen simulieren, von denen jede mehrere Mitarbeiter hat.

Erstellen der Abteilungstabelle

Die Tabelle „Abteilungen“ enthält die eindeutige Abteilungs-ID, den Namen und den Manager jeder Abteilung.

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)

Erstellen der Mitarbeitertabelle

Als nächstes generieren wir die Mitarbeitertabelle, in der jeder Mitarbeiter über die Abteilungs-ID einer Abteilung zugeordnet ist.

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)

Diese hierarchische Struktur verknüpft jeden Mitarbeiter über die Abteilungs-ID mit einer Abteilung und bildet so eine Eltern-Kind-Beziehung.

Beispiel 3: Simulieren von Many-to-Many-Beziehungen für Kursanmeldungen

In bestimmten Szenarien bestehen Viele-zu-Viele-Beziehungen, bei denen eine Entität mit vielen anderen in Beziehung steht. Lassen Sie uns dies mit Studenten simulieren, die sich für mehrere Kurse anmelden, wobei jeder Kurs mehrere Studenten hat.

Erstellen der Kurstabelle

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)

Erstellen der Schülertabelle

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)

Erstellen der Kursanmeldungstabelle

Die Tabelle „CourseEnrollments“ erfasst die Viele-zu-Viele-Beziehung zwischen Studenten und Kursen.

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)

In diesem Beispiel erstellen wir eine Verknüpfungstabelle, um m:n-Beziehungen zwischen Studierenden und Kursen darzustellen.

Abschluss:
Mit Python und Bibliotheken wie Faker und Pandas können Sie realistische und vielfältige synthetische Datensätze generieren, um eine Vielzahl von Testanforderungen zu erfüllen. In diesem Blog haben wir Folgendes behandelt:

1. Zusammenhängende Tabellen: Demonstration einer Eins-zu-Viele-Beziehung zwischen Kunden und Bestellungen.
2. Hierarchische Daten: Veranschaulichung einer Eltern-Kind-Beziehung zwischen Abteilungen und Mitarbeitern.
3. Komplexe Beziehungen: Simulation von Viele-zu-Viele-Beziehungen zwischen Studenten und Kursen.

Diese Beispiele legen den Grundstein für die Generierung synthetischer Daten, die auf Ihre Bedürfnisse zugeschnitten sind. Weitere Verbesserungen, wie das Erstellen komplexerer Beziehungen, das Anpassen von Daten für bestimmte Datenbanken oder das Skalieren von Datensätzen für Leistungstests, können die Generierung synthetischer Daten auf die nächste Stufe heben.

Diese Beispiele bieten eine solide Grundlage für die Generierung synthetischer Daten. Es können jedoch weitere Verbesserungen vorgenommen werden, um die Komplexität und Spezifität zu erhöhen, wie zum Beispiel:

1. Datenbankspezifische Daten: Anpassen der Datengenerierung für verschiedene Datenbanksysteme (z. B. SQL vs. NoSQL).
2. Komplexere Beziehungen: Erstellen zusätzlicher gegenseitiger Abhängigkeiten, wie z. B. zeitliche Beziehungen, mehrstufige Hierarchien oder eindeutige Einschränkungen.
3. Daten skalieren: Generieren größerer Datensätze für Leistungstests oder Stresstests, um sicherzustellen, dass das System reale Bedingungen im großen Maßstab bewältigen kann. Durch die Generierung synthetischer Daten, die auf Ihre Bedürfnisse zugeschnitten sind, können Sie realistische Bedingungen zum Entwickeln, Testen und Optimieren von Anwendungen simulieren, ohne auf sensible oder schwer zu beschaffende Datensätze angewiesen zu sein.

Wenn Ihnen der Artikel gefällt, teilen Sie ihn bitte mit Ihren Freunden und Kollegen. Sie können sich auf LinkedIn mit mir in Verbindung setzen, um weitere Ideen zu besprechen.