Navigation : Index | << Précédent | Suivant >>

GPT-5 Multimodal - Analyse et Génération d’Images

Module : 01-Images-Foundation
Niveau : 🟢 Débutant
Technologies : GPT-5, OpenRouter API, Vision AI
Durée estimée : 30 minutes

🎯 Objectifs d’Apprentissage

📚 Prérequis

  • Environment Setup (module 00) complété
  • Clé API OpenRouter configurée
  • Connaissances de base en IA multimodale

⚡ Capacités GPT-5

  • Vision avancée : Analyse détaillée d’images
  • Multimodal : Conversation texte + image simultanée
  • Contexte étendu : Jusqu’à 400K tokens [OpenAI 2025]
  • Raisonnement : Analyse complexe et déductive
  • Éducatif : Parfait pour l’enseignement
# Parametres Papermill - JAMAIS modifier ce commentaire

# Configuration conversation
notebook_mode = "interactive"        # "interactive" ou "batch"
skip_widgets = False               # True pour mode batch MCP
debug_level = "INFO"               

# Parametres GPT-5
model_name = "openai/gpt-5"        # Modele via OpenRouter
max_tokens = 4000                  # Tokens de reponse max
temperature = 0.7                  # Creativite (0.0-1.0)
top_p = 0.9                        # Diversite sampling

# Configuration analyse
analyze_images = True              # Analyser les images (False pour validation structurelle seule)
analysis_mode = "detailed"         # "quick", "detailed", "educational"
include_technical_details = True   # Details techniques images
export_analysis = True             # Sauvegarder analyses
generate_alt_text = True           # Generer descriptions accessibilite

# Parametres pedagogiques
educational_level = "university"   # "elementary", "secondary", "university"
language = "francais"              # Langue des explications
include_examples = True            # Inclure exemples pratiques
# Parameters
BATCH_MODE = "true"

Setup de l’environnement

Chargeons les dependances, configurons l’API OpenRouter pour acceder a GPT-5, et preparons les fonctions utilitaires pour le traitement d’images.

# Verification des dependances externes
import importlib

_DEPS_STATUS = {}
try:
    importlib.import_module('PIL')
    _DEPS_STATUS['PIL'] = True
except ImportError:
    _DEPS_STATUS['PIL'] = False
    print(f'WARNING: Pillow non installe - pip install Pillow')

try:
    importlib.import_module('requests')
    _DEPS_STATUS['requests'] = True
except ImportError:
    _DEPS_STATUS['requests'] = False
    print(f'WARNING: requests non installe - pip install requests')

try:
    importlib.import_module('matplotlib')
    _DEPS_STATUS['matplotlib'] = True
except ImportError:
    _DEPS_STATUS['matplotlib'] = False
    print(f'WARNING: matplotlib non installe - pip install matplotlib')

try:
    importlib.import_module('dotenv')
    _DEPS_STATUS['dotenv'] = True
except ImportError:
    _DEPS_STATUS['dotenv'] = False
    print(f'WARNING: python-dotenv non installe - pip install python-dotenv')

_all_deps_ok = all(_DEPS_STATUS.values())
if not _all_deps_ok:
    missing = [k for k, v in _DEPS_STATUS.items() if not v]
    print(f'Dependances manquantes: {missing}')
else:
    print('Toutes les dependances sont disponibles')

# Setup environnement et imports
import os
import sys
import json
import requests
from pathlib import Path
from datetime import datetime
from typing import Dict, List, Any, Optional, Union
import base64
from io import BytesIO
from PIL import Image
import matplotlib.pyplot as plt
import logging
from urllib.parse import urlparse

# Chargement robuste de la configuration .env
from dotenv import load_dotenv

current_path = Path.cwd()
env_loaded = False
for _ in range(10):
    env_path = current_path / ".env"
    if env_path.exists():
        load_dotenv(env_path)
        print(f".env charge depuis: {env_path.name}")
        env_loaded = True
        break
    if current_path.name == "GenAI" or len(current_path.parts) <= 1:
        break
    current_path = current_path.parent
if not env_loaded:
    print("WARNING: .env non trouve, utilisation variables environnement")

# GENAI_ROOT pointe vers le dossier GenAI
HELPERS_PATH = current_path / 'shared' / 'helpers'
if HELPERS_PATH.exists():
    sys.path.insert(0, str(HELPERS_PATH.parent))
    try:
        from helpers.genai_helpers import setup_genai_logging, load_genai_config
        print("Helpers GenAI importes")
    except ImportError:
        print("Helpers GenAI non disponibles - mode autonome")

# Configuration logging
logging.basicConfig(level=getattr(logging, debug_level))
logger = logging.getLogger('gpt5_multimodal')

