Synthetische Daten mit Python Faker erstellen: Tutorial

Was sind synthetische Daten?

Synthetische Daten sind computergenerierte Daten, die realen Daten ähneln. Ihr Hauptzweck ist es, die Privatsphäre und Integrität von Systemen zu erhöhen. Unternehmen müssen beispielsweise Strategien zum Datenschutz umsetzen, um die personenbezogenen Daten (PII) oder Gesundheitsdaten (PHI) ihrer Nutzer zu schützen. Mit synthetischen Daten lassen sich neue Anwendungen testen und gleichzeitig die Privatsphäre der Nutzer wahren. 

Im Machine-Learning-Umfeld setzen wir synthetische Daten ein, um die Modellleistung zu verbessern. Das gilt auch, wenn Daten knapp oder unausgewogen sind. Typische Einsatzfelder für synthetische Daten im Machine Learning sind autonomes Fahren, Sicherheit, Robotik, Betrugserkennung und das Gesundheitswesen. 

Bildquelle: Nvidia

Laut Gartner werden bis 2024 sechzig Prozent der Daten, die für die Entwicklung von KI- und Analytics-Anwendungen genutzt werden, synthetisch erzeugt. Warum nimmt die Nutzung synthetischer Daten so stark zu? 

Die Erhebung und Bereinigung realer Daten ist teuer und in manchen Fällen selten. Beispielsweise sind Daten zu Bankbetrug, Brustkrebs, autonomem Fahren oder Malware-Angriffen in der realen Welt schwer zu bekommen. Selbst wenn du an die Daten kommst, kostet es Zeit und Ressourcen, sie für Machine-Learning-Aufgaben zu bereinigen und aufzubereiten. 

Im ersten Teil des Tutorials erfährst du, warum wir synthetische Daten brauchen, wofür sie eingesetzt werden und wie man sie erzeugt. Im zweiten Teil sehen wir uns die Python-Bibliothek Faker an und nutzen sie, um synthetische Daten zu erstellen, mit denen wir Anwendungen testen und die Privatsphäre der Nutzer bewahren. 

Warum sollten wir synthetische Daten erzeugen?

Bild von der Autorin/dem Autor

Wir brauchen synthetische Daten für Datenschutz, Anwendungstests, bessere Modellleistung, die Abbildung seltener Fälle und zur Senkung der Betriebskosten.

• Privatsphäre: Zum Schutz der Nutzerdaten. Namen, E-Mails und Adressen lassen sich durch synthetische Daten ersetzen. So vermeiden wir Cyber- und Blackbox-Angriffe, bei denen Modelle Details aus Trainingsdaten rekonstruieren.
• Tests: Das Testen von Anwendungen mit Echtdaten ist teuer. Datenbank-, UI- und KI-Tests mit synthetischen Daten sind kostengünstiger und sicherer.
• Modellleistung: Generierte synthetische Daten können die Leistung verbessern. Beispiel: Bei Bildklassifikatoren vergrößern wir mit Shearing, Shifting und Rotating den Datensatz und steigern die Genauigkeit. 
• Seltene Fälle: Auf seltene Ereignisse zu warten, um Echtdaten zu sammeln, ist keine Option. Beispiele: Kreditkartenbetrug, Autounfälle, Krebsdaten. 
• Kosten: Datenerhebung braucht Zeit und Ressourcen. Echtdaten zu beschaffen, zu bereinigen, zu labeln und für Tests oder Training aufzubereiten, ist teuer. 

Wo werden synthetische Daten eingesetzt?

In diesem Abschnitt siehst du, wie Unternehmen mit synthetischen Daten kosteneffiziente, datenschutzfreundliche und performante Anwendungen entwickeln. 

1. Datenaustausch: Synthetische Daten ermöglichen es, sensible Daten intern und mit Dritten zu teilen. Sie helfen auch, private Daten in die Cloud zu verlagern und für Analysen bereitzuhalten.
2. Finanzdienstleistungen: Synthetische Daten werden erzeugt, um seltene Ereignisse wie betrügerische Transaktionen, Anomalien oder Rezessionen nachzubilden. Außerdem lassen sich damit Kundenverhalten mit Analysetools besser verstehen. 
3. Quality Assurance: Qualität von Anwendungen und Datensystemen prüfen und sicherstellen. Synthetische Daten werden genutzt, um Systeme mit seltenen Anomalien zu testen und die Performance zu erhöhen.
4. Gesundheitswesen: Medizinische Daten intern und extern teilen, ohne die Vertraulichkeit der Patienten zu verletzen. Außerdem einsetzbar für klinische Studien und das Erkennen seltener Krankheiten. Lerne den Umgang mit sensiblen Informationen in unseren Kursen zu Datenprivatsphäre und Anonymisierung mit Python oder R. 
5. Automotive: Für Roboter, Drohnen und autonome Fahrzeuge sind Echtdaten schwer und langsam zu beschaffen. Unternehmen testen und trainieren ihre Systeme mit synthetischen Simulationsdaten und sparen Kosten, ohne bei der Performance Abstriche zu machen. 
6. Machine Learning: Synthetische Daten vergrößern Trainingsdatensätze, beheben Klassenungleichgewichte und helfen, Modelle auf Leistung und Genauigkeit zu testen. Ebenso dienen sie dazu, Verzerrungen in bestehenden Bild- und Textdaten zu reduzieren. So testen wir Systeme und schützen die Privatsphäre. Beispiel: DeepFake wird eingesetzt, um Gesichtserkennungssysteme zu testen. 

