Gerando dados sintéticos com Python Faker: tutorial

O que são dados sintéticos?

Dados sintéticos são dados gerados por computador que se assemelham a dados do mundo real. O principal objetivo dos dados sintéticos é aumentar a privacidade e a integridade dos sistemas. Por exemplo, para proteger informações de identificação pessoal (PII) ou informações de saúde pessoais (PHI) dos usuários, as empresas precisam implementar estratégias de proteção de dados. Usar dados sintéticos ajuda as empresas a testar novas aplicações e proteger a privacidade dos usuários. 

No caso de aprendizado de máquina, usamos dados sintéticos para melhorar o desempenho dos modelos. Eles também são úteis quando os dados são escassos ou desbalanceados. Os usos típicos de dados sintéticos em aprendizado de máquina incluem veículos autônomos, segurança, robótica, proteção contra fraudes e saúde. 

Imagem: Nvidia

Segundo dados da Gartner, até 2024, 60% dos dados usados para desenvolver aplicações de machine learning e analytics serão gerados sinteticamente. Mas por que estamos vendo essa tendência de alta no uso de dados sintéticos? 

Coletar e limpar dados do mundo real é caro e, em alguns casos, raro. Por exemplo, é difícil encontrar dados reais sobre fraudes bancárias, câncer de mama, carros autônomos e ataques de malware. Mesmo que você obtenha os dados, vai levar tempo e recursos para limpá-los e processá-los para tarefas de aprendizado de máquina. 

Na primeira parte do tutorial, vamos entender por que precisamos de dados sintéticos, suas aplicações e como gerá-los. Na parte final, vamos explorar a biblioteca Python Faker e usá-la para criar dados sintéticos para testes e para manter a privacidade dos usuários. 

Por que precisamos gerar dados sintéticos?

Imagem do autor

Precisamos de dados sintéticos para garantir a privacidade dos usuários, testar aplicações, melhorar o desempenho de modelos, representar casos raros e reduzir custos operacionais.

• Privacidade: para proteger os dados dos usuários. Você pode substituir nomes, e-mails e endereços por dados sintéticos. Isso ajuda a evitar ataques cibernéticos e ataques de caixa-preta, nos quais modelos inferem detalhes dos dados de treinamento.
• Testes: testar aplicações com dados reais é caro. Testar bancos de dados, interfaces e aplicações de IA com dados sintéticos é mais econômico e seguro.
• Desempenho do modelo: dados sintéticos gerados podem melhorar o desempenho. Exemplo: em classificadores de imagens, aplicamos cisalhamento, deslocamento e rotação para aumentar o tamanho do dataset e melhorar a acurácia do modelo. 
• Casos raros: não dá para esperar o evento raro acontecer para coletar dados reais. Exemplos: detecção de fraude em crédito, batidas de carro e dados de câncer. 
• Custo: coletar dados consome tempo e recursos. É caro adquirir dados reais, limpá-los, rotulá-los e prepará-los para testes ou treinamento de modelos. 

Quais são as aplicações de dados sintéticos?

Nesta seção, vamos ver como as empresas usam dados sintéticos para construir aplicações de alto desempenho, com foco em privacidade e custo-benefício. 

1. Compartilhamento de dados: dados sintéticos permitem que empresas compartilhem dados sensíveis internamente e com terceiros. Também ajudam a migrar dados privados para a nuvem e a reter dados para análises.
2. Serviços financeiros: geram-se dados sintéticos para simular eventos raros, como transações fraudulentas, detecção de anomalias e recessões econômicas. Também servem para entender o comportamento de clientes com ferramentas de analytics. 
3. Garantia de qualidade: manter e testar a qualidade de aplicações ou sistemas de dados. Os dados sintéticos são usados para testar sistemas em anomalias raras e melhorar o desempenho.
4. Saúde: permitem compartilhar prontuários internamente e externamente preservando a confidencialidade dos pacientes. Você também pode usá-los em testes clínicos e na detecção de doenças raras. Aprenda a processar informações sensíveis com um curso de privacidade de dados e anonimização em Python ou R. 
5. Automotivo: é difícil e demorado obter dados reais para robôs, drones e carros autônomos. Empresas testam e treinam seus sistemas com dados de simulação sintéticos e economizam na construção de soluções sem perder desempenho. 
6. Machine learning: podemos usar dados sintéticos para aumentar o dataset de treinamento, resolver problemas de desbalanceamento e testar modelos para garantir desempenho e precisão. Também é usado para reduzir vieses em dados de imagem e texto existentes. Isso ajuda a testar sistemas e manter a privacidade dos usuários. Por exemplo, DeepFake é usado para testar sistemas de reconhecimento facial. 