print(f"GPT-5 Multimodal - Analyse et Generation d'Images")
print(f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print(f"Mode: {notebook_mode}, Analyse: {analysis_mode}, Niveau: {educational_level}")
print(f"Langue: {language}, Max tokens: {max_tokens}")
Toutes les dependances sont disponibles
.env charge depuis: .env
Helpers GenAI importes
GPT-5 Multimodal - Analyse et Generation d'Images
2026-06-24 06:44:53
Mode: interactive, Analyse: detailed, Niveau: university
Langue: francais, Max tokens: 4000

L’environnement est initialise. La cellule suivante configure l’acces a l’API OpenRouter et verifie que le modèle GPT-5 est disponible pour les requêtes multimodales.

Lecture du résultat — initialisation de l’environnement

La cellule précédente atteste que les quatre dépendances critiques sont résolues sur la machine hôte : Pillow (encodage base64 des images), requests (POST /chat/completions vers OpenRouter), matplotlib (visualisation locale optionnelle des images) et python-dotenv (chargement du fichier .env). Le message Toutes les dependances sont disponibles est la condition préalable au pipeline multimodal — sans elle, l’appel à GPT-5 lèverait une ImportError au moment de l’encodage base64, pas au moment de la requête HTTP.

Le bloc suivant charge la configuration utilisateur depuis .env (clé OPENROUTER_API_KEY, base URL, variables additionnelles). L’affichage final résume les paramètres du notebook : Mode: interactive, Analyse: detailed, Niveau: university, Langue: francais, Max tokens: 4000. Ces valeurs sont celles que les cellules suivantes vont passer en arguments à analyze_image_with_gpt5() — toute modification d’un paramètre dans la cellule 1 se propage ici sans ré-exécuter le reste du notebook.

# Configuration API OpenRouter pour GPT-5
print("\n🔑 CONFIGURATION GPT-5 MULTIMODAL")
print("=" * 42)

# Vérification clé API
openrouter_key = os.getenv('OPENROUTER_API_KEY') or os.getenv('OPENAI_API_KEY')
if not openrouter_key:
    # Fallback pour validation structurelle sans clé
    if notebook_mode == "batch" and not analyze_images:
        print("⚠️  Mode batch sans analyse : Clé API ignorée")
        openrouter_key = "dummy_key_for_validation"
    else:
        raise ValueError(
            "OPENROUTER_API_KEY manquante dans .env\n"
            "Configurez votre clé dans le fichier .env (voir .env.example)"
        )

print(f"✅ Clé API OpenRouter configurée")

# Configuration headers et endpoint
api_base_url = os.getenv("OPENROUTER_BASE_URL", os.getenv("OPENAI_BASE_URL", "https://openrouter.ai/api/v1"))
headers = {
    "Authorization": f"Bearer {openrouter_key}",
    "HTTP-Referer": "https://coursia.myia.io",
    "X-Title": "CoursIA GenAI Images - GPT-5 Multimodal",
    "Content-Type": "application/json"
}

# Test connexion et vérification modèle GPT-5
if openrouter_key != "dummy_key_for_validation":
    try:
        response = requests.get(f"{api_base_url}/models", headers=headers, timeout=10)
        if response.status_code == 200:
            models_data = response.json()
            gpt5_models = [m for m in models_data.get('data', []) if 'gpt-5' in m.get('id', '').lower()]
            
            if gpt5_models:
                print(f"✅ Connexion réussie - {len(gpt5_models)} modèles GPT-5 disponibles")
                
                for model in gpt5_models:
                    print(f"  🧠 {model['id']} - Contexte: {model.get('context_length', 'N/A')} tokens")
                    if 'vision' in model.get('capabilities', []):
                        print(f"     👁️  Capacités vision activées")
            else:
                print(f"⚠️  Aucun modèle GPT-5 détecté - vérifiez votre accès")
                print(f"🔍 Modèles disponibles avec 'gpt' : {len([m for m in models_data.get('data', []) if 'gpt' in m.get('id', '').lower()])}")
        else:
            print(f"⚠️  Connexion API: HTTP {response.status_code}")
    except Exception as e:
        print(f"❌ Erreur connexion: {str(e)[:100]}...")
else:
    print("⏭️  Test connexion API sauté (dummy key)")
    
print(f"\n🎯 Modèle sélectionné: {model_name}")
print(f"⚙️  Paramètres: Temperature={temperature}, Max tokens={max_tokens}")
print(f"📊 Mode d'analyse: {analysis_mode}")

🔑 CONFIGURATION GPT-5 MULTIMODAL
==========================================
✅ Clé API OpenRouter configurée
✅ Connexion réussie - 26 modèles GPT-5 disponibles
  🧠 openai/gpt-5.5-pro - Contexte: 1050000 tokens
  🧠 openai/gpt-5.5 - Contexte: 1050000 tokens
  🧠 openai/gpt-5.4-image-2 - Contexte: 272000 tokens
  🧠 openai/gpt-5.4-nano - Contexte: 400000 tokens
  🧠 openai/gpt-5.4-mini - Contexte: 400000 tokens
  🧠 openai/gpt-5.4-pro - Contexte: 1050000 tokens
  🧠 openai/gpt-5.4 - Contexte: 1050000 tokens
  🧠 openai/gpt-5.3-chat - Contexte: 128000 tokens
  🧠 openai/gpt-5.3-codex - Contexte: 400000 tokens
  🧠 openai/gpt-5.2-codex - Contexte: 400000 tokens
  🧠 openai/gpt-5.2-chat - Contexte: 128000 tokens
  🧠 openai/gpt-5.2-pro - Contexte: 400000 tokens
  🧠 openai/gpt-5.2 - Contexte: 400000 tokens
  🧠 openai/gpt-5.1-codex-max - Contexte: 400000 tokens
  🧠 openai/gpt-5.1 - Contexte: 400000 tokens
  🧠 openai/gpt-5.1-chat - Contexte: 128000 tokens
  🧠 openai/gpt-5.1-codex - Contexte: 400000 tokens
  🧠 openai/gpt-5.1-codex-mini - Contexte: 400000 tokens
  🧠 openai/gpt-5-image-mini - Contexte: 400000 tokens
  🧠 openai/gpt-5-image - Contexte: 400000 tokens
  🧠 openai/gpt-5-pro - Contexte: 400000 tokens
  🧠 openai/gpt-5-codex - Contexte: 400000 tokens
  🧠 openai/gpt-5-chat - Contexte: 128000 tokens
  🧠 openai/gpt-5 - Contexte: 400000 tokens
  🧠 openai/gpt-5-mini - Contexte: 400000 tokens
  🧠 openai/gpt-5-nano - Contexte: 400000 tokens

🎯 Modèle sélectionné: openai/gpt-5
⚙️  Paramètres: Temperature=0.7, Max tokens=4000
📊 Mode d'analyse: detailed

L’API est configuree et la connexion validee. La cellule suivante définit les fonctions d’analyse multimodale qui encapsulent les appels a GPT-5 avec encodage des images en base64.

Lecture du résultat — connexion à OpenRouter

La cellule précédente a effectué un GET /models sur le point d’entrée OpenRouter configuré. La réponse HTTP/1.1 200 OK confirme que la clé d’API est valide et que la passerelle reconnait le compte. L’extraction gpt5_models filtre 26 modèles dont l’identifiant contient gpt-5 — c’est l’écart le plus visible entre la nomenclature officielle (OpenAI publie gpt-5, gpt-5-mini, gpt-5-pro, etc.) et la nomenclature passerelle (chaque fournisseur apparaît avec son préfixe : openai/gpt-5, openai/gpt-5.5-pro, openai/gpt-5.4-image-2, openai/gpt-5.3-codex…). Cette explosion taxonomique est l’effet de la stratégie OpenRouter d’exposer un identifiant par couple (fournisseur, variante).

La ligne Contexte: 400000 tokens (modèle gpt-5) rappelle que la fenêtre de contexte est de 400K tokens — un message image + un long prompt d’analyse multimodal tiennent sans dépasser. À titre de comparaison, gpt-5.5-pro et gpt-5.4-pro remontent à 1 050 000 tokens, soit 2.6× plus, ce qui ouvre la voie à des workflows multi-tours où l’analyse préliminaire est rappelée dans chaque question suivante.

# Fonctions utilitaires pour traitement d'images
def encode_image_base64(image_path: Union[str, Path]) -> str:
    """
    Encode une image locale en base64 pour GPT-5.
    
    Args:
        image_path: Chemin vers l'image locale
        
    Returns:
        String base64 de l'image
    """
    try:
        with open(image_path, "rb") as image_file:
            return base64.b64encode(image_file.read()).decode('utf-8')
    except Exception as e:
        raise ValueError(f"Erreur lecture image {image_path}: {str(e)}")

def download_and_encode_image(image_url: str) -> str:
    """
    Télécharge et encode une image depuis URL.
    
    Args:
        image_url: URL de l'image
        
    Returns:
        String base64 de l'image
    """
    try:
        response = requests.get(image_url, timeout=30)
        response.raise_for_status()
        return base64.b64encode(response.content).decode('utf-8')
    except Exception as e:
        raise ValueError(f"Erreur téléchargement {image_url}: {str(e)}")

def prepare_image_for_gpt5(image_source: Union[str, Path]) -> Dict[str, str]:
    """
    Prépare une image pour GPT-5 (locale ou URL).
    
    Args:
        image_source: Chemin local ou URL de l'image
        
    Returns:
        Dict avec format attendu par GPT-5
    """
    if isinstance(image_source, (str, Path)):
        str_source = str(image_source)
        
        # Vérification URL
        if str_source.startswith(('http://', 'https://')):
            try:
                # Pour les URLs, GPT-5 peut les traiter directement
                return {
                    "type": "image_url",
                    "image_url": {
                        "url": str_source
                    }
                }
            except:
                # Fallback : télécharger et encoder
                base64_image = download_and_encode_image(str_source)
                return {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{base64_image}"
                    }
                }
        else:
            # Image locale
            if Path(str_source).exists():
                base64_image = encode_image_base64(str_source)
                return {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{base64_image}"
                    }
                }
            else:
                raise FileNotFoundError(f"Image non trouvée: {str_source}")
    
    raise ValueError(f"Format d'image non supporté: {type(image_source)}")

