Faites un voyage interactif à travers les parcs nationaux d’Amérique avec des outils d’IA

Faites un voyage interactif à travers les parcs nationaux américains avec des outils d’IA

Les parcs nationaux américains ont toujours inspiré un sentiment d’émerveillement, mais tout le monde ne peut pas emporter une cuisinière de camping et se rendre à Yosemite ou à Acadia sur un coup de tête. En août 2026, Google Arts & Culture a lancé un projet remarquable appelé United Parks of America, conçu pour permettre à chacun d’explorer ces paysages protégés depuis n’importe où dans le monde. L’initiative est un excellent exemple de la façon dont l’IA peut transformer un écran statique en un environnement interactif et riche, permettant aux visiteurs de « parcourir » des sentiers, de zoomer sur des détails géologiques et d’écouter les histoires derrière les monuments.

Mais vous n’avez pas besoin d’attendre qu’un géant de la technologie crée votre expérience. Avec quelques outils open source et des jeux de données publics, vous pouvez créer votre propre voyage interactif à travers les parcs nationaux américains. Cet article présente un projet pratique et concret : une application en ligne de commande et sur le web qui récupère les données des parcs, génère des textes descriptifs et produit même des légendes d’images alimentées par l’IA. C’est un projet de week-end parfait pour les développeurs qui veulent allier leur amour de la nature à un peu d’apprentissage automatique.

Prérequis

Avant de commencer, assurez-vous d’avoir ce qui suit sur votre machine :

• Python 3.9 ou supérieur – nous utiliserons des fonctionnalités modernes du langage et des versions récentes de bibliothèques.
• pip – le gestionnaire de paquets Python standard, généralement fourni avec Python.
• Une connexion Internet stable – nous devons télécharger des ensembles de données et des modèles pré-entraînés.
• Une clé API du National Park Service (NPS) – gratuite, disponible sur developer.nps.gov. Ce service web public fournit des informations officielles sur tous les parcs nationaux, y compris les descriptions, les activités et les coordonnées.
• Un GPU (optionnel mais recommandé) – si vous prévoyez d’exécuter un modèle vision-langage localement, un GPU accélérera l’inférence. Cependant, l’exécution sur CPU fonctionne bien pour des exemples simples.

Aucune connaissance en développement frontend n’est requise ; nous utiliserons Gradio, une bibliothèque Python qui transforme quelques lignes de code en interface web partageable.

Installation pas à pas

Tout d’abord, créez un environnement Python propre pour éviter les conflits de dépendances avec d’autres projets. Ouvrez votre terminal et créez un environnement virtuel.

python -m venv nps-env

Activez-le. Sur macOS et Linux :

source nps-env/bin/activate

Sous Windows, la commande est légèrement différente :

nps-env\Scripts\activate

Mettez maintenant à niveau pip vers la dernière version et installez les bibliothèques nécessaires.

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

Voici ce que fait chaque bibliothèque :

• requests – effectue les appels HTTP vers l’API NPS.
• pandas – organise les données JSON renvoyées en tableaux.
• pillow – traite les images.
• torch – PyTorch, le moteur derrière de nombreux modèles d’IA.
• transformers – la bibliothèque de Hugging Face pour charger des modèles de langage et de vision pré-entraînés.
• gradio – crée une interface web pour notre outil.

Après l’installation, vérifiez que tout fonctionne en affichant les versions.

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

Créez maintenant un dossier de projet et un script Python. Nous l’appellerons nps_journey.py.

mkdir nps-journey
cd nps-journey

Récupération des données des parcs nationaux

Le National Park Service fournit une API bien documentée. Pour y accéder, vous avez besoin d’une clé API. Une fois que vous l’avez, enregistrez-la dans une variable d’environnement pour des raisons de sécurité.

export NPS_API_KEY="votre-cle-api-ici"

Nous allons maintenant écrire un script qui demande une liste des parcs et affiche leurs noms. Ouvrez nps_journey.py dans un éditeur de texte et ajoutez :

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())

Exécutez le script pour voir une liste des parcs nationaux et les États où ils se trouvent.

python nps_journey.py

Vous obtiendrez un tableau avec au moins les 50 premiers parcs. Nous avons maintenant la matière première pour notre voyage interactif.

Construction de l’interface interactive