Como gerar dados sintéticos

Podemos usar geradores de dados falsos, ferramentas estatísticas, redes neurais e redes generativas adversárias para gerar dados sintéticos.  

Gerando bases de dados falsas com a biblioteca Faker para testar bancos de dados e sistemas. Ela pode gerar perfis de usuários com endereços e todas as informações essenciais. Você também pode gerar textos e parágrafos aleatórios. Isso ajuda empresas a proteger a privacidade dos usuários na fase de testes e a economizar na aquisição de datasets reais. 

Entendendo a distribuição dos dados para gerar um dataset totalmente novo com ferramentas estatísticas como Gaussiana, Exponencial, Qui-quadrado, t, lognormal e Uniforme. É preciso ter conhecimento do domínio para gerar dados sintéticos baseados em distribuição. 

Variational Autoencoder (VAE) é um método de aprendizado não supervisionado que usa um codificador e um decodificador para comprimir o dataset original e gerar uma representação dos dados originais. Ele é projetado para otimizar a correlação entre os conjuntos de entrada e saída. 

Generative Adversarial Network (GAN) é a forma mais popular de gerar dados. Dá para criar imagens, sons, dados tabulares e dados de simulação sintéticos. Usa uma arquitetura de aprendizado profundo com gerador e discriminador para produzir dados sintéticos comparando amostras aleatórias com dados reais. Leia nosso tutorial Desmistificando redes generativas adversárias para criar seus próprios dados sintéticos com Keras.  

O que é Python Faker?

Python Faker é um pacote open source de Python usado para criar datasets falsos para testes de aplicações, popular dados em bancos e manter o anonimato dos usuários.

Imagem do autor

Você pode instalar o Faker com:

pip install faker

O Faker vem com suporte a linha de comando, fixtures para Pytest, localização (diferentes regiões), reprodutibilidade e providers dinâmicos (para personalizar conforme sua necessidade).

Você também pode usar as funcionalidades básicas do Faker para criar um dataset rápido e adaptá-lo ao seu caso. Na tabela abaixo, você confere várias funções do Faker e seus propósitos. 

Para conhecer funções mais avançadas, consulte a documentação do Faker.

É importante revisar essas funções, pois vamos usá-las para criar vários exemplos e dataframes. 

Geração de dados sintéticos com Python Faker

Nesta seção, vamos usar o Python Faker para gerar dados sintéticos. Ela tem 5 exemplos de como usar o Faker em diferentes tarefas. A ideia é adotar uma abordagem centrada em privacidade para testar sistemas. Na última parte, vamos gerar dados falsos para complementar os dados originais usando o provider localizado do Faker. 

Você encontra todo o código deste tutorial neste workbook do DataLab; você pode criar sua própria cópia para rodar tudo no navegador, sem instalar nada no seu computador.

Primeiro, vamos iniciar um gerador com `Faker()`. Por padrão, ele usa o locale “en_US”. 

from faker import Faker
fake = Faker()

Exemplo 1

O objeto “fake” pode gerar dados chamando propriedades. Por exemplo, `fake.name()` gera o nome completo aleatório de uma pessoa.

print(fake.name())
>>> Jessica Robinson

Da mesma forma, podemos gerar e-mail, país, texto, geolocalização e URL falsos, como abaixo.  

print(fake.email())
print(fake.country())
print(fake.name())
print(fake.text())
print(fake.latitude(), fake.longitude())
print(fake.url())

Saída

ybanks@example.com
Mayotte
Mr. Jose Browning DDS
Dog might bank dog total life financial. Dark view doctor time just.
Stay second treatment language theory. Space seek adult create matter imagine lay.
51.7514185 -148.802970
http://fischer.info/

Exemplo 2

Você pode usar diferentes locales para gerar dados em vários idiomas e regiões. 

