Begeben Sie sich mit KI-Tools auf eine interaktive Reise durch Amerikas Nationalparks

Machen Sie eine interaktive Reise durch Amerikas Nationalparks mit KI-Tools

Amerikas Nationalparks haben schon immer Staunen hervorgerufen, aber nicht jeder kann spontan einen Campingkocher packen und nach Yosemite oder Acadia aufbrechen. Im August 2026 startete Google Arts & Culture ein bemerkenswertes Projekt namens United Parks of America, das Menschen auf der ganzen Welt ermöglicht, diese geschützten Landschaften zu erkunden. Die Initiative ist ein hervorragendes Beispiel dafür, wie KI einen statischen Bildschirm in eine reichhaltige, interaktive Umgebung verwandeln kann – Besucher können durch Wege „laufen“, in geologische Details hineinzoomen und die Geschichten hinter den Denkmälern hören.

Aber man muss nicht auf einen Tech-Giganten warten, um ein solches Erlebnis zu schaffen. Mit ein paar Open-Source-Tools und öffentlichen Datensätzen können Sie Ihre eigene interaktive Reise durch Amerikas Nationalparks erstellen. Dieser Artikel führt durch ein praktisches, praxisnahes Projekt: eine Kommandozeilen- und Web-App, die Parkdaten abruft, beschreibenden Text generiert und sogar KI-gestützte Bildunterschriften erzeugt. Es ist ein perfektes Wochenendprojekt für Entwickler, die ihre Liebe zur Natur mit etwas maschinellem Lernen verbinden möchten.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass auf Ihrem Rechner Folgendes vorhanden ist:

• Python 3.9 oder höher – wir verwenden moderne Sprachfunktionen und aktuelle Bibliotheksversionen.
• pip – der standardmäßige Python-Paketinstaller, normalerweise in Python enthalten.
• Eine stabile Internetverbindung – wir müssen Datensätze und vortrainierte Modelle herunterladen.
• Ein National Park Service (NPS) API-Schlüssel – kostenlos erhältlich unter developer.nps.gov. Dieser öffentliche Webservice bietet offizielle Informationen zu allen Nationalparks, einschließlich Beschreibungen, Aktivitäten und Koordinaten.
• Eine GPU (optional, aber empfohlen) – wenn Sie ein Vision-Language-Modell lokal ausführen möchten, beschleunigt eine GPU die Inferenz. Für kleine Beispiele funktioniert die CPU-Ausführung jedoch auch.

Kenntnisse in Frontend-Entwicklung sind nicht erforderlich; wir verwenden Gradio, eine Python-Bibliothek, die ein paar Zeilen Code in eine teilbare Webschnittstelle verwandelt.

Schritt-für-Schritt-Installation

Richten Sie zuerst eine saubere Python-Umgebung ein, um Abhängigkeitskonflikte mit anderen Projekten zu vermeiden. Öffnen Sie Ihr Terminal und erstellen Sie eine virtuelle Umgebung.

python -m venv nps-env

Aktivieren Sie sie. Unter macOS und Linux:

source nps-env/bin/activate

Unter Windows ist der Befehl etwas anders:

nps-env\Scripts\activate

Aktualisieren Sie nun pip auf die neueste Version und installieren Sie die benötigten Bibliotheken.

pip install --upgrade pip
pip install requests pandas pillow torch transformers gradio

Das macht jede Bibliothek:

• requests – führt HTTP-Aufrufe an die NPS-API durch.
• pandas – organisiert die zurückgegebenen JSON-Daten in Tabellen.
• pillow – verarbeitet Bilder.
• torch – PyTorch, die Engine hinter vielen KI-Modellen.
• transformers – Hugging Faces Bibliothek zum Laden vortrainierter Sprach- und Bildmodelle.
• gradio – erstellt eine Webschnittstelle für unser Werkzeug.

Überprüfen Sie nach der Installation, ob alles funktioniert, indem Sie die Versionen ausgeben.

python -c "import torch; print(torch.__version__); import gradio; print(gradio.__version__)"

Erstellen Sie nun einen Projektordner und ein Python-Skript. Nennen wir es nps_journey.py.

mkdir nps-journey
cd nps-journey

Nationalparkdaten abrufen

Der National Park Service bietet eine gut dokumentierte API. Für den Zugriff benötigen Sie einen API-Schlüssel. Sobald Sie ihn haben, speichern Sie ihn aus Sicherheitsgründen in einer Umgebungsvariable.

export NPS_API_KEY="ihr-api-schluessel-hier"

Jetzt schreiben wir ein Skript, das eine Liste der Parks anfordert und ihre Namen anzeigt. Öffnen Sie nps_journey.py in einem Texteditor und fügen Sie Folgendes hinzu:

