Introdução:
Testes abrangentes são essenciais para aplicações orientadas por dados, mas muitas vezes dependem da disponibilidade dos conjuntos de dados corretos, que nem sempre estão disponíveis. Esteja você desenvolvendo aplicativos da Web, modelos de aprendizado de máquina ou sistemas de back-end, dados realistas e estruturados são cruciais para a validação adequada e para garantir um desempenho robusto. A aquisição de dados do mundo real pode ser limitada devido a questões de privacidade, restrições de licenciamento ou simplesmente à indisponibilidade de dados relevantes. É aqui que os dados sintéticos se tornam valiosos.

Neste blog, exploraremos como Python pode ser usado para gerar dados sintéticos para diferentes cenários, incluindo:

1. Tabelas inter-relacionadas: representando relacionamentos um-para-muitos.
2. Dados hierárquicos: frequentemente usados ​​em estruturas organizacionais.
3. Relacionamentos complexos: como relacionamentos muitos-para-muitos em sistemas de inscrição.

Aproveitaremos as bibliotecas faker e pandas para criar conjuntos de dados realistas para esses casos de uso.

Exemplo 1: Criação de dados sintéticos para clientes e pedidos (relacionamento um-para-muitos)

Em muitos aplicativos, os dados são armazenados em várias tabelas com relacionamentos de chave estrangeira. Vamos gerar dados sintéticos para clientes e seus pedidos. Um cliente pode fazer vários pedidos, representando um relacionamento um-para-muitos.

Gerando a tabela de clientes

A tabela Clientes contém informações básicas como CustomerID, nome e endereço de 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)

Este código gera 10 clientes aleatórios usando Faker para criar nomes e endereços de e-mail realistas.

Gerando a tabela de pedidos

Agora geramos a tabela Pedidos, onde cada pedido é associado a um cliente através do 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)

Nesse caso, a tabela Pedidos vincula cada pedido a um cliente usando o CustomerID. Cada cliente pode fazer vários pedidos, formando um relacionamento um-para-muitos.

Exemplo 2: Gerando dados hierárquicos para departamentos e funcionários

Os dados hierárquicos são frequentemente usados ​​em ambientes organizacionais, onde os departamentos têm vários funcionários. Vamos simular uma organização com departamentos, cada um com vários funcionários.

Gerando a Tabela de Departamentos

A tabela Departamentos contém o DepartmentID, o nome e o gerente exclusivos de cada departamento.

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)

Gerando a Tabela de Funcionários

Em seguida, geramos a tabelaEmployeestable, onde cada funcionário é associado a um departamento 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)

Essa estrutura hierárquica vincula cada funcionário a um departamento por meio do DepartmentID, formando um relacionamento pai-filho.

Exemplo 3: Simulação de relacionamentos muitos-para-muitos para inscrições em cursos

Em certos cenários, existem relacionamentos muitos-para-muitos, onde uma entidade se relaciona com muitas outras. Vamos simular isso com alunos matriculados em vários cursos, onde cada curso tem vários alunos.

Gerando a Tabela de Cursos

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)

Gerando a tabela de alunos

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)

Gerando a Tabela de Matrículas do Curso

A tabela CourseEnrollments captura o relacionamento muitos-para-muitos entre alunos e cursos.

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)

Neste exemplo, criamos uma tabela de ligação para representar relacionamentos muitos-para-muitos entre alunos e cursos.

Conclusão:
Usando Python e bibliotecas como Faker e Pandas, você pode gerar conjuntos de dados sintéticos diversificados e realistas para atender a uma variedade de necessidades de teste. Neste blog, cobrimos:

1. Tabelas inter-relacionadas: demonstrando um relacionamento um-para-muitos entre clientes e pedidos.
2. Dados hierárquicos: ilustrando uma relação pai-filho entre departamentos e funcionários.
3. Relacionamentos Complexos: Simulando relacionamentos muitos-para-muitos entre alunos e cursos.

Esses exemplos estabelecem a base para a geração de dados sintéticos adaptados às suas necessidades. Aprimoramentos adicionais, como a criação de relacionamentos mais complexos, a personalização de dados para bancos de dados específicos ou o dimensionamento de conjuntos de dados para testes de desempenho, podem levar a geração de dados sintéticos ao próximo nível.

Esses exemplos fornecem uma base sólida para a geração de dados sintéticos. No entanto, melhorias adicionais podem ser feitas para aumentar a complexidade e especificidade, tais como:

1. Dados específicos do banco de dados: personalização da geração de dados para diferentes sistemas de banco de dados (por exemplo, SQL vs. NoSQL).
2. Relacionamentos mais complexos: criação de interdependências adicionais, como relacionamentos temporais, hierarquias de vários níveis ou restrições exclusivas.
3. Escalonamento de dados: geração de conjuntos de dados maiores para testes de desempenho ou testes de estresse, garantindo que o sistema possa lidar com condições do mundo real em escala. Ao gerar dados sintéticos adaptados às suas necessidades, você pode simular condições realistas para desenvolver, testar e otimizar aplicativos sem depender de conjuntos de dados confidenciais ou difíceis de adquirir.

Se você gostou do artigo, compartilhe-o com seus amigos e colegas. Você pode se conectar comigo no LinkedIn para discutir outras ideias.