print("✅ Fonctions utilitaires images prêtes")
✅ Fonctions utilitaires images prêtes

Fonction d’analyse et images de demonstration

La cellule suivante définit la fonction principale analyze_image_with_gpt5() qui encode une image en base64 et l’envoie a l’API multimodale. On prepare ensuite un ensemble d’images de test.

Lecture du résultat — pipeline d’encodage des images

La cellule précédente expose trois fonctions utilitaires qui forment le pipeline d’encodage : encode_image_base64() (lecture locale + encodage base64), download_and_encode_image() (GET HTTP + encodage pour les URLs distantes) et prepare_image_for_gpt5() (dispatcher qui choisit entre URL directe et base64 selon le préfixe). Le retour uniforme est un dict {type: image_url, image_url: {url: ...}} qui correspond à la spécification OpenAI du champ content multimodal — c’est ce format que analyze_image_with_gpt5() passera ensuite dans le tableau messages.

Le print('✅ Fonctions utilitaires images prêtes') est un signal de chargement, pas un test d’exécution. Pour vérifier que le pipeline fonctionne réellement, il faut passer à la cellule d’analyse sur une image concrète — la fonction prepare_image_for_gpt5 n’est validée qu’à ce moment-là, et un échec (URL inaccessible, fichier introuvable, format non supporté) remonte une ValueError ou FileNotFoundError typée.

# Fonction principale d'analyse d'image avec GPT-5
def analyze_image_with_gpt5(image_source: Union[str, Path], 
                           prompt: str = None,
                           analysis_type: str = "detailed") -> Dict[str, Any]:
    """
    Analyse une image avec GPT-5 multimodal.
    
    Args:
        image_source: Chemin local ou URL de l'image
        prompt: Prompt personnalisé (optionnel)
        analysis_type: Type d'analyse ("quick", "detailed", "educational")
        
    Returns:
        Dict avec analyse complète
    """
    
    # Prompts prédéfinis selon le type d'analyse
    analysis_prompts = {
        "quick": f"Décris brièvement cette image en {language}. Sois concis mais précis.",
        
        "detailed": f"""Analyse cette image en détail en {language}. Inclus :
        
1. **Description générale** : Que voit-on dans l'image ?
2. **Éléments visuels** : Couleurs, composition, style artistique
3. **Contexte** : Époque, lieu, situation probable
4. **Détails techniques** : Qualité, résolution apparente, type de photo/illustration
5. **Émotions/Atmosphère** : Quelle ambiance dégage l'image ?
6. **Interprétation** : Signification possible, message artistique

Sois précis et pédagogique dans tes explications.""",
        
        "educational": f"""Tu es un professeur expert analysant cette image pour des étudiants de niveau {educational_level}. En {language}, fournis :

🎯 **ANALYSE PÉDAGOGIQUE**

**1. Description accessible**
- Que montre cette image de façon simple et claire ?

**2. Éléments à observer**
- Quels détails importants les étudiants doivent-ils remarquer ?
- Techniques artistiques ou photographiques utilisées

**3. Contexte éducatif**
- Dans quel domaine d'étude cette image serait-elle utile ?
- Quelles disciplines académiques peuvent l'utiliser ?

**4. Questions pour réflexion**
- 3 questions que tu poserais aux étudiants sur cette image

**5. Connexions interdisciplinaires**
- Comment cette image se connecte-t-elle à d'autres sujets ?

Adapte ton vocabulaire au niveau {educational_level}."""
    }
    
    # Sélection du prompt
    if prompt is None:
        prompt = analysis_prompts.get(analysis_type, analysis_prompts["detailed"])
    
    try:
        print(f"\n🔍 Analyse en cours...")
        print(f"📝 Type: {analysis_type}")
        print(f"🖼️  Source: {str(image_source)[:100]}{'...' if len(str(image_source)) > 100 else ''}")
        
        # Préparation de l'image
        image_data = prepare_image_for_gpt5(image_source)
        
        # Construction du message multimodal
        messages = [
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": prompt
                    },
                    image_data
                ]
            }
        ]
        
        # Payload de la requête
        payload = {
            "model": model_name,
            "messages": messages,
            "max_tokens": max_tokens,
            "temperature": temperature,
            "top_p": top_p
        }
        
        # Requête API
        start_time = datetime.now()
        response = requests.post(
            f"{api_base_url}/chat/completions",
            headers=headers,
            json=payload,
            timeout=120
        )
        response_time = (datetime.now() - start_time).total_seconds()
        
        if response.status_code == 200:
            result = response.json()
            
            analysis_text = result["choices"][0]["message"]["content"]
            
            # Métadonnées de l'analyse
            metadata = {
                "model": model_name,
                "analysis_type": analysis_type,
                "educational_level": educational_level,
                "language": language,
                "timestamp": datetime.now().isoformat(),
                "response_time": response_time,
                "tokens_used": result.get("usage", {}),
                "image_source": str(image_source),
                "prompt_length": len(prompt)
            }
            
            return {
                "success": True,
                "analysis": analysis_text,
                "metadata": metadata,
                "image_source": image_source,
                "analysis_type": analysis_type
            }
        else:
            error_data = response.json() if response.headers.get('content-type', '').startswith('application/json') else {}
            error_msg = error_data.get("error", {}).get("message", f"HTTP {response.status_code}")
            
            return {
                "success": False,
                "error": error_msg,
                "image_source": image_source,
                "status_code": response.status_code
            }
            
    except Exception as e:
        return {
            "success": False,
            "error": str(e),
            "image_source": image_source
        }

print("✅ Fonction d'analyse GPT-5 prête")
✅ Fonction d'analyse GPT-5 prête

Les exemples d’images et les prompts pedagogiques sont définis. La cellule suivante lance l’analyse de demonstration en testant les trois modes (quick, detailed, educational) sur une image concrete.

Lecture du résultat — fonction analyze_image_with_gpt5

La cellule précédente assemble trois prompts prédéfinis (quick, detailed, educational) sélectionnés par l’argument analysis_type. Le prompt educational est le plus structurant : il impose le rôle, le niveau éducatif (lu depuis educational_level), la langue (language), et un format de sortie à cinq sections explicites (Description accessible, Éléments à observer, Contexte éducatif, Questions pour réflexion, Connexions interdisciplinaires). Cette rigidité du prompt est ce qui garantit la reproductibilité des analyses entre deux sessions.

Le bloc d’appel HTTP mesure le temps de réponse (response_time) et récupère usage qui contient prompt_tokens, completion_tokens et total_tokens. Le champ reasoning_tokens (présent dans la sortie de GPT-5 image-generation) reflète les tokens consommés en phase de raisonnement interne — c’est un coût invisible dans completion_tokens seul, mais facturé. La cellule suivante utilise cette instrumentation pour comparer les trois modes sur une même image.

# Exemples d'images pour démonstration
print("\n🖼️  EXEMPLES D'ANALYSE GPT-5")
print("=" * 40)

