Globale Daten mit KI und UN Data Commons leichter erkundbar machen

Globale Daten mit KI und UN Data Commons einfacher erkundbar machen

Globale Statistiken haben eine seltsame Eigenschaft: Sie sind gleichzeitig reichlich vorhanden und schwer zu nutzen. Die Zahlen existieren – Bevölkerung, Emissionen, Handel, Gesundheit, Bildung –, aber sie liegen in Hunderten separater Portale, jedes mit eigenen Dateiformaten, eigenen Ländernamenskonventionen und eigener Vorstellung davon, was ein „Jahr“ bedeutet. Die Lücke zwischen Datenverfügbarkeit und Datennutzbarkeit ist der Punkt, an dem die meisten Analyseprojekte unbemerkt Wochen verlieren.

Ein Google-Blogbeitrag, der Arbeit mit der UN Data Commons-Plattform beschreibt, formuliert das Ziel direkt: globale Daten leichter erkundbar zu machen. Das ist das Thema dieses Artikels. Im Folgenden trenne ich, was die Quelle aussagt, von dem, was Interpretation ist, und konzentriere mich dann auf den Teil, der heute wirklich umsetzbar ist – die praktischen Werkzeuge, die Sie einrichten können, um heterogene internationale Daten mit KI-Unterstützung zu erkunden.

Was die Quelle aussagt und was nicht

Die verifizierte Primärquelle ist der Google AI Blog-Beitrag Making global data easier to explore, veröffentlicht unter https://blog.google/innovation-and-ai/technology/ai/google-un-data-commons-platform. Die zentrale verifizierte Aussage ist ein Ziel, keine Funktionsliste: Es geht darum, globale Daten im Kontext der UN-Datenarbeit leichter erkundbar zu machen.

Das ist eine bewusst enge Aussage, und sie verdient Respekt. Der Beitrag nennt – nach der hier verfügbaren Evidenz – keine Abfragesprachen, SDK-Namen, Endpunkte, Modellversionen, Preise oder Benchmark-Ergebnisse. Dieser Artikel wird sie daher nicht erfinden. Alles in den folgenden Abschnitten dazu, wie man mit globalen Daten arbeitet, ist allgemeine Engineering-Praxis für Open-Data-Arbeit, keine Beschreibung einer bestimmten Plattform-API.

Interpretation, klar gekennzeichnet: Wenn eine Institution einen Data Commons mit KI kombiniert, ist der plausible Nutzen nicht „die KI kennt die Antwort“. Er besteht darin, dass KI die Reibung zwischen einer menschlichen Frage und einer maschinenlesbaren Abfrage verringern kann – einen Ländernamen einem Code zuordnen, erraten, welche Spalte was bedeutet, und SQL gegen ein unbekanntes Schema entwerfen.

Warum sich globale Daten der Erkundung widersetzen

In fast jedem länderübergreifenden Projekt treten drei Hindernisse auf.

Identitäts-Nichtübereinstimmung. Dasselbe Land erscheint in verschiedenen Dateien als Kenya, KEN, KE, Republic of Kenya und 肯尼亚. Ein Join über Namen schlägt still fehl.

Schema-Drift. Eine Quelle speichert Spalten year und value; eine andere speichert eine Spalte pro Jahr. Eine meldet CO₂ in Kilotonnen, eine andere in Millionen Tonnen.

Metadaten-Distanz. Die Definition eines Indikators lebt in einer PDF, während die Zahlen in einer CSV leben. Nichts verbindet sie programmatisch.

KI löst diese Probleme nicht auf. Sie verkürzt die Schleife: Sie können den gewünschten Join in einfacher Sprache beschreiben und einen Entwurf erhalten, den Sie dann verifizieren. Die Verifizierung liegt weiterhin bei Ihnen.

Voraussetzungen

Bevor Sie irgendetwas installieren, stellen Sie sicher, dass Sie Folgendes haben:

• Python 3.10 oder neuer. Ältere Versionen brechen moderne Type Hints und mehrere Datenbibliotheken.
• Einen Paketmanager und ein Terminal. macOS, Linux oder WSL unter Windows.
• Etwa 2 GB Speicherplatz für eine virtuelle Umgebung und einen bescheidenen lokalen Datensatz.
• Optional: ein Google Cloud-Projekt, wenn Sie öffentliche Datensätze abfragen wollen, die in BigQuery gehostet werden.
• Optional: Zugang zu einer LLM-API, die Sie bereits nutzen, wenn Sie das Muster von natürlicher Sprache zu SQL ausprobieren möchten. Die folgenden Beispiele behandeln dies als konfigurierbaren Endpunkt, nicht als bestimmten Anbieter.
• Einen offenen Datensatz zum Üben. Jeder CSV- oder Parquet-Export eines nationalen Statistikamts oder einer internationalen Organisation funktioniert.