Wie erzeugt man synthetische Daten?

Dazu können wir Fake-Datageneratoren, Statistik-Tools, neuronale Netze und Generative Adversarial Networks nutzen.  

Gefälschte Datenbanken erzeugen mit der Faker-Bibliothek, um Datenbanken und Systeme zu testen. Sie kann Fake-Profile mit Adressen und allen wichtigen Infos generieren. Auch zufälliger Text und Absätze sind möglich. Das hilft, in Testphasen die Privatsphäre zu schützen und Kosten für Echtdaten zu sparen. 

Datenverteilungen verstehen, um mit statistischen Verteilungen wie Gauß, Exponential, Chi-Quadrat, t, Lognormal und Uniform einen komplett neuen Datensatz zu erzeugen. Dafür brauchst du Fachwissen, um verteilungsbasierte synthetische Daten sinnvoll zu erstellen. 

Variational Autoencoder ist ein unüberwachtes Verfahren mit Encoder und Decoder, das den Originaldatensatz komprimiert und eine Repräsentation davon erzeugt. Ziel ist es, die Korrelation zwischen Eingabe- und Ausgabedaten zu optimieren. 

Generative Adversarial Networks sind der populärste Ansatz. Damit lassen sich synthetische Bilder, Audio, Tabellendaten und Simulationsdaten erzeugen. Ein Generator und ein Diskriminator vergleichen Zufallsproben mit Echtdaten und erzeugen so synthetische Daten. Lies unser Tutorial Demystifying Generative Adversarial Nets, um mit Keras eigene synthetische Daten zu erstellen.  

Was ist Python Faker?

Python Faker ist ein Open-Source-Paket, mit dem du Fake-Datensätze für Anwendungstests erzeugst, Datenbanken befüllst und die Anonymität von Nutzern sicherst.

Bild von der Autorin/dem Autor

Du installierst Faker mit:

pip install faker

Faker bietet eine CLI, Pytest-Fixtures, Lokalisierung (Unterstützung verschiedener Regionen), Reproduzierbarkeit und Dynamic Provider (für individuelle Anpassungen).

Mit den Basisfunktionen von Faker kannst du schnell einen Datensatz bauen und ihn dann passgenau erweitern. In der Tabelle unten findest du wichtige Faker-Funktionen und wofür sie gut sind. 

Mehr zu fortgeschrittenen Funktionen findest du in der Faker-Dokumentation.

Es lohnt sich, diese Funktionen im Blick zu haben – wir nutzen sie gleich, um Beispiele und DataFrames zu erstellen. 

Synthetische Daten mit Python Faker erzeugen

In diesem Abschnitt generieren wir mit Python Faker synthetische Daten. Du siehst 5 Beispiele, wie du Faker für verschiedene Aufgaben einsetzen kannst. Ziel ist ein privacy-first Ansatz für Systemtests. Im letzten Teil erzeugen wir Fake-Daten, die mit Hilfe lokalisierter Provider echte Daten ergänzen. 

Den gesamten Code findest du in diesem DataLab-Notebook. Du kannst dir einfach eine Kopie anlegen und alles direkt im Browser ausführen – ganz ohne Installation.

Zunächst initialisieren wir einen Generator mit `Faker()`. Standardmäßig ist die Locale “en_US” aktiv. 

from faker import Faker
fake = Faker()

Beispiel 1

Das Objekt “fake” erzeugt Daten über Attributnamen. So generiert `fake.name()` etwa einen vollständigen zufälligen Personennamen.

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

Ähnlich lassen sich E-Mail-Adresse, Ländername, Text, Geokoordinaten und URL erzeugen.  

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

Ausgabe

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/

Beispiel 2

Mit verschiedenen Locales erzeugst du Daten in unterschiedlichen Sprachen und für bestimmte Regionen. 

Im folgenden Beispiel generieren wir Daten auf Spanisch und für Spanien.

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

Ausgabe

Wie zu sehen, ändert sich der Name, und der Text ist auf Spanisch.

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/

Probieren wir es mit Deutsch und Deutschland. Für ein vollständiges Nutzerprofil verwenden wir die Funktion `profile()`.

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

Ausgabe

Es ist klar erkennbar, wie sich mit Faker Daten für verschiedene Sprachen und Länder generieren lassen. Die Locale beeinflusst Name, Beruf, Adresse, Firma und weitere Identifikationsdaten entsprechend Sprache und Land.  