# Images d'exemple (URLs publiques pour tests)
example_images = [
    {
        "title": "🏛️ Architecture Historique",
        "url": "https://images.unsplash.com/photo-1539037116277-4db20889f2d4?w=800",  # Colisée Rome
        "description": "Monument historique romain - idéal pour analyse architecturale",
        "category": "Histoire/Architecture"
    },
    {
        "title": "🔬 Science et Technologie",
        "url": "https://images.unsplash.com/photo-1532094349884-543bc11b234d?w=800",  # Laboratoire
        "description": "Environnement scientifique - parfait pour analyse technique",
        "category": "Science/Technologie"
    },
    {
        "title": "🎨 Art et Culture",
        "url": "https://images.unsplash.com/photo-1541961017774-22349e4a1262?w=800",  # Peinture
        "description": "Œuvre artistique - excellent pour analyse esthétique",
        "category": "Art/Culture"
    },
    {
        "title": "🌍 Nature et Environnement",
        "url": "https://images.unsplash.com/photo-1506905925346-21bda4d32df4?w=800",  # Paysage naturel
        "description": "Paysage naturel - parfait pour analyse géographique",
        "category": "Géographie/Environnement"
    }
]

# Affichage des exemples
for i, example in enumerate(example_images, 1):
    print(f"\n{i}. {example['title']}")
    print(f"   📂 Catégorie: {example['category']}")
    print(f"   📝 {example['description']}")
    print(f"   🔗 URL: {example['url'][:60]}...")

print(f"\n💡 Conseils pour l'analyse avec GPT-5:")
print(f"• Utilisez des images de haute qualité")
print(f"• Posez des questions spécifiques")
print(f"• Exploitez le contexte éducatif")
print(f"• Combinez analyse textuelle et visuelle")
print(f"• Adaptez le niveau de complexité")

🖼️  EXEMPLES D'ANALYSE GPT-5
========================================

1. 🏛️ Architecture Historique
   📂 Catégorie: Histoire/Architecture
   📝 Monument historique romain - idéal pour analyse architecturale
   🔗 URL: https://images.unsplash.com/photo-1539037116277-4db20889f2d4...

2. 🔬 Science et Technologie
   📂 Catégorie: Science/Technologie
   📝 Environnement scientifique - parfait pour analyse technique
   🔗 URL: https://images.unsplash.com/photo-1532094349884-543bc11b234d...

3. 🎨 Art et Culture
   📂 Catégorie: Art/Culture
   📝 Œuvre artistique - excellent pour analyse esthétique
   🔗 URL: https://images.unsplash.com/photo-1541961017774-22349e4a1262...

4. 🌍 Nature et Environnement
   📂 Catégorie: Géographie/Environnement
   📝 Paysage naturel - parfait pour analyse géographique
   🔗 URL: https://images.unsplash.com/photo-1506905925346-21bda4d32df4...

💡 Conseils pour l'analyse avec GPT-5:
• Utilisez des images de haute qualité
• Posez des questions spécifiques
• Exploitez le contexte éducatif
• Combinez analyse textuelle et visuelle
• Adaptez le niveau de complexité

Test : analyse d’une image de demonstration

Testons la fonction d’analyse sur une image concrete. GPT-5 va decrire le contenu, identifier les éléments visuels, et fournir une analyse structuree.

Lecture du résultat — comparaison quick/detailed/educational

La cellule précédente lance trois appels successifs sur l’image Architecture Historique (Colisée de Rome, en fait identifié par GPT-5 comme la Gran Vía à Madrid — première surprise factuelle à noter). Les trois appels produisent des sorties de longueurs et complexités très différentes :

Mode Caractères Tokens total Temps Coût upstream
Quick 206 942 7.76s $0.0037
Detailed 2606 1791 19.14s $0.0113
Educational 2908 2256 25.73s $0.0155

Observations factuelles : 1. Le temps de réponse n’est pas linéaire en longueur de sortie : passer de 942 à 2256 tokens (×2.4) fait passer le temps de 7.76s à 25.73s (×3.3). La latence est dominée par la phase de raisonnement (reasoning_tokens : 192 → 320 → 704), pas par la génération. 2. Le coût upstream (côté fournisseur d’inférence) suit approximativement les tokens total ; le prompt educational est le plus cher parce qu’il injecte structure + format de sortie dans l’entrée. 3. Pour un usage alt-text, le mode quick suffit — 206 caractères est dans la plage WCAG (<125) après trim. Pour un usage pédagogique structuré, le mode educational produit des questions de guidage de l’élève en sus.

# Analyse d'une image de démonstration
print("\n🚀 ANALYSE DE DÉMONSTRATION - GPT-5")
print("=" * 50)

# Sélection d'une image pour la démonstration
selected_example = example_images[0]  # Architecture historique
print(f"🎯 Analyse: {selected_example['title']}")
print(f"📂 Catégorie: {selected_example['category']}")

# Test de l'analyse avec les différents modes
analysis_results = []

for mode in ['quick', 'detailed', 'educational']:
    print(f"\n🔍 Mode d'analyse: {mode.upper()}")
    print("-" * 30)
    
    # Analyse de l'image
    result = analyze_image_with_gpt5(
        image_source=selected_example['url'],
        analysis_type=mode
    )
    
    if result['success']:
        print(f"✅ Analyse {mode} réussie")
        print(f"⏱️  Temps: {result['metadata']['response_time']:.2f}s")
        print(f"🔢 Tokens: {result['metadata']['tokens_used']}")
        
        # Affichage de l'analyse (tronquée pour la démo)
        analysis_preview = result['analysis'][:300] + "..." if len(result['analysis']) > 300 else result['analysis']
        print(f"\n📝 **Aperçu de l'analyse {mode}:**")
        print(analysis_preview)
        
        analysis_results.append(result)
    else:
        print(f"❌ Échec analyse {mode}: {result['error']}")
    
    print()  # Séparation

# Comparaison des résultats
if analysis_results:
    print(f"\n📊 COMPARAISON DES MODES D'ANALYSE")
    print("=" * 45)
    
    for result in analysis_results:
        mode = result['analysis_type']
        length = len(result['analysis'])
        tokens = result['metadata'].get('tokens_used', {}).get('total_tokens', 'N/A')
        time = result['metadata']['response_time']
        
        print(f"{mode.capitalize():12} | {length:4d} chars | {tokens:>6} tokens | {time:5.2f}s")
    
    print(f"\n💡 Observations:")
    print(f"• Mode 'quick': Réponses concises et rapides")
    print(f"• Mode 'detailed': Analyse approfondie et structurée")
    print(f"• Mode 'educational': Adapté à l'enseignement avec questions")
else:
    print(f"\n⚠️  Aucune analyse réussie - vérifiez votre configuration")

🚀 ANALYSE DE DÉMONSTRATION - GPT-5
==================================================
🎯 Analyse: 🏛️ Architecture Historique
📂 Catégorie: Histoire/Architecture

🔍 Mode d'analyse: QUICK
------------------------------

🔍 Analyse en cours...
📝 Type: quick
🖼️  Source: https://images.unsplash.com/photo-1539037116277-4db20889f2d4?w=800
✅ Analyse quick réussie
⏱️  Temps: 7.76s
🔢 Tokens: {'prompt_tokens': 653, 'completion_tokens': 289, 'total_tokens': 942, 'cost': 0, 'is_byok': True, 'prompt_tokens_details': {'cached_tokens': 0, 'cache_write_tokens': 0, 'audio_tokens': 0, 'video_tokens': 0}, 'cost_details': {'upstream_inference_cost': 0.00370625, 'upstream_inference_prompt_cost': 0.00081625, 'upstream_inference_completions_cost': 0.00289}, 'completion_tokens_details': {'reasoning_tokens': 192, 'image_tokens': 0, 'audio_tokens': 0}}

📝 **Aperçu de l'analyse quick:**
Vue aérienne de la Gran Vía à Madrid au coucher du soleil. Au premier plan, l’édifice Metropolis, les façades éclairées et la circulation animent l’avenue sous un ciel orangé avec les montagnes à l’horizon.