No exemplo abaixo, vamos gerar dados em espanhol e com a região Espanha.

fake = Faker("es_ES")
print(fake.email())
print(fake.country())
print(fake.name())
print(fake.text())
print(fake.latitude(), fake.longitude())
print(fake.url())

Saída

Como dá para ver, o nome da pessoa mudou e o texto está em espanhol.

casandrahierro@example.com
Tonga
Juan Solera-Mancebo
Cumque adipisci eligendi aperiam. Quas laboriosam amet at dignissimos. Excepturi pariatur ipsam esse.
89.180798 -2.274117
https://corbacho-galan.net/

Vamos testar agora com o idioma alemão e Alemanha como país. Para gerar um perfil completo de usuário, usamos a função `profile()`.

fake = Faker("de_DE")
fake.profile()

Saída

Fica claro como podemos usar o Faker para gerar dados em vários idiomas e países. Trocar o locale muda nome, profissão, endereço, empresa e outros dados de identificação conforme o idioma e o país.  

{'job': 'Erzieher',
'company': 'Stadelmann Thanel GmbH',
'ssn': '631-64-0521',
'residence': 'Leo-Schinke-Allee 298\n26224 Altötting',
'current_location': (Decimal('51.5788595'), Decimal('29.780659')),
'blood_group': 'B+',
'website': ['https://www.schmidtke.de/',
  'https://roskoth.com/',
  'http://www.textor.de/',
  'https://www.zirme.com/'],
'username': 'vdoerr',
'name': 'Francesca Fröhlich',
'sex': 'F',
'address': 'Steinbergallee 13\n84765 Saarbrücken',
' mail': 'smuehle@gmail.com',
'birthdate': datetime.date(1998, 3, 19)}

Exemplo 3

Neste exemplo, vamos criar um dataframe do pandas usando o Faker.

1. Criar um dataframe vazio (data) no pandas
2. Passar por x laços para criar várias linhas
3. Usar `randint()` para gerar id único
4. Usar o Faker para criar nome, endereço e geolocalização
5. Executar a função `input_data()` com x=10

from random import randint 
import pandas as pd 
 
fake = Faker()
 
def input_data(x):
   
    # pandas dataframe
    data = pd.DataFrame()
    for i in range(0, x):
        data.loc[i,'id']= randint(1, 100)
        data.loc[i,'name']= fake.name()
        data.loc[i,'address']= fake.address()
        data.loc[i,'latitude']= str(fake.latitude())
        data.loc[i,'longitude']= str(fake.longitude())
    return data
   

input_data(10)

A saída fica excelente. Temos colunas de id, nome, endereço, latitude e longitude com dados únicos por usuário. 

Para reproduzir o resultado, precisamos fixar a semente (seed). Assim, sempre que executarmos o código novamente, teremos resultados semelhantes. 

Faker.seed(2)
input_data(10)

Exemplo 4

Também podemos gerar frases que contenham palavras-chave à nossa escolha. Semelhante a `text(), texts(), paragraph(), word() e words()`. Você pode aumentar o número de palavras em uma frase definindo o argumento nb_words.

No exemplo abaixo, geramos cinco frases usando uma lista de palavras. Não é perfeito, mas ajuda a testar aplicações que exigem muitos textos. 

word_list = ["DataCamp", "says", "great", "loves", "tutorial", "workplace"]

for i in range(0, 5):
    print(fake.sentence(ext_word_list=word_list))

Saída

Loves great says.
Says workplace workplace tutorial great loves.
Loves workplace workplace loves workplace loves great DataCamp.
Loves says workplace great.
Workplace great DataCamp.

Combinando dados sintéticos e reais

Nesta parte, vamos usar os dados de e-commerce do repositório de datasets da DataCamp e adicionar dados falsos de usuários usando as colunas CustomerID e Country. Isso ajuda a manter a privacidade e a testar o sistema com parâmetros adicionais. 

Para carregar o arquivo CSV, vamos usar a função `read_csv()` do pandas e exibir as cinco primeiras linhas com `head()`

# Loading CSV file
Ecommerce = pd.read_csv("e-commerce.csv")
Ecommerce.head()

O dataset tem as colunas InvoiceNo, StockCode (ID do produto), Description, Product (nome do item), Quantity (por transação), InvoiceDate, UnitPrice (em libras), CustomerID e Country. 