Un simple menu en ligne de commande est un bon début. Nous pouvons demander à l’utilisateur de choisir un parc, puis afficher sa description, ses activités et ses horaires. Étendons notre script :

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("\nParcs disponibles (10 premiers) :")
        sample = parks_df.head(10)[["parkCode", "name"]].to_string(index=False)
        print(sample)
        code = input("Entrez un code de parc (ou 'q' pour quitter) : ").strip().lower()
        if code == "q":
            break
        park = get_park_details(code)
        if park is None:
            print("Parc introuvable. Réessayez.")
            continue
        print(f"\n{park['name']}")
        print(park.get("description", "Aucune description disponible."))
        print("\nActivités : ", ", ".join(
            [a["name"] for a in park.get("activities", [])]
        ))
        print("\nMétéo : ", park.get("weatherInfo", "Non disponible."))

if __name__ == "__main__":
    interactive_cli()

Nous pouvons maintenant naviguer dans les parcs directement depuis le terminal. Mais pour rendre cela vraiment interactif et visuel, utilisons une interface web.

Exemples d’utilisation

Exemple 1 : un tableau de bord Gradio pour explorer les parcs

Gradio est le moyen le plus rapide de transformer votre script Python en application web partageable. Nous allons créer une fonction qui prend un code de parc et renvoie une vue structurée des informations essentielles du parc.

import gradio as gr

def display_park(park_code):
    park = get_park_details(park_code)
    if park is None:
        return "Parc introuvable", 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"**Parc :** {park['name']}\n\n{description}\n\n**Activités :** {activities}"
    return info, img_url

Lançons ensuite l’application :

demo = gr.Interface(
    fn=display_park,
    inputs="text",
    outputs=["markdown", gr.Image(type="filepath")],
    title="Explorateur interactif des parcs nationaux",
    description="Entrez un code de parc (ex. YOSE pour Yosemite) pour explorer."
)
demo.launch()

Exécutez le script et ouvrez l’URL locale dans votre navigateur. Vous venez de créer un explorateur web interactif qui vous donne les informations et les images officielles du NPS. C’est une base solide pour un « voyage ».

Exemple 2 : légende d’images alimentée par l’IA

Voici maintenant la touche IA. Le projet de Google Arts & Culture donne un aperçu de la puissance de l’IA générative : elle peut vous inviter dans un paysage à travers plusieurs sens. Nous pouvons reproduire cette sensation avec un modèle vision-langage pré-entraîné qui décrit n’importe quelle image que vous lui donnez.

La bibliothèque transformers de Hugging Face inclut des modèles comme BLIP (Bootstrapping Language-Image Pre-training). Voici comment le charger et obtenir une description d’une photo de parc.

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

Combinons cela avec l’explorateur de parcs. Lorsqu’un utilisateur sélectionne un parc, nous prenons la première image de l’API NPS, nous l’enregistrons dans un fichier temporaire et nous générons une légende poétique avec BLIP.

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 "Parc ou image introuvable", 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\nDescription : {park.get('description', '')}"
    return info, temp_path

Lançons maintenant une nouvelle interface Gradio :

demo2 = gr.Interface(
    fn=display_park_with_caption,
    inputs="text",
    outputs=["markdown", gr.Image(type="filepath")],
    title="Voyage dans les parcs nationaux avec l’IA",
    description="Entrez un code de parc et laissez l’IA interpréter la vue."
)
demo2.launch()

C’est un petit avant-goût des voyages interactifs mentionnés dans le projet Google Arts & Culture. Au lieu de simplement lire des faits, l’utilisateur reçoit une interprétation générée par l’IA de ce à quoi ressemble l’endroit. Vous pouvez même aller plus loin : générer un court poème, créer un itinéraire de voyage basé sur les activités du parc ou résumer les avis des visiteurs.

Exemple 3 : un planificateur d’itinéraire utilisant les coordonnées des parcs

La plupart des enregistrements du NPS incluent latitude et longitude. Nous pouvons nous en servir pour construire un voyage basé sur une carte. Par souci de simplicité, nous afficherons les coordonnées et calculerons les distances entre deux parcs. C’est une fonctionnalité pratique pour les personnes qui souhaitent planifier un road trip multi-parcs.

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 "Code de parc invalide."
    lat1, lon1 = park1["latitude"], park1["longitude"]
    lat2, lon2 = park2["latitude"], park2["longitude"]
    dist = haversine(float(lat1), float(lon1), float(lat2), float(lon2))
    return f"Distance de {park1['name']} à {park2['name']} : {dist:.0f} km"

Ajoutez cette fonction à l’application Gradio existante, et les visiteurs pourront explorer la géographie derrière l’expérience. C’est un outil instantané « où vais-je ensuite ».

Exemple 4 : génération d’un itinéraire personnalisé