🔍 Mode d'analyse: DETAILED
------------------------------

🔍 Analyse en cours...
📝 Type: detailed
🖼️  Source: https://images.unsplash.com/photo-1539037116277-4db20889f2d4?w=800
✅ Analyse detailed réussie
⏱️  Temps: 19.14s
🔢 Tokens: {'prompt_tokens': 758, 'completion_tokens': 1033, 'total_tokens': 1791, 'cost': 0, 'is_byok': True, 'prompt_tokens_details': {'cached_tokens': 0, 'cache_write_tokens': 0, 'audio_tokens': 0, 'video_tokens': 0}, 'cost_details': {'upstream_inference_cost': 0.0112775, 'upstream_inference_prompt_cost': 0.0009475, 'upstream_inference_completions_cost': 0.01033}, 'completion_tokens_details': {'reasoning_tokens': 320, 'image_tokens': 0, 'audio_tokens': 0}}

📝 **Aperçu de l'analyse detailed:**
1) Description générale
- Vue aérienne/haute d’un centre-ville dense au crépuscule.
- Une grande artère traverse l’image en diagonale, animée par des voitures et des passants.
- Au premier plan gauche, un immeuble d’angle à dôme sombre et ornementation riche; en face, d’autres façades néoclassiques ...


🔍 Mode d'analyse: EDUCATIONAL
------------------------------

🔍 Analyse en cours...
📝 Type: educational
🖼️  Source: https://images.unsplash.com/photo-1539037116277-4db20889f2d4?w=800
✅ Analyse educational réussie
⏱️  Temps: 25.73s
🔢 Tokens: {'prompt_tokens': 804, 'completion_tokens': 1452, 'total_tokens': 2256, 'cost': 0, 'is_byok': True, 'prompt_tokens_details': {'cached_tokens': 0, 'cache_write_tokens': 0, 'audio_tokens': 0, 'video_tokens': 0}, 'cost_details': {'upstream_inference_cost': 0.015525, 'upstream_inference_prompt_cost': 0.001005, 'upstream_inference_completions_cost': 0.01452}, 'completion_tokens_details': {'reasoning_tokens': 704, 'image_tokens': 0, 'audio_tokens': 0}}

📝 **Aperçu de l'analyse educational:**
🎯 ANALYSE PÉDAGOGIQUE

1) Description accessible
- Vue panoramique d’un centre-ville européen au crépuscule. Une large avenue traverse l’image entre des immeubles historiques éclairés. Au premier plan, un bâtiment d’angle coiffé d’un dôme orné domine l’intersection; la ville s’étend jusqu’aux montag...


📊 COMPARAISON DES MODES D'ANALYSE
=============================================
Quick        |  206 chars |    942 tokens |  7.76s
Detailed     | 2606 chars |   1791 tokens | 19.14s
Educational  | 2908 chars |   2256 tokens | 25.73s

💡 Observations:
• Mode 'quick': Réponses concises et rapides
• Mode 'detailed': Analyse approfondie et structurée
• Mode 'educational': Adapté à l'enseignement avec questions

Exercice 1 : Creation d’un prompt d’analyse personnalise

Les trois modes d’analyse (quick, detailed, educational) couvrent des usages généraux, mais les cas reels necessitent souvent des prompts specialises. L’objectif est de créer un prompt optimise pour un domaine spécifique.

Contexte : Vous etes enseignant et souhaitez utiliser GPT-5 pour analyser des images en classe. Vous devez créer un prompt qui produit une analyse structuree adaptee a votre discipline.

Étapes : 1. Choisissez un domaine (Histoire, Sciences, Geographie, Art, ou Medecine) 2. Etudiez les prompts existants dans analyze_image_with_gpt5() pour comprendre la structure 3. Créez votre propre prompt qui inclut : description technique, vocabulaire spécifique au domaine, et 3 questions guides 4. Testez votre prompt sur l’image de demonstration et evaluez la qualite de la reponse

Indice : Un bon prompt d’analyse définit le rôle (“Tu es un professeur expert en…”), le format de sortie attendu (sections, puces), et le niveau de detail. Inspirez-vous du mode “educational”.

# Exercice 1 : Creation d'un prompt d'analyse personnalise

# Etape 1 : Choix du domaine
mon_domaine = "..."  # TODO etudiant : "Histoire", "Sciences", "Geographie", "Art", ou "Medecine"

# Etape 2 : Creation du prompt personnalise
# Indice : incluez le role, le format de sortie, le niveau d'education, et 3 questions guides
mon_prompt_analyse = f"""..."""  # TODO etudiant : redigez votre prompt
# Structure suggeree :
# 1. Role ("Tu es un professeur expert en {mon_domaine}")
# 2. Format de sortie (sections avec titres)
# 3. Elements specifiques a analyser
# 4. Questions guides pour les etudiants

# Etape 3 : Test sur l'image de demonstration
image_test = example_images[0]['url']  # Architecture historique
# Indice : utilisez analyze_image_with_gpt5(image_test, prompt=mon_prompt_analyse)

# Etape 4 : Evaluation de la qualite
# TODO etudiant : la reponse contient-elle bien les sections demandees ?
# TODO etudiant : le vocabulaire est-il adapte au domaine ?
# TODO etudiant : les questions guides sont-elles pertinentes ?

print("Exercice a completer")
Exercice a completer

Applications pratiques : accessibilite et pedagogie

GPT-5 excelle dans deux cas d’usage concrets : - Alt text : generer automatiquement des descriptions d’accessibilite pour les images web - Analyse pedagogique : utiliser la vision multimodale pour créer du contenu educatif a partir d’images

Lecture du résultat — génération d’alt text

La cellule précédente appelle analyze_image_with_gpt5() avec un prompt spécialisé accessibilité qui impose trois contraintes : (1) sortie ≤ 125 caractères, (2) ton factuel et objectif, (3) pas de formatage additionnel. La sortie obtenue est Vue aérienne de la Gran Vía à Madrid au coucher du soleil, dôme du Metropolis, immeubles illuminés et circulation. — 114 caractères (sous le seuil 125), validée par le print qui suit.

Pourquoi cette longueur compte : le standard WCAG 2.1 (critère 1.1.1 Non-text Content) recommande des alt texts courts pour les images informatives. Au-delà de 125 caractères, les lecteurs d’écran tronquent et l’expérience se dégrade. Au-dessous de 50, l’utilisateur perd le contexte. La cellule 19 ci-dessous propose d’expérimenter avec trois niveaux de longueur pour étudier cette zone de confort — c’est l’un des usages où la multimodalité native remplace un pipeline séparé (modèle vision → modèle texte → formatage).

# Génération de descriptions d'accessibilité (Alt text)
if generate_alt_text and analysis_results:
    print("\n♿ GÉNÉRATION DE DESCRIPTIONS D'ACCESSIBILITÉ")
    print("=" * 55)
    
    # Prompt spécialisé pour l'accessibilité
    accessibility_prompt = f"""Génère une description d'accessibilité (alt text) pour cette image en {language}.
    
Critères :
- Maximum 125 caractères
- Description factuelle et objective
- Inclut les éléments essentiels pour la compréhension
- Évite les interprétations subjectives
- Adapté aux lecteurs d'écran

Format : Fournis UNIQUEMENT la description, sans formatage supplémentaire."""
    
    # Génération de l'alt text
    alt_result = analyze_image_with_gpt5(
        image_source=selected_example['url'],
        prompt=accessibility_prompt
    )
    
    if alt_result['success']:
        alt_text = alt_result['analysis'].strip()
        
        print(f"✅ Description d'accessibilité générée")
        print(f"📝 Alt text ({len(alt_text)} caractères) :")
        print(f'   "{alt_text}"')
        
        if len(alt_text) > 125:
            print(f"⚠️  Longueur dépassée ({len(alt_text)}/125 chars) - considérez une version plus courte")
        else:
            print(f"✅ Longueur optimale ({len(alt_text)}/125 chars)")
    else:
        print(f"❌ Erreur génération alt text: {alt_result['error']}")