Para criar um objeto Faker localizado, vamos exibir os nomes de países únicos e usá-los para criar um dicionário. Como podemos ver, há sete países, e criaremos sete geradores localizados do Faker na sequência. 

Ecommerce.Country.dropna().unique()

>>> array(['United Kingdom', 'France', 'Australia', 'Netherlands', 'Germany',
      'Norway', 'EIRE'], dtype=object)

Na função `anonymous`, nós:

1. Extraímos os IDs de cliente únicos e removemos valores ausentes
2. Criamos um dicionário com nomes de países e seus códigos de locale
3. Extraímos o índice da linha e o país para cada cliente único
4. Usamos o dicionário e o país para inicializar o gerador localizado do Faker
5. Adicionamos nome, endereço e geolocalização do cliente ao dataframe existente. 

A função abaixo recebe o dataframe e adiciona quatro novas colunas com dados de usuário com base em CustomerID e Country. 

def anonymous(df):
   
    # Extracting unique CustomerID
    unique_id = df.CustomerID.dropna().unique()
   
    # Creating the dictionary for Faker localized providers
    local = {
        "United Kingdom": "en_GB",
        "France": "fr_FR",
        "Australia": "en_AU",
        "Netherlands": "nl_NL",
        "Germany": "de_DE",
        "Norway": "no_NO",
        "EIRE": "ga_IE",
    }

    for i in unique_id:
       
        # Extracting row index
        row_id = df[df["CustomerID"] == i].index
       
        # Extracting country name for faker locale
        CountryName = Ecommerce.loc[
            Ecommerce["CustomerID"] == i, "Country"
        ].to_numpy()[0]

        # Using locale dictionary to create faker locale generator
        code = local[CountryName]
        fake = Faker(code)

        # Generating fake data and adding it to dataframe
        CustomerName = fake.name()
        Address = fake.address()
        Latitude = str(fake.latitude())
        Longitude = str(fake.longitude())

        for x in row_id:
            df.loc[x, "CustomerName"] = CustomerName
            df.loc[x, "Address"] = Address
            df.loc[x, "Latitude"] = Latitude
            df.loc[x, "Longitude"] = Longitude

    return df

Vamos usar seed(5) para reprodutibilidade e rodar a função `anonymous` no dataframe Ecommerce. 

# Using seed for reproducibility
Faker.seed(5)

secure_db = anonymous(Ecommerce)
secure_db

Os primeiros resultados mostram os dados de 17850, United Kingdom, e Pamela Cox-James. 

Para visualizar os resultados localizados da função, precisamos ver os dados por país único na coluna Country. 

display_db = []
for i in Ecommerce.Country.dropna().unique():
    display_db.append(secure_db[secure_db["Country"] == i].to_numpy()[0])
pd.DataFrame(display_db, columns=Ecommerce.columns)

O resultado é animador. Você vê nomes diferentes por região e idioma. Os endereços batem com o país. Com esse método, você pode remover dados de identificação pessoal e criar dados localizados com o Faker para proteger a privacidade e economizar. 

O código-fonte está disponível neste workbook do DataLab.

Conclusão 

Uma das limitações do Python Faker é a qualidade modesta dos dados. Ele funciona bem para testes de aplicações, mas peca na precisão. Por exemplo, nomes nem sempre combinam com e-mail, domínio ou nome de usuário. 

Você pode personalizar o provider ou criar um novo do seu jeito, mas vai gastar tempo para deixar tudo redondo. Nesse meio-tempo, dá até para criar seu próprio pacote em Python usando `random.choice()`.

Em big techs, cientistas de dados usam várias ferramentas para processar informações sensíveis e manter a privacidade. Eles também usam dados sintéticos para melhorar o desempenho de modelos, reduzir vieses, testar aplicações e economizar no desenvolvimento de soluções avançadas de IA. 

Se quiser se aprofundar, confira a trilha de carreira Data Scientist with Python para começar sua jornada rumo a se tornar um cientista de dados confiante.

Neste tutorial, vimos a importância dos dados sintéticos e suas aplicações. Também geramos dados falsos do zero com o Python Faker para testar sistemas de dados e manter a privacidade dos usuários.