Sie brauchen keine GPU. Dies ist ein Workflow zum Abrufen, Harmonisieren und Abfragen, kein Trainings-Workflow.

Schritt-für-Schritt-Installation

1. Python-Version prüfen

Führen Sie dies aus, um zu bestätigen, dass der Interpreter neu genug ist.

python3 --version

Wenn eine Version unter 3.10 gemeldet wird, installieren Sie vor dem Fortfahren ein neueres Python über Ihren System-Paketmanager oder pyenv.

2. Isolierte virtuelle Umgebung erstellen

Wenn Sie Abhängigkeiten aus Ihrem System-Python heraushalten, vermeiden Sie später Versionskonflikte.

python3 -m venv ~/.venvs/globaldata
source ~/.venvs/globaldata/bin/activate

Unter Windows mit WSL lautet die Aktivierungszeile ebenfalls source ~/.venvs/globaldata/bin/activate; in PowerShell wäre es ~/.venvs/globaldata/Scripts/Activate.ps1.

3. Paketierungstoolchain aktualisieren

Frische Umgebungen enthalten oft ein veraltetes pip, was zu verwirrenden Resolver-Fehlern führt.

python -m pip install --upgrade pip setuptools wheel

4. Kerndatenbibliotheken installieren

Diese decken HTTP-Abruf, tabellarische Manipulation, lokale analytische Abfragen und Notebooks ab.

pip install pandas requests duckdb pyarrow python-dotenv jupyterlab

duckdb gibt Ihnen SQL über lokale CSV- und Parquet-Dateien, ohne einen Server zu betreiben – nützlich, wenn eine „Datenbank“ eigentlich nur ein Ordner voller Downloads ist.

5. Ländercode-Helfer installieren

Länderidentität ist die mit Abstand häufigste Ursache für fehlgeschlagene Joins; installieren Sie daher eine gepflegte Codetabelle.

pip install pycountry

6. Optional: Google Cloud CLI installieren

Tun Sie dies nur, wenn Sie Datensätze abfragen wollen, die in BigQuery gehostet werden.

brew install --cask google-cloud-sdk

Unter Debian oder Ubuntu verwenden Sie das offizielle apt-Repository anstelle von brew.

7. Optional: Bei Google Cloud authentifizieren

Dies öffnet ein Browserfenster und speichert die Standardanmeldedaten der Anwendung lokal.

gcloud auth application-default login

8. Optional: Projekt auswählen und API aktivieren

Legen Sie das Projekt fest, das für alle von Ihnen ausgeführten Abfragen abgerechnet werden soll.

gcloud config set project YOUR_PROJECT_ID
gcloud services enable bigquery.googleapis.com

9. Optional: Python-Client installieren

Dies ist die Bibliothek, mit der Skripte BigQuery direkt aufrufen können.

pip install google-cloud-bigquery db-dtypes

10. Umgebung verifizieren

Führen Sie dies aus, um zu bestätigen, dass die wesentlichen Importe aufgelöst werden.

python -c "import pandas, duckdb, pycountry, requests; print('environment ready')"

Konfiguration

Halten Sie Anmeldedaten und Endpunkte aus Ihren Quelldateien heraus.

1. Konfigurationsdatei erstellen

Dies schreibt eine private Env-Datei in Ihr Home-Verzeichnis. Ersetzen Sie jeden Platzhalter durch Ihre eigenen Werte.

cat > ~/.globaldata.env <<'EOF'
DATA_API_ENDPOINT=https://your-data-portal.example/api/v1
DATA_API_KEY=replace-with-your-key
MODEL_ENDPOINT=https://your-llm-provider.example/v1
MODEL_API_KEY=replace-with-your-model-key
MODEL_NAME=replace-with-your-model-id
GCP_PROJECT=your-project-id
EOF

2. Berechtigungen für die Datei einschränken

Anmeldedaten in einer weltweit lesbaren Datei sind ein häufiger und vermeidbarer Fehler.

chmod 600 ~/.globaldata.env

3. Konfiguration in Python laden