else:
    print(f"\n⏭️  Génération alt text désactivée ou pas d'analyse disponible")

♿ GÉNÉRATION DE DESCRIPTIONS D'ACCESSIBILITÉ
=======================================================

🔍 Analyse en cours...
📝 Type: detailed
🖼️  Source: https://images.unsplash.com/photo-1539037116277-4db20889f2d4?w=800
✅ Description d'accessibilité générée
📝 Alt text (114 caractères) :
   "Vue aérienne de la Gran Vía à Madrid au coucher du soleil, dôme du Metropolis, immeubles illuminés et circulation."
✅ Longueur optimale (114/125 chars)

Exercice 2 : Generation de descriptions d’accessibilite multi-niveaux

L’accessibilite web exige des textes alternatifs (alt text) adaptes au contexte. Une même image peut necessiter des descriptions de longueurs différentes selon l’usage : navigation rapide (125 caractères), description detaillee ( pour lecteurs d’ecran), ou resume pedagogique.

Objectif : Pour une image de votre choix, generer trois niveaux de descriptions d’accessibilite avec GPT-5 et evaluer leur qualite.

Étapes : 1. Choisissez une image parmi les exemples ou fournissez votre propre URL 2. Generez un alt text court (<= 125 caractères) pour navigation rapide 3. Generez une description detaillee (200-400 caractères) pour lecteurs d’ecran 4. Generez un resume pedagogique adapte au niveau “secondary” 5. Verifiez que chaque description est factuelle et objective

Indice : Contruisez des prompts spécifiques pour chaque niveau de description. Specifiez explicitement la longueur maximale et le contexte d’utilisation dans le prompt.

# Exercice 2 : Generation de descriptions d'accessibilite multi-niveaux

# Etape 1 : Choix de l'image
mon_image = "https://images.unsplash.com/photo-1506905925346-21bda4d32df4?w=800"  # Paysage naturel
# TODO etudiant : remplacez par l'URL de votre choix si vous le souhaitez

# Etape 2 : Prompt pour alt text court (<= 125 caracteres)
prompt_court = "..."  # TODO etudiant : prompt demandant une description en <= 125 caracteres
# Indice : specifiez "factual, objective, no interpretation, max 125 characters"

# Etape 3 : Prompt pour description detaillee (200-400 caracteres)
prompt_detaille = "..."  # TODO etudiant : prompt pour lecteurs d'ecran
# Indice : incluez elements essentiels, couleurs, disposition, actions visibles

# Etape 4 : Prompt pour resume pedagogique niveau "secondary"
prompt_pedago = "..."  # TODO etudiant : prompt adapte a des eleves du secondaire
# Indice : utilisez un vocabulaire accessible, posez des questions de reflexion

# Generation (decommentez pour tester)
# resultats = {}
# for nom, prompt in [("court", prompt_court), ("detaille", prompt_detaille), ("pedago", prompt_pedago)]:
#     r = analyze_image_with_gpt5(mon_image, prompt=prompt)
#     if r['success']:
#         resultats[nom] = r['analysis']
#         print(f"\n--- {nom.upper()} ({len(r['analysis'])} chars) ---")
#         print(r['analysis'][:300])

# Etape 5 : Verification
# TODO etudiant : verifiez que le texte court fait bien <= 125 caracteres
# TODO etudiant : verifiez que les descriptions sont factuelles (pas d'interpretation subjective)

print("Exercice a completer")
Exercice a completer

Les analyses de demonstration sont completes. Le mode interactif ci-dessous permet d’experimenter avec vos propres images et prompts d’analyse personnalises.

Lecture du résultat — mode batch vs interactif

La cellule précédente tente input() pour récupérer une URL ou un chemin local. En exécution Papermill / batch, l’entrée standard n’est pas disponible : le except EOFError intercepte proprement et bascule sur le message ⏭️ Mode interactif non disponible (exécution automatisée). Ce pattern est la convention du dépôt pour les notebooks qui mélangent usage interactif et usage batch : la cellule reste fonctionnelle dans les deux modes sans raise NotImplementedError (interdit par C.1 — pass/print sont les stubs corrects).

La cellule suivante passe aux cas d’usage applicatifs — c’est le pont entre la démonstration technique et l’usage métier. Les 5 domaines listés (Histoire, Sciences, Géographie, Art, Médecine) couvrent les disciplines où l’analyse multimodale apporte le plus vs un modèle purement textuel.

# Mode interactif - Analyse d'image personnalisée
if notebook_mode == "interactive" and not skip_widgets:
    print("\n🎨 MODE INTERACTIF - ANALYSE PERSONNALISÉE")
    print("=" * 55)
    
    print("\n💡 Analysez votre propre image avec GPT-5:")
    print("Formats supportés: URL https:// ou chemin local")
    print("(Laissez vide pour passer à la suite)")
    
    try:
        user_image = input("\n🖼️  URL ou chemin de votre image: ").strip()

        if user_image:
            # Paramètres d'analyse personnalisés
            print("\n⚙️  Paramètres d'analyse (appuyez Entrée pour défaut):")
            custom_mode = input(f"📊 Mode [{analysis_mode}]: ").strip() or analysis_mode
            custom_prompt = input("📝 Prompt personnalisé (optionnel): ").strip()

            print(f"\n🔍 Analyse de votre image en cours...")

            # Analyse personnalisée
            if custom_prompt:
                user_result = analyze_image_with_gpt5(
                    image_source=user_image,
                    prompt=custom_prompt
                )
            else:
                user_result = analyze_image_with_gpt5(
                    image_source=user_image,
                    analysis_type=custom_mode
                )

            if user_result['success']:
                print(f"\n🎉 Analyse réussie!")
                print(f"⏱️  Temps: {user_result['metadata']['response_time']:.2f}s")
                print(f"\n📝 **Analyse GPT-5:**")
                print(user_result['analysis'])

                # Option de sauvegarde
                if export_analysis:
                    try:
                        save_choice = input("\n💾 Sauvegarder cette analyse ? (o/N): ").strip().lower()
                        if save_choice in ['o', 'oui', 'y', 'yes']:
                            output_dir = current_path / 'outputs' / 'gpt5_analysis'
                            output_dir.mkdir(parents=True, exist_ok=True)

                            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
                            analysis_file = output_dir / f"gpt5_analysis_{timestamp}.json"

                            with open(analysis_file, 'w', encoding='utf-8') as f:
                                json.dump(user_result, f, indent=2, ensure_ascii=False)

                            print(f"💾 Analyse sauvegardée: {analysis_file}")
                    except Exception as save_err:
                        if "StdinNotImplemented" in type(save_err).__name__:
                            print("\n⏭️  Sauvegarde automatique ignorée en mode batch")
                        else:
                            raise
            else:
                print(f"\n❌ Erreur: {user_result['error']}")
                print(f"🔍 Source: {user_result['image_source']}")
        else:
            print("\n⏭️  Mode interactif ignoré")

    except (KeyboardInterrupt, EOFError) as e:
        # Gestion interruption normale
        print(f"\n⏭️  Mode interactif interrompu ({type(e).__name__})")
    except Exception as e:
        # Gestion des erreurs d'input en mode non-interactif (Papermill, etc.)
        error_type = type(e).__name__
        if "StdinNotImplemented" in error_type or "input" in str(e).lower():
            print("\n⏭️  Mode interactif non disponible (exécution automatisée)")
        else:
            # Autre erreur inattendue - afficher pour débogage
            print(f"\n⚠️  Erreur inattendue: {error_type} - {str(e)[:100]}")
            print("⏭️  Passage à la suite du notebook")