{'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)}

Beispiel 3

In diesem Beispiel erstellen wir mit Faker einen pandas-DataFrame.

1. Leeren pandas-DataFrame (data) erstellen
2. Mehrere Zeilen per Schleife erzeugen
3. Mit `randint()` eine eindeutige ID erzeugen
4. Mit Faker Name, Adresse und Geodaten hinzufügen
5. Funktion `input_data()` mit x=10 ausführen

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)

Die Ausgabe kann sich sehen lassen: Wir bekommen Spalten für id, name, address, latitude und longitude mit eindeutigen Nutzerdaten. 

Für reproduzierbare Ergebnisse setzen wir den Seed. So erhältst du beim erneuten Ausführen ähnliche Resultate. 

Faker.seed(2)
input_data(10)

Beispiel 4

Wir können auch Sätze erzeugen, die bestimmte Schlüsselwörter enthalten – ähnlich zu `text(), texts(), paragraph(), word(), words()`. Über das Argument nb_words erhöhst du die Wortanzahl.

Im Beispiel unten generieren wir fünf Sätze aus einer Wortliste. Nicht perfekt, aber ideal, um Anwendungen zu testen, die viel Text brauchen. 

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

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

Ausgabe

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

Synthetische und echte Daten kombinieren

In diesem Teil nutzen wir E-Commerce-Daten aus dem DataCamp-Datenrepository und ergänzen sie um Fake-Nutzerdaten anhand der Spalten CustomerID und Country. So schützen wir die Privatsphäre und testen zusätzliche Parameter. 

Zum Laden der CSV nutzen wir die pandas-Funktion `read_csv()` und zeigen mit `head()` die ersten fünf Zeilen.

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

Der Datensatz enthält InvoiceNo, StockCode (Produkt-ID), Description (Produktname), Quantity (pro Transaktion), InvoiceDate, UnitPrice (in Pfund), CustomerID und Country. 

Um einen lokalisierten Faker zu erstellen, listen wir die eindeutigen Ländernamen auf und nutzen sie für ein Dictionary. Wie zu sehen, gibt es sieben Länder – im nächsten Schritt erzeugen wir sieben lokalisierte Faker-Generatoren. 

Ecommerce.Country.dropna().unique()

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

Die Funktion `anonymous` macht Folgendes:

1. Eindeutige CustomerIDs extrahieren und fehlende Werte entfernen
2. Dictionary mit Ländernamen und Locale-Kürzeln erstellen
3. Für jede eindeutige CustomerID Zeilenindex und Land bestimmen
4. Mit Dictionary und Länderkürzel einen lokalisierten Faker erzeugen
5. Name, Adresse und Geodaten zur bestehenden Tabelle hinzufügen. 

Die Funktion unten nimmt den DataFrame und ergänzt vier neue Spalten mit Nutzerdaten basierend auf CustomerID und 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

Für Reproduzierbarkeit setzen wir seed(5) und führen `anonymous` auf dem Ecommerce-DataFrame aus. 

# Using seed for reproducibility
Faker.seed(5)

secure_db = anonymous(Ecommerce)
secure_db

Die ersten Zeilen zeigen Daten zu 17850, United Kingdom und Pamela Cox-James. 

Um die lokalisierten Ergebnisse zu visualisieren, betrachten wir je ein Beispiel pro Land. 

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)

Das Ergebnis ist überzeugend: Du siehst je Region und Sprache unterschiedliche Namen, und die Adressen passen zum Land. So kannst du personenbezogene Daten entfernen und mit Faker lokalisierte Daten erzeugen, um Privatsphäre zu schützen und Kosten zu sparen. 

Den Code findest du in diesem DataLab-Notebook.

Fazit 

Ein Nachteil von Python Faker ist die mitunter geringe Datenqualität. Für Anwendungstests reicht es, doch an manchen Stellen fehlt die Stimmigkeit. Beispielsweise passen Namen nicht immer zu E-Mail, Domain oder Username. 

Du kannst Provider anpassen oder eigene erstellen. Das kostet aber Zeit, die du alternativ in ein eigenes Python-Paket mit `random.choice()` investieren könntest.

In Big Tech nutzen Data Scientists verschiedene Tools, um sensible Daten zu verarbeiten und die Privatsphäre zu wahren. Außerdem verwenden sie synthetische Daten, um Modelle zu verbessern, Bias zu reduzieren, Anwendungen zu testen und Kosten bei der Entwicklung moderner KI-Lösungen zu senken. 

Wenn du tiefer einsteigen willst, schau dir den Career Track Data Scientist with Python an und starte deine Reise zur gefragten Data-Scientist-Karriere.

In diesem Tutorial hast du die Bedeutung synthetischer Daten und ihre Anwendungsfälle kennengelernt. Außerdem haben wir mit Python Faker von Grund auf Fake-Daten erzeugt, um Datensysteme zu testen und die Privatsphäre der Nutzer zu schützen.