Dieses Snippet liest die Datei zur Laufzeit, ohne Secrets fest zu codieren.

import os
from dotenv import load_dotenv

load_dotenv(os.path.expanduser("~/.globaldata.env"))

DATA_API_ENDPOINT = os.environ["DATA_API_ENDPOINT"]
GCP_PROJECT = os.environ.get("GCP_PROJECT")

Der Platzhalter DATA_API_ENDPOINT ist bewusst gewählt. Jedes Portal, das Sie verwenden, hat seine eigene dokumentierte Basis-URL; die folgenden Muster sind unabhängig davon, welche das ist.

Anwendungsbeispiele

Beispiel 1: Länderidentifikatoren normalisieren

Dies sind die wirkungsvollsten zwanzig Zeilen Code in jeder länderübergreifenden Analyse.

import pycountry

ALIASES = {
    "Republic of Korea": "KOR",
    "Korea, Rep.": "KOR",
    "Viet Nam": "VNM",
    "Russian Federation": "RUS",
    "Côte d'Ivoire": "CIV",
}

def to_iso3(name: str) -> str | None:
    name = name.strip()
    if name in ALIASES:
        return ALIASES[name]
    try:
        return pycountry.countries.lookup(name).alpha_3
    except LookupError:
        return None

print(to_iso3("Kenya"), to_iso3("Korea, Rep."), to_iso3("Atlantis"))

Dass der letzte Aufruf None zurückgibt, ist der Punkt: nicht zugeordnete Werte sollten sichtbar sein, nicht stillschweigend verworfen werden. Protokollieren Sie sie und erweitern Sie ALIASES, anstatt zu raten.

Beispiel 2: Heterogene Dateien in eine abfragbare Tabelle laden

DuckDB kann CSV und Parquet direkt lesen und sie vereinigen, was einen Importschritt vermeidet.

import duckdb

con = duckdb.connect("globaldata.duckdb")

con.execute("""
    CREATE OR REPLACE TABLE observations AS
    SELECT
        indicator_code,
        UPPER(country_iso3) AS country_iso3,
        CAST(year AS INTEGER) AS year,
        CAST(value AS DOUBLE) AS value,
        source_file
    FROM read_csv_auto('downloads/*.csv', filename = true)
    WHERE value IS NOT NULL
""")

print(con.execute("""
    SELECT country_iso3, COUNT(*) AS rows
    FROM observations
    GROUP BY 1 ORDER BY 2 DESC LIMIT 10
""").fetchdf())

Die Option filename = true bewahrt die Herkunft, sodass jede Zeile bis zu der Datei zurückverfolgt werden kann, aus der sie stammt.

Beispiel 3: Eine Abfrage aus einer umgangssprachlichen Frage entwerfen

Dieses Muster sendet Ihr Schema plus eine Frage an ein Sprachmodell und bittet um SQL zurück. Es ist eine Entwurfshilfe, kein Orakel.

import os, requests

SYSTEM = """You translate questions into DuckDB SQL over this schema:

observations(indicator_code VARCHAR, country_iso3 VARCHAR, year INTEGER, value DOUBLE)

Rules:
- Return only the SQL statement.
- Use read-only SELECT statements.
- Never emit INSERT, UPDATE, DELETE, DROP, or ATTACH.
"""

def draft_sql(question: str) -> str:
    response = requests.post(
        f"{os.environ['MODEL_ENDPOINT']}/chat/completions",
        headers={"Authorization": f"Bearer {os.environ['MODEL_API_KEY']}"},
        json={
            "model": os.environ["MODEL_NAME"],
            "temperature": 0,
            "messages": [
                {"role": "system", "content": SYSTEM},
                {"role": "user", "content": question},
            ],
        },
        timeout=60,
    )
    response.raise_for_status()
    return response.json()["choices"][0]["message"]["content"].strip()

print(draft_sql("Which five countries had the highest value in 2020?"))

Beispiel 4: Den Entwurf gegen eine schreibgeschützte Verbindung ausführen

Die Datenbank schreibgeschützt zu öffnen, ist eine günstige, wirksame Schutzmaßnahme.

import duckdb

con = duckdb.connect("globaldata.duckdb", read_only=True)

sql = draft_sql("Which five countries had the highest value in 2020?")
print(sql)

if sql.upper().lstrip().startswith("SELECT"):
    print(con.execute(sql).fetchdf())
else:
    print("Refused: statement is not a SELECT.")