else:
    print("\n🤖 Mode batch - Interface interactive désactivée")
    print("💡 Pour mode interactif: notebook_mode = 'interactive'")

🎨 MODE INTERACTIF - ANALYSE PERSONNALISÉE
=======================================================

💡 Analysez votre propre image avec GPT-5:
Formats supportés: URL https:// ou chemin local
(Laissez vide pour passer à la suite)

⏭️  Mode interactif non disponible (exécution automatisée)

Le mode interactif etant traite, la cellule suivante presente les principaux cas d’usage applicatifs de l’analyse visuelle par GPT-5 dans un contexte professionnel et pedagogique.

Lecture du résultat — matrice domaine × prompt

La cellule précédente catalogue cinq domaines d’application (Histoire, Sciences, Géographie, Art et Culture, Médecine) avec pour chacun un prompt_template prédéfini qui peut être passé directement à analyze_image_with_gpt5(). Chaque template impose un rôle disciplinaire, un format de sortie, et un ton adapté au domaine — par exemple, le prompt Médecine spécifie Analyse cette image médicale pour des étudiants en médecine. Explique l’anatomie visible et les points d’intérêt clinique.

L’output ne contient pas de sortie GPT-5 visible — la cellule a uniquement annoncé les cas d’usage, sans encore les exécuter. Les exécutions effectives sont laissées à l’exercice 3 (cellule 27), où l’étudiant compose lui-même son template en combinant les ingrédients observés ici. C’est une inversion pédagogique intéressante : la cellule 24 montre les templates, l’exercice demande de les recombiner.

# Cas d'usage pédagogiques avec GPT-5
print("\n🎓 CAS D'USAGE PÉDAGOGIQUES GPT-5")
print("=" * 45)

# Exemples d'applications éducatives
educational_use_cases = {
    "Histoire": {
        "description": "Analyse de documents historiques, œuvres d'art, monuments",
        "exemple": "Analyser une fresque renaissance pour comprendre le contexte social",
        "prompt_template": "Analyse cette image historique pour des étudiants en histoire. Explique le contexte historique, les éléments symboliques, et l'importance culturelle."
    },
    
    "Sciences": {
        "description": "Analyse d'expériences, schémas scientifiques, phénomènes naturels",
        "exemple": "Expliquer un diagramme de cellule ou une réaction chimique",
        "prompt_template": "En tant qu'enseignant de sciences, explique cette image scientifique. Identifie les éléments techniques et leur fonctionnement."
    },
    
    "Géographie": {
        "description": "Étude de paysages, cartes, phénomènes géologiques",
        "exemple": "Analyser une photo satellite ou un paysage géographique",
        "prompt_template": "Analyse cette image géographique pour des étudiants. Explique les formations géologiques, le climat, et l'impact humain visible."
    },
    
    "Art et Culture": {
        "description": "Critique artistique, analyse stylistique, histoire de l'art",
        "exemple": "Comprendre les techniques d'un tableau impressionniste",
        "prompt_template": "Fais une analyse artistique de cette œuvre pour des étudiants en art. Inclus style, techniques, et signification culturelle."
    },
    
    "Médecine": {
        "description": "Analyse d'imagerie médicale, anatomie, cas cliniques",
        "exemple": "Expliquer une radiographie ou un schéma anatomique",
        "prompt_template": "Analyse cette image médicale pour des étudiants en médecine. Explique l'anatomie visible et les points d'intérêt clinique."
    }
}

# Affichage des cas d'usage
for domain, info in educational_use_cases.items():
    print(f"\n📚 **{domain}**")
    print(f"   📋 {info['description']}")
    print(f"   💡 Exemple: {info['exemple']}")
    print(f"   📝 Template de prompt disponible")

print(f"\n🎯 Avantages GPT-5 pour l'éducation:")
print(f"• **Multimodal** : Analyse texte + image simultanée")
print(f"• **Contextuel** : Comprend le niveau éducatif")
print(f"• **Adaptable** : Ajuste le vocabulaire selon l'audience")
print(f"• **Interactif** : Permet les questions de suivi")
print(f"• **Précis** : Analyse détaillée et factuelle")

print(f"\n📝 Exemple de workflow pédagogique:")
print(f"1. Sélection d'image pertinente au cours")
print(f"2. Analyse GPT-5 avec prompt éducatif")
print(f"3. Génération de questions pour les étudiants")
print(f"4. Discussion interactive basée sur l'analyse")
print(f"5. Évaluation de la compréhension")

🎓 CAS D'USAGE PÉDAGOGIQUES GPT-5
=============================================

📚 **Histoire**
   📋 Analyse de documents historiques, œuvres d'art, monuments
   💡 Exemple: Analyser une fresque renaissance pour comprendre le contexte social
   📝 Template de prompt disponible

📚 **Sciences**
   📋 Analyse d'expériences, schémas scientifiques, phénomènes naturels
   💡 Exemple: Expliquer un diagramme de cellule ou une réaction chimique
   📝 Template de prompt disponible

📚 **Géographie**
   📋 Étude de paysages, cartes, phénomènes géologiques
   💡 Exemple: Analyser une photo satellite ou un paysage géographique
   📝 Template de prompt disponible

📚 **Art et Culture**
   📋 Critique artistique, analyse stylistique, histoire de l'art
   💡 Exemple: Comprendre les techniques d'un tableau impressionniste
   📝 Template de prompt disponible

📚 **Médecine**
   📋 Analyse d'imagerie médicale, anatomie, cas cliniques
   💡 Exemple: Expliquer une radiographie ou un schéma anatomique
   📝 Template de prompt disponible

🎯 Avantages GPT-5 pour l'éducation:
• **Multimodal** : Analyse texte + image simultanée
• **Contextuel** : Comprend le niveau éducatif
• **Adaptable** : Ajuste le vocabulaire selon l'audience
• **Interactif** : Permet les questions de suivi
• **Précis** : Analyse détaillée et factuelle

📝 Exemple de workflow pédagogique:
1. Sélection d'image pertinente au cours
2. Analyse GPT-5 avec prompt éducatif
3. Génération de questions pour les étudiants
4. Discussion interactive basée sur l'analyse
5. Évaluation de la compréhension

🎯 Résumé et Bonnes Pratiques

✅ Ce que vous avez appris

🚀 Prochaines étapes

  1. Expérimentez avec vos propres images éducatives
  2. Testez différents niveaux d’analyse selon votre public
  3. Intégrez GPT-5 dans vos workflows pédagogiques
  4. Combinez avec DALL-E 3 pour génération + analyse
  5. Explorez les notebooks avancés (Module 02)

💡 Conseils pour l’utilisation

✅ Bonnes pratiques: - Utilisez des images de haute qualité - Adaptez le prompt au niveau éducatif - Combinez analyse visuelle et contextuelle - Générez des questions pédagogiques - Sauvegardez les analyses réussies