import os
import requests
import pandas as pd

API_KEY = os.getenv("NPS_API_KEY")
BASE_URL = "https://developer.nps.gov/api/v1/parks"

def fetch_park_data(limit=50):
    headers = {"X-Api-Key": API_KEY}
    params = {"limit": limit, "fields": "images,activities"}
    response = requests.get(BASE_URL, headers=headers, params=params)
    response.raise_for_status()
    data = response.json()
    return pd.DataFrame(data["data"])

parks_df = fetch_park_data()
print(parks_df[["name", "states"]].head())

Führen Sie das Skript aus, um eine Liste der Nationalparks und der Bundesstaaten, in denen sie liegen, zu sehen.

python nps_journey.py

Sie erhalten eine Tabelle mit mindestens den ersten 50 Parks. Wir haben nun das Rohmaterial für unsere interaktive Reise.

Die interaktive Shell bauen

Ein einfaches Kommandozeilenmenü ist ein guter Anfang. Wir können den Benutzer bitten, einen Park auszuwählen, und dann dessen Beschreibung, Aktivitäten und Öffnungszeiten anzeigen. Erweitern wir unser Skript:

def get_park_details(park_code):
    headers = {"X-Api-Key": API_KEY}
    params = {"parkCode": park_code}
    response = requests.get(BASE_URL, headers=headers, params=params)
    response.raise_for_status()
    data = response.json()["data"]
    if not data:
        return None
    return data[0]

def interactive_cli():
    while True:
        print("\nVerfügbare Parks (erste 10):")
        sample = parks_df.head(10)[["parkCode", "name"]].to_string(index=False)
        print(sample)
        code = input("Geben Sie einen Parkcode ein (oder 'q' zum Beenden): ").strip().lower()
        if code == "q":
            break
        park = get_park_details(code)
        if park is None:
            print("Park nicht gefunden. Versuchen Sie es erneut.")
            continue
        print(f"\n{park['name']}")
        print(park.get("description", "Keine Beschreibung verfügbar."))
        print("\nAktivitäten:", ", ".join(
            [a["name"] for a in park.get("activities", [])]
        ))
        print("\nWetterinfo:", park.get("weatherInfo", "Nicht verfügbar."))

if __name__ == "__main__":
    interactive_cli()

Jetzt können wir die Parks direkt vom Terminal aus durchstöbern. Aber um dies wirklich interaktiv und visuell zu machen, nutzen wir eine Webschnittstelle.

Anwendungsbeispiele

Beispiel 1: Ein Gradio-Dashboard zur Parkerkundung

Gradio ist der schnellste Weg, Ihr Python-Skript in eine teilbare Web-App zu verwandeln. Wir erstellen eine Funktion, die einen Parkcode entgegennimmt und eine strukturierte Ansicht der wichtigsten Parkinformationen zurückgibt.

import gradio as gr

def display_park(park_code):
    park = get_park_details(park_code)
    if park is None:
        return "Park nicht gefunden", None
    if park.get("images"):
        img_url = park["images"][0]["url"]
    else:
        img_url = None
    description = park.get("description", "")
    activities = ", ".join([a["name"] for a in park.get("activities", [])])
    info = f"**Park:** {park['name']}\n\n{description}\n\n**Aktivitäten:** {activities}"
    return info, img_url

Dann starten wir die App:

demo = gr.Interface(
    fn=display_park,
    inputs="text",
    outputs=["markdown", gr.Image(type="filepath")],
    title="Interaktiver Nationalpark-Explorer",
    description="Geben Sie einen Parkcode ein (z. B. YOSE für Yosemite) und erkunden Sie."
)
demo.launch()

Führen Sie das Skript aus und öffnen Sie die lokale URL in Ihrem Browser. Sie haben gerade einen webbasierten interaktiven Explorer gebaut, der offizielle NPS-Informationen und Bilder liefert. Das ist eine solide Grundlage für eine „Reise“.

Beispiel 2: KI-gestützte Bildunterschriften

Jetzt kommt die KI-Kante. Das Projekt von Google Arts & Culture deutet die Leistungsfähigkeit generativer KI an: Sie kann Sie durch mehrere Sinne in eine Landschaft einladen. Wir können dieses Gefühl mit einem vortrainierten Vision-Language-Modell nachahmen, das jedes Bild beschreibt, das Sie ihm geben.

Die transformers-Bibliothek von Hugging Face enthält Modelle wie BLIP (Bootstrapping Language-Image Pre-training). So laden Sie es und erhalten eine Beschreibung eines Parkfotos.