Die Prüfung startswith("SELECT") ist grob und kann durch einen hartnäckigen Prompt leicht umgangen werden. Betrachten Sie sie als Stolperdraht, nicht als Sicherheitsgrenze. Beschränken Sie in echten Deployments die Privilegien des Datenbankbenutzers auf Engine-Ebene.

Beispiel 5: Eine Indikatordefinition an ihre Zahlen anhängen

Metadaten machen eine Zahl interpretierbar. Halten Sie eine kleine Nachschlagetabelle neben den Daten vor.

con = duckdb.connect("globaldata.duckdb")

con.execute("""
    CREATE OR REPLACE TABLE indicators AS
    SELECT * FROM (VALUES
        ('EN.GHG.CO2.MT.CE.AR5', 'Carbon dioxide emissions', 'million tonnes'),
        ('SP.POP.TOTL',           'Total population',         'people')
    ) AS t(indicator_code, label, unit)
""")

print(con.execute("""
    SELECT i.label, i.unit, o.country_iso3, o.year, o.value
    FROM observations o
    JOIN indicators i USING (indicator_code)
    WHERE o.country_iso3 = 'KEN'
    ORDER BY o.year DESC
    LIMIT 5
""").fetchdf())

Jetzt kommt ein abgerufener Wert mit angehängter Einheit an, was eine ganze Klasse nachgelagerter Fehler verhindert.

Fallstricke und offene Grenzen

KI-Entwürfe sind keine Belege. Eine generierte SQL-Anweisung kann auf eine Spalte verweisen, die nicht existiert, oder auf einen Ländercode filtern, der nie in den Daten war. Führen Sie sie immer zuerst gegen einen kleinen Ausschnitt aus.

Sprachmodelle kennen Ihren Indikator nicht. Sie wissen, dass SP.POP.TOTL wie ein Weltbank-Code aussieht, aber sie können nicht bestätigen, was ein bestimmtes Portal damit meint. Die Definition muss vom Herausgeber kommen.

Bereitstellung ist unsichtbar, bis sie es nicht mehr ist. Die Installationsschritte dieses Artikels beschreiben allgemeine Open-Data-Werkzeuge. Jede spezifische Plattform, die rund um die UN-Data-Commons-Bemühung gebaut wird, hat ihr eigenes Onboarding, eigene Bedingungen und eigene Ratenlimits, die die verfügbare Quelle nicht beschreibt. Lesen Sie diese Dokumente, bevor Sie Abhängigkeiten davon aufbauen.

Harmonisierung ist nie abgeschlossen. Neue Ländernamen, neue Indikatorrevisionen und neue Datenstände erscheinen ständig. Planen Sie eine Wartungsschleife ein, keine einmalige Bereinigung.

Aggregation verbirgt Uneinigkeit. Wenn zwei Agenturen unterschiedliche Werte für denselben Indikator melden, produziert ein Join bereitwillig beide. Entscheiden Sie ausdrücklich, ob Sie eine Quelle bevorzugen, sie mitteln oder die Uneinigkeit sichtbar machen.

Fazit

Das Versprechen von KI in der Arbeit mit globalen Daten ist enger und nützlicher, als es zunächst klingt. Es geht nicht darum, dass das Modell die Statistiken kennt. Es geht darum, dass das Modell zwischen einer menschlichen Frage und einer fragmentierten Speicherschicht sitzen, den Join entwerfen, die Codezuordnung vorschlagen und die Zeit von „Ich frage mich“ zu „Hier ist eine Abfrage, die ich prüfen kann“ verkürzen kann.

Die UN-Data-Commons-Bemühung, wie in der Quelle beschrieben, zielt genau auf diese Reibung: globale Daten leichter erkundbar zu machen. Die praktische Antwort besteht darin, eine kleine, reproduzierbare Umgebung rund um die Daten aufzubauen, die Sie bereits haben – eine virtuelle Umgebung, DuckDB für lokales SQL, pycountry für Identität und einen konfigurierbaren Modellendpunkt zum Entwerfen. Drei Regeln halten es ehrlich: Identifikatoren statt Namen normalisieren, Metadaten neben den Zahlen behalten und niemals eine generierte Abfrage ausführen, die Sie nicht gelesen haben.

Beginnen Sie mit einem Datensatz und einer Frage. Die Werkzeuge brauchen einen Nachmittag; die Gewohnheit, zu verifizieren, was das Modell produziert hat, macht die Ergebnisse vertrauenswürdig.