❌ Évitez: - Images trop petites ou de mauvaise qualité - Prompts vagues ou génériques - Oublier le contexte éducatif - Ignorer les limitations du modèle - Ne pas vérifier la factualité

🔗 Ressources complémentaires

  • Documentation OpenRouter : openrouter.ai
  • Guide GPT-5 : Capacités multimodales
  • Templates éducatifs : docs/genai-phase2-templates.md
  • Standards CoursIA : docs/genai-images-development-standards.md

📖 Références savantes

  • OpenAI (2025). GPT-5 System Card & Model Page. — Modèle multimodal (texte + vision), fenêtre de contexte 400 000 tokens, 128 000 tokens de sortie maximum. Sources officielles : openai.com/gpt-5/ et developers.openai.com/api/docs/models/gpt-5.
  • OpenAI (2024). GPT-4o System Card. — Précurseur multimodal de GPT-5 (vision + texte unifiés), base de l’API multimodale utilisée via OpenRouter dans ce notebook.

Lecture du résultat — ce que la cellule suivante présente vraiment

Le print('Cas d'usage pédagogiques') précédent est un catalogue statique, pas une exécution. Les cinq domaines listés sont là pour donner à l’étudiant un point de départ structuré — chaque prompt_template est immédiatement réutilisable via analyze_image_with_gpt5(image, prompt=...), sans avoir à le réécrire. Le print('Template de prompt disponible') est l’indice que la cellule a déjà joué son rôle pédagogique au moment où l’étudiant l’a lue, même si rien n’a été exécuté.

Trois choses à retenir pour la cellule de résumé : 1. L’API OpenRouter expose 26 modèles GPT-5 distincts — la nomenclature est plus large que la nomenclature OpenAI officielle, et la sélection se fait sur le compromis contexte × coût × capabilities (vision, tools, etc.). 2. Les trois modes d’analyse (quick/detailed/educational) ne sont pas interchangeables : quick est optimisé pour l’alt-text WCAG, educational produit des questions de guidage de l’élève — c’est le seul mode qui fournit un livrable pédagogique clé en main. 3. Le pipeline multimodal (encode → POST → parse) est uniforme quelle que soit l’image — la complexité se trouve dans le prompt, pas dans le transport.

Exercice 3 : Synthèse — Workflow d’analyse multimodale complet

Durée estimée : 15-20 minutes

Objectif

Créer un workflow d’analyse d’image personnalisé avec GPT-5 pour un cas d’usage pédagogique spécifique (histoire, sciences, géographie, art, ou médecine).

Instructions

  1. Choisir un domaine parmi les 5 cas d’usage pédagogiques présentés dans le notebook
  2. Sélectionner une image pertinente pour ce domaine (URL publique ou image locale)
  3. Créer un prompt personnalisé adapté au niveau éducatif visé
  4. Implémenter une fonction d’analyse qui combine les 3 modes (quick, detailed, educational)
  5. Générer les questions pédagogiques que GPT-5 suggère pour les étudiants

Indices :

  • Indice 1 : Utilisez la fonction analyze_image_with_gpt5() avec le paramètre prompt pour votre prompt personnalisé
  • Indice 2 : Le mode “educational” génère automatiquement 3 questions de réflexion pour étudiants
  • Indice 3 : Adaptez le vocabulaire du prompt au niveau (elementary, secondary, university)
# TODO: Implémentez l'analyse personnalisée pour votre domaine

# 1. Sélection du domaine et configuration
domain = "..."  # "Histoire", "Sciences", "Géographie", "Art", "Médecine"
niveau = "university"  # Niveau éducatif cible

# 2. Image à analyser (choisir une URL ou chemin local)
image_source = "https://images.unsplash.com/photo-..."  # Remplacer par votre image

# 3. Création du prompt personnalisé
# Indice: Inspirez-vous des templates dans educational_use_cases
custom_prompt = f"""Tu es un professeur expert en {domain}.
Analyse cette image pour des étudiants de niveau {niveau}.
Inclus :
1. Description accessible du sujet
2. Éléments techniques importants à observer
3. Contexte historique ou scientifique
4. 3 questions de réflexion pour les étudiants
"""

# 4. Implémenter l'analyse avec les 3 modes
# Indice: Utilisez analyze_image_with_gpt5() avec analysis_type et prompt
def analyse_complete(image_url, prompt, domain):
    """
    Analyse une image avec les 3 modes et retourne les résultats.
    
    Args:
        image_url: URL ou chemin de l'image
        prompt: Prompt personnalisé pour le mode educational
        domain: Domaine d'étude pour le contexte
    
    Returns:
        Dict avec les 3 analyses (quick, detailed, educational)
    """
    results = {}
    
    # TODO: Implémentez les 3 analyses
    # - Mode quick pour une vue d'ensemble
    # - Mode detailed pour l'analyse technique
    # - Mode educational avec votre prompt personnalisé
    
    pass  # Remplacer par votre implémentation
    
    return results

# 5. Exécuter l'analyse et afficher les résultats
# Indice: Utilisez pprint.json pour un affichage lisible des résultats
pass

Critères de succès

Extension (optionnelle)

Pour les étudiants avancés : - Ajouter une fonction de comparaison entre 2 images du même domaine - Implémenter une évaluation des réponses étudiant avec GPT-5 - Créer un quiz interactif basé sur les questions générées

Lecture du résultat — exercice 3 (synthèse)

La cellule précédente pose un exercice de synthèse structurant : choisir un domaine parmi les cinq catalogueés en cellule 24, sélectionner une image, construire un prompt personnalisé, et implémenter une fonction analyse_complete() qui appelle les trois modes en séquence. Le squelette fourni est pass — le code est volontairement non rempli pour respecter C.1 (pas d’erreur volontaire). C’est exactement le genre d’exercice où la densité des cellules markdown environnantes est précieuse : l’étudiant a sous les yeux la signature de analyze_image_with_gpt5(), les trois modes documentés, et les critères de succès en cellule 28 ci-dessous, sans avoir à naviguer entre sections.

Conclusion

GPT-5 image generation (via OpenRouter) incarne l’approche multimodale native : le modèle ne se contente pas de générer des images à partir d’un prompt texte, il analyse et produit dans un même flux, ce qui ouvre trois modes d’usage pédagogique distincts — quick (206 chars), detailed (2606 chars), educational (2908 chars). Le ratio coût d’inférence / richesse du contenu est directement exposé à l’utilisateur par le choix du mode.

Apport spécifique de la multimodalité native : la génération automatique d’alt text (114 chars optimal, sous le seuil 125 chars des référentiels d’accessibilité WCAG) intègre la description d’image comme livrable de première classe, pas comme un post-traitement optionnel. Pour les 5 cas d’usage éducatif couverts (Histoire, Sciences, Géographie, Art et Culture, Médecine), c’est un gain d’accessibilité substantiel par rapport aux modèles purement text-to-image.

Positionnement dans l’écosystème : GPT-5 complète la palette du cours en couvrant l’axe compréhension + génération, là où DALL-E 3 se concentre sur la génération seule et où SD XL Turbo expose les rouages internes. Les 26 modèles GPT-5 détectés via l’API OpenRouter ouvrent un terrain d’expérimentation comparative large mais introduisent une dépendance forte au fournisseur de route.

Pour aller plus loin : explorer le notebook 04-1-Educational-Content-Generation qui orchestre plusieurs modèles pour produire un livrable pédagogique complet (image + alt text + métadonnées structurées).

Retour au sommet