from transformers import pipeline

def load_captioner():
    return pipeline("image-to-text", model="Salesforce/blip-image-captioning-large")

captioner = load_captioner()

def caption_image(image_path):
    result = captioner(image_path)[0]["generated_text"]
    return result

Kombinieren wir das mit dem Park-Explorer. Wenn ein Benutzer einen Park auswählt, nehmen wir das erste Bild von der NPS-API, speichern es in einer temporären Datei und generieren mit BLIP eine poetische Bildunterschrift.

import tempfile
import requests
from PIL import Image

def download_image(url, save_path):
    response = requests.get(url, stream=True)
    response.raise_for_status()
    with open(save_path, "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)

def display_park_with_caption(park_code):
    park = get_park_details(park_code)
    if park is None or not park.get("images"):
        return "Park oder Bild nicht gefunden", None
    img_url = park["images"][0]["url"]
    temp_path = tempfile.NamedTemporaryFile(suffix=".jpg", delete=False).name
    download_image(img_url, temp_path)
    caption = caption_image(temp_path)
    info = f"**{park['name']}**\n\n{caption}\n\nBeschreibung: {park.get('description', '')}"
    return info, temp_path

Starten Sie nun eine neue Gradio-Oberfläche:

demo2 = gr.Interface(
    fn=display_park_with_caption,
    inputs="text",
    outputs=["markdown", gr.Image(type="filepath")],
    title="KI-gestützte Nationalpark-Reise",
    description="Geben Sie einen Parkcode ein und lassen Sie die KI die Aussicht interpretieren."
)
demo2.launch()

Das ist ein kleiner Vorgeschmack auf die interaktiven Reisen, die im Google-Arts-&-Culture-Projekt erwähnt werden. Statt nur Fakten zu lesen, erhält der Benutzer eine KI-generierte Interpretation dessen, wie der Ort aussieht. Sie können die Idee sogar erweitern – ein kurzes Gedicht generieren, eine Reiseroute basierend auf den Aktivitäten des Parks erstellen oder Besucherbewertungen zusammenfassen.

Beispiel 3: Ein Routenplaner mit Parkkoordinaten

Die meisten NPS-Datensätze enthalten latitude und longitude. Damit können wir eine kartenbasierte Reise aufbauen. Der Einfachheit halber zeigen wir die Koordinaten an und berechnen Entfernungen zwischen zwei Parks. Das ist eine praktische Funktion für Menschen, die einen Multi-Park-Roadtrip planen möchten.

from math import radians, sin, cos, sqrt, atan2

def haversine(lat1, lon1, lat2, lon2):
    R = 6371
    dlat = radians(lat2 - lat1)
    dlon = radians(lon2 - lon1)
    a = sin(dlat / 2) ** 2 + cos(radians(lat1)) * cos(radians(lat2)) * sin(dlon / 2) ** 2
    return 2 * R * atan2(sqrt(a), sqrt(1 - a))

def distance_between_parks(code1, code2):
    park1 = get_park_details(code1)
    park2 = get_park_details(code2)
    if not park1 or not park2:
        return "Ungültiger Parkcode."
    lat1, lon1 = park1["latitude"], park1["longitude"]
    lat2, lon2 = park2["latitude"], park2["longitude"]
    dist = haversine(float(lat1), float(lon1), float(lat2), float(lon2))
    return f"Entfernung von {park1['name']} zu {park2['name']}: {dist:.0f} km"

Fügen Sie die Funktion zur bestehenden Gradio-App hinzu, und Besucher können die Geografie hinter dem Erlebnis erkunden. Es ist ein sofort einsetzbares „Wohin geht es als Nächstes“-Werkzeug.

Beispiel 4: Eine personalisierte Reiseroute generieren

Die NPS-API liefert auch eine Liste der Aktivitäten, aber wir können noch einen Schritt weiter gehen und ein Sprachmodell verwenden, um eine Eintagesroute basierend auf diesen Aktivitäten zu erstellen. Zum Beispiel können wir ein leichtgewichtiges Textgenerierungsmodell von Hugging Face wie distilgpt2 verwenden, um einen Absatz zu schreiben, der eine Wanderung durch den Park beschreibt. Das ist keine vollständig verlässliche faktenbasierte Reiseroute, aber es verleiht einen kreativen, immersiven Charakter.

from transformers import pipeline

def generate_itinerary(park_code):
    park = get_park_details(park_code)
    if not park:
        return "Park nicht gefunden."
    activities = [a["name"] for a in park.get("activities", [])]
    prompt = (
        f"Stellen Sie sich einen Tag im {park['name']} vor. "
        f"Er bietet: {', '.join(activities[:5])}. "
        f"Schreiben Sie eine kurze Reiseroute in zwei Sätzen."
    )
    text_gen = pipeline("text-generation", model="distilgpt2")
    result = text_gen(prompt, max_new_tokens=80, num_return_sequences=1)[0]["generated_text"]
    return result

Kombinieren Sie das mit den vorherigen Funktionen, und Sie haben eine vollständig interaktive Reise mit drei Ebenen der KI-Unterstützung: faktenbasierte Daten, visuelle Beschreibung und kreative Erzählung. Das spiegelt den Geist des United Parks of America-Projekts wider: die Parks auch aus der Ferne lebendig zu machen.

Alles zusammenfügen

Kombinieren wir alles in einer einzigen Gradio-App mit Tabs, sodass Sie zwischen dem klassischen Explorer, dem Bildunterschriften-Generator, dem Entfernungsrechner und dem KI-Reiserouten-Autor wechseln können.

with gr.Blocks() as full_app:
    gr.Markdown("# 🏞 Machen Sie eine KI-Reise durch Amerikas Nationalparks")
    with gr.Tab("Erkunden"):
        code_input = gr.Textbox(label="Parkcode")
        out_text = gr.Markdown()
        out_img = gr.Image(type="filepath")
        explore_btn = gr.Button("Los")
        explore_btn.click(fn=display_park_with_caption, inputs=code_input, outputs=[out_text, out_img])
    with gr.Tab("Entfernung"):
        code1 = gr.Textbox(label="Parkcode 1")
        code2 = gr.Textbox(label="Parkcode 2")
        dist_out = gr.Markdown()
        dist_btn = gr.Button("Berechnen")
        dist_btn.click(fn=distance_between_parks, inputs=[code1, code2], outputs=dist_out)
    with gr.Tab("Reiseroute"):
        code_it = gr.Textbox(label="Parkcode")
        it_out = gr.Markdown()
        it_btn = gr.Button("Generieren")
        it_btn.click(fn=generate_itinerary, inputs=code_it, outputs=it_out)
full_app.launch()

Führen Sie das Skript erneut aus und Sie haben ein lokales interaktives Portal. Teilen Sie die lokale URL mit Freunden oder stellen Sie es auf einem kostenlosen Dienst wie Hugging Face Spaces bereit (denken Sie daran, Ihren NPS-API-Schlüssel dort als Geheimnis zu setzen).

Hinweise und Einschränkungen

Die Werkzeuge, die wir gebaut haben, sind lehrreich, aber nicht produktionsreif. Ein paar Dinge sollten Sie beachten:

• Das NPS-API-Ratenlimit beträgt 50 Anfragen pro Sekunde, was großzügig ist, aber übertreiben Sie es nicht.
• Das BLIP-Modell wurde mit allgemeinen Bildern trainiert, daher können seine Bildunterschriften für bestimmte Parkwahrzeichen zu allgemein sein. Sie können es feinabstimmen, aber das erfordert zusätzliche Daten.
• distilgpt2 ist ein kleines Sprachmodell; seine Reiseroute wird kreativ, aber nicht realistisch sein. Ein größeres Modell wie Llama 3 würde bessere Ergebnisse liefern, aber Sie bräuchten mehr Speicher und eine geeignete Hosting-Umgebung.
• Das Papier des United Parks of America-Projekts zeigt, was mit erheblicher Ingenieursarbeit im Hintergrund möglich ist – Ihre DIY-Version ist ein unterhaltsamer Ausgangspunkt, kein vollwertiger Ersatz.

Fazit

Die United Parks of America-Initiative von Google Arts & Culture, gestartet im August 2026, ist eine wunderschöne Demonstration dafür, wie KI die Natur auf jeden Bildschirm bringen kann. Aber dieselben zugrunde liegenden Konzepte – Verarbeitung natürlicher Sprache, Vision-Language-Modelle und offene Daten – sind für Hobbyisten und Entwickler zugänglich. Mit weniger als 150 Zeilen Python haben Sie nun eine interaktive Reise durch Amerikas Nationalparks gebaut, mit der Sie erkunden, beschreiben, planen und sich etwas vorstellen können.

Dieses Projekt ist nur der Anfang des Weges. Fügen Sie Funktionen wie Wettervorhersage, Audio-Erzählung mit einem Text-to-Speech-Modell oder sogar einen Chatbot hinzu, der mit Park-FAQs trainiert wurde. Der Schlüssel ist, weiter zu erkunden – so wie Sie einen neuen Wanderweg begehen würden. KI bringt Sie bis zur Hälfte; Neugierde erledigt den Rest.