L’API NPS fournit également une liste d’activités, mais nous pouvons aller plus loin et utiliser un modèle de langage pour créer un itinéraire d’une journée basé sur ces activités. Par exemple, nous pouvons utiliser un modèle léger de génération de texte de Hugging Face, comme distilgpt2, pour rédiger un paragraphe décrivant une randonnée dans le parc. Ce n’est pas un itinéraire factuel entièrement fiable, mais cela donne une touche immersive et créative.

from transformers import pipeline

def generate_itinerary(park_code):
    park = get_park_details(park_code)
    if not park:
        return "Parc introuvable."
    activities = [a["name"] for a in park.get("activities", [])]
    prompt = (
        f"Imaginons une journée dans {park['name']}. "
        f"Le parc propose : {', '.join(activities[:5])}. "
        f"Rédigez un court itinéraire en deux phrases."
    )
    text_gen = pipeline("text-generation", model="distilgpt2")
    result = text_gen(prompt, max_new_tokens=80, num_return_sequences=1)[0]["generated_text"]
    return result

Combinez cela avec les fonctions précédentes, et vous obtenez un voyage entièrement interactif avec trois niveaux d’assistance IA : données factuelles, description visuelle et récit créatif. Cela reflète l’esprit du projet United Parks of America : rendre les parcs vivants, même à distance.

Tout assembler

Regroupons tout dans une seule application Gradio avec des onglets, afin de pouvoir passer de l’explorateur classique à la légende d’images, au calcul de distance et au générateur d’itinéraire IA.

with gr.Blocks() as full_app:
    gr.Markdown("# 🏞 Faites un voyage IA à travers les parcs nationaux américains")
    with gr.Tab("Explorer"):
        code_input = gr.Textbox(label="Code du parc")
        out_text = gr.Markdown()
        out_img = gr.Image(type="filepath")
        explore_btn = gr.Button("Go")
        explore_btn.click(fn=display_park_with_caption, inputs=code_input, outputs=[out_text, out_img])
    with gr.Tab("Distance"):
        code1 = gr.Textbox(label="Code du parc 1")
        code2 = gr.Textbox(label="Code du parc 2")
        dist_out = gr.Markdown()
        dist_btn = gr.Button("Calculer")
        dist_btn.click(fn=distance_between_parks, inputs=[code1, code2], outputs=dist_out)
    with gr.Tab("Itinéraire"):
        code_it = gr.Textbox(label="Code du parc")
        it_out = gr.Markdown()
        it_btn = gr.Button("Générer")
        it_btn.click(fn=generate_itinerary, inputs=code_it, outputs=it_out)
full_app.launch()

Exécutez à nouveau le script et vous aurez un portail interactif local. Partagez l’URL locale avec des amis, ou déployez-le sur un service gratuit comme Hugging Face Spaces (n’oubliez pas d’y définir votre clé API NPS comme secret).

Remarques et limites

Les outils que nous avons construits sont éducatifs, pas de qualité production. Quelques points à garder à l’esprit :

• La limite de débit de l’API NPS est de 50 requêtes par seconde, ce qui est généreux, mais évitez de la marteler.
• Le modèle BLIP a été entraîné sur des images générales ; ses légendes pour des monuments spécifiques de parcs peuvent donc être trop génériques. Vous pouvez l’affiner, mais cela nécessite des données supplémentaires.
• distilgpt2 est un petit modèle de langage ; son itinéraire sera créatif, pas réaliste. Un modèle plus grand comme Llama 3 donnerait de meilleurs résultats, mais nécessiterait plus de mémoire et un environnement d’hébergement approprié.
• Le document du projet United Parks of America montre ce qui est possible avec une ingénierie significative en coulisses ; votre version DIY est un point de départ amusant, pas un remplacement complet.

Conclusion

L’initiative United Parks of America de Google Arts & Culture, lancée en août 2026, est une belle démonstration de la façon dont l’IA peut apporter le plein air à n’importe quel écran. Mais les mêmes concepts sous-jacents – traitement du langage naturel, modèles vision-langage et données ouvertes – sont accessibles aux amateurs et aux développeurs. Avec moins de 150 lignes de Python, vous avez maintenant construit un voyage interactif à travers les parcs nationaux américains qui vous permet d’explorer, de décrire, de planifier et d’imaginer.

Ce projet n’est que le début du sentier. Ajoutez des fonctionnalités comme les prévisions météo, une narration audio avec un modèle de synthèse vocale, ou même un chatbot entraîné sur les FAQ des parcs. L’essentiel est de continuer à explorer – comme vous le feriez en parcourant un nouveau sentier. L’IA vous mènera à mi-chemin ; la curiosité fait le reste.