소개:
데이터 기반 애플리케이션에는 포괄적인 테스트가 필수적이지만 항상 사용 가능하지 않을 수 있는 올바른 데이터 세트가 있어야 하는 경우가 많습니다. 웹 애플리케이션, 기계 학습 모델 또는 백엔드 시스템을 개발하는 경우 현실적이고 구조화된 데이터는 적절한 검증과 강력한 성능 보장에 매우 중요합니다. 실제 데이터 수집은 개인 정보 보호 문제, 라이센스 제한 또는 단순히 관련 데이터를 사용할 수 없는 경우로 인해 제한될 수 있습니다. 합성 데이터가 가치 있는 곳이 바로 여기입니다.

이 블로그에서는 Python을 사용하여 다음을 포함한 다양한 시나리오에 대한 합성 데이터를 생성하는 방법을 살펴보겠습니다.

1. 상호관련 테이블: 일대다 관계를 나타냅니다.
2. 계층적 데이터: 조직 구조에서 자주 사용됩니다.
3. 복잡한 관계: 등록 시스템의 다대다 관계 등.

Faker 및 Pandas 라이브러리를 활용하여 이러한 사용 사례에 대한 현실적인 데이터 세트를 만들 것입니다.

예 1: 고객 및 주문에 대한 종합 데이터 생성(일대다 관계)

많은 애플리케이션에서 데이터는 외래 키 관계를 통해 여러 테이블에 저장됩니다. 고객과 주문에 대한 합성 데이터를 생성해 보겠습니다. 고객은 일대다 관계를 나타내는 여러 주문을 할 수 있습니다.

고객 테이블 생성

고객 테이블에는 고객 ID, 이름, 이메일 주소 등의 기본 정보가 포함되어 있습니다.

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)

이 코드는 Faker를 사용하여 실제 이름과 이메일 주소를 생성하는 무작위 고객 10명을 생성합니다.

주문 테이블 생성

이제 각 주문이 CustomerID를 통해 고객과 연결되는 Orders 테이블을 생성합니다.

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)

이 경우 Orders 테이블은 CustomerID를 사용하여 각 주문을 고객에 연결합니다. 각 고객은 여러 주문을 하여 일대다 관계를 형성할 수 있습니다.

예 2: 부서 및 직원에 대한 계층적 데이터 생성

계층적 데이터는 부서에 여러 직원이 있는 조직 설정에서 자주 사용됩니다. 각 부서에 여러 직원이 있는 조직을 시뮬레이션해 보겠습니다.

부서 테이블 생성

부서 테이블에는 각 부서의 고유한 부서 ID, 이름 및 관리자가 포함되어 있습니다.

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)

직원 테이블 생성

다음으로 각 직원이 DepartmentID를 통해 부서와 연결되는 Employeestable을 생성합니다.

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)

이 계층 구조는 DepartmentID를 통해 각 직원을 부서에 연결하여 상위-하위 관계를 형성합니다.

예 3: 강좌 등록을 위한 다대다 관계 시뮬레이션

특정 시나리오에서는 하나의 엔터티가 다른 엔터티와 관련된 다대다 관계가 존재합니다. 각 코스에는 여러 명의 학생이 있는 여러 코스에 등록하는 학생들을 대상으로 이를 시뮬레이션해 보겠습니다.

강좌 테이블 생성

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)

학생 테이블 생성

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)

강좌 등록 테이블 생성

CourseEnrollments 테이블은 학생과 코스 간의 다대다 관계를 캡처합니다.

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)

이 예에서는 학생과 강좌 간의 다대다 관계를 나타내는 연결 테이블을 만듭니다.

결론:
Python과 Faker 및 Pandas와 같은 라이브러리를 사용하면 현실적이고 다양한 합성 데이터 세트를 생성하여 다양한 테스트 요구 사항을 충족할 수 있습니다. 이 블로그에서는 다음 내용을 다루었습니다.

1. 상호관련 테이블: 고객과 주문 간의 일대다 관계를 보여줍니다.
2. 계층적 데이터: 부서와 직원 간의 상위-하위 관계를 보여줍니다.
3. 복잡한 관계: 학생과 코스 간의 다대다 관계를 시뮬레이션합니다.

이러한 예는 귀하의 요구에 맞는 합성 데이터를 생성하기 위한 기반을 마련합니다. 더욱 복잡한 관계 생성, 특정 데이터베이스에 대한 데이터 사용자 정의, 성능 테스트를 위한 데이터 세트 확장 등의 추가 개선을 통해 합성 데이터 생성을 한 단계 더 발전시킬 수 있습니다.

이러한 예는 합성 데이터 생성을 위한 견고한 기반을 제공합니다. 그러나 다음과 같이 복잡성과 특이성을 높이기 위해 추가 개선이 이루어질 수 있습니다.

데이터베이스별 데이터: 다양한 데이터베이스 시스템에 대한 데이터 생성 사용자 정의(예: SQL 및 NoSQL).
더 복잡한 관계: 시간적 관계, 다단계 계층 또는 고유 제약 조건과 같은 추가 상호 종속성을 생성합니다.
데이터 확장: 성능 테스트 또는 스트레스 테스트를 위해 더 큰 데이터 세트를 생성하여 시스템이 대규모로 실제 조건을 처리할 수 있도록 보장합니다. 요구 사항에 맞는 합성 데이터를 생성하면 민감하거나 획득하기 어려운 데이터 세트에 의존하지 않고도 애플리케이션 개발, 테스트 및 최적화를 위한 현실적인 조건을 시뮬레이션할 수 있습니다.