IA multimodale
L'IA peut non seulement parler, mais aussi voir des images, entendre des sons et comprendre des vidéos—maîtrisez les outils et technologies multimodales.
Pendant longtemps, l'IA était monosensorielle.
L'IA textuelle ne pouvait traiter que du texte, comme demander à ChatGPT d'écrire des articles.
-
L'IA visuelle ne pouvait traiter que des images, comme demander à Midjourney de dessiner des images.
-
L'IA audio ne pouvait traiter que du son, comme demander à Whisper de transcrire la parole.
Mais le monde réel est multimodal—quand nous lisons des livres, nous voyons des illustrations, quand nous regardons des films, il y a des images et du son, et quand nous communiquons avec les autres, nous observons les expressions et le ton.
L'IA multimodale est une IA capable de comprendre et de générer simultanément plusieurs types de contenu, comme donner à l'IA des yeux, des oreilles et une bouche, lui permettant d'interagir avec le monde d'une manière plus proche des humains.
Un exemple concret : vous donnez à l'IA une photo d'un ticket de caisse, elle peut reconnaître le texte qu'il contient (OCR), comprendre quels articles ont été achetés, vous aider à l'organiser dans un tableau, et même vous le lire à voix haute. C'est une tâche multimodale typique.
Qu'est-ce que l'IA multimodale
D'abord, clarifions quelques concepts de base.
Monomodal vs multimodal
La modalité désigne la forme sous laquelle l'information est exprimée.
Le texte, les images, l'audio et la vidéo sont toutes des modalités différentes.
| Type | Description | Produits typiques |
|---|---|---|
| IA monomodale | Ne peut traiter qu'une seule modalité | GPT-3 initial (texte uniquement), Stable Diffusion (images uniquement) |
| IA multimodale | Peut traiter plusieurs modalités simultanément | GPT-4o, Claude 3, Gemini |
La percée fondamentale de l'IA multimodale réside dans :Elle peut convertir des informations provenant de différentes modalités en un langage commun pour la compréhension。
Par exemple, lorsqu'elle voit une image d'un « chat », elle peut convertir l'image en un vecteur (un ensemble de nombres) ; lorsqu'elle voit le mot « chat », elle peut aussi le convertir en un vecteur. Ces deux vecteurs sont proches dans l'espace mathématique parce qu'ils représentent le même concept.
Principaux défis de l'IA multimodale
La multimodalité semble simple, mais en pratique, elle est très difficile.
Le premier défi est l'« alignement » — comment faire en sorte que le « chat » dans une image et le « chat » dans un texte apparaissent comme la même chose pour le modèle ?
-
Le deuxième défi est la « fusion » — lorsque l'on voit en même temps une image et un texte, comment combiner leurs informations ?
-
Le troisième défi est la « génération » — comment générer une image à partir d'une description textuelle, ou générer une description textuelle à partir d'une image ?
-
Heureusement, ces problèmes sont progressivement résolus. À partir de 2024, presque tous les principaux grands modèles sont multimodaux.
Compréhension des images (vision)
La compréhension des images consiste à faire en sorte que l'IA comprenne les images — décrire le contenu, reconnaître le texte, analyser des graphiques et repérer les détails.
Les principaux grands modèles prennent désormais en charge l'entrée d'images.
Il existe généralement deux façons de l'utiliser :
L'une consiste à téléverser directement le fichier image, par exemple en cliquant sur l'icône d'image dans la version web de ChatGPT pour le téléverser.
-
Une autre façon consiste à intégrer l'image dans la requête API en utilisant l'encodage Base64, adapté aux appels programmatiques.
| Modèle | Méthodes d'entrée d'image | Formats d'image pris en charge |
|---|---|---|
| GPT | URL, Base64, téléversement direct | JPG、PNG、WEBP、GIF |
| Claude | Base64, téléversement direct | JPG、PNG、WEBP、GIF |
| Gemini | Téléversement direct, Google Drive | JPG、PNG、WEBP |
Les tâches de vision courantes comprennent :
Description d'image — Qu'y a-t-il sur cette image ?
-
OCR — Extraire le texte d'une image.
-
Analyse de graphique — Que nous dit ce diagramme à barres ?
-
Détection des détails — Aidez-moi à vérifier cette maquette pour détecter des problèmes.
Mise en pratique : Appeler l'API GPT-4o Vision avec Python
Regardons un exemple complet — utiliser l'API pour analyser une image.
Exemple
# Fichier : example_vision_demo.py
# Fonction : Analyser des images avec l'API GPT-4o Vision
# ============================================
import base64
import requests
import os
# Configurer la clé API (veuillez la remplacer par votre vraie clé)
# Obtenez-la ici : https://platform.openai.com/api-keys
OPENAI_API_KEY = "sk-your-api-key-here"
OPENAI_API_URL = "https://api.openai.com/v1/chat/completions"
def encode_image_to_base64(image_path: str) -> str:
"""
Encoder le fichier image local en une chaîne Base64
C'est le format de transfert requis par l'API
"""
with open(image_path, "rb") as image_file:
# Lire le contenu binaire du fichier et l'encoder en Base64
base64_data = base64.b64encode(image_file.read()).decode("utf-8")
return base64_data
def analyze_image_with_gpt4o(
image_path: str,
prompt: str = "Veuillez décrire en détail le contenu de cette image.",
model: str = "gpt-4o"
) -> str:
"""
Utilisez l'API GPT-4o Vision pour analyser l'image
Description du paramètre :
image_path : Chemin du fichier image local (par exemple, "example_test.jpg")
prompt : La question que vous souhaitez poser ou la tâche que vous souhaitez que l’IA accomplisse
model : Nom du modèle à utiliser (par défaut gpt-4o)
Retourne :
Texte du résultat d’analyse de l’IA
"""
# Étape 1 : Encoder l’image en Base64
base64_image = encode_image_to_base64(image_path)
# Étape 2 : Construire les en-têtes de la requête
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
# Étape 3 : Construire le corps de la requête
# Remarque : Le contenu de l’image est transmis via le champ image_url, au format "data:image/jpeg;base64,..."
payload = {
"model": model,
"messages": [
{
"role": "user",
"content": [
# La première partie est le prompt textuel
{"type": "text", "text": prompt},
# La deuxième partie est l'image
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{base64_image}"
}
}
]
}
],
"max_tokens": 1000 # Limiter la longueur de sortie pour éviter des coûts élevés
}
# Étape 4 : Envoyer la requête API
print(f"Analyse de l'image : {image_path} ...")
response = requests.post(OPENAI_API_URL, headers=headers, json=payload)
# Étape 5 : Traiter la réponse
if response.status_code == 200:
result = response.json()
# Extraire la réponse de l'IA
answer = result["choices"][0]["message"]["content"]
return answer
else:
# Afficher des informations détaillées sur l'erreur lorsqu'une erreur se produit
error_msg = f"Échec de la requête : {response.status_code} - {response.text}"
print(error_msg)
return error_msg
def extract_text_from_image(image_path: str) -> str:
"""
Spécialement pour l'OCR : Extraire le texte des images
"""
prompt = """
Veuillez extraire tout le contenu textuel de cette image.
Exigences :
1. Reproduisez fidèlement le texte, n'omettez rien
2. Conservez les paragraphes et la mise en forme d'origine
3. S'il y a des tableaux, affichez-les sous forme de tableau
4. S'il n'y a pas de texte dans l'image, veuillez l'indiquer
Ceci est le test OCR du tutoriel EXAMPLE.
"""
return analyze_image_with_gpt4o(image_path, prompt)
def analyze_chart(image_path: str) -> str:
"""
Spécialement pour l'analyse de graphiques
"""
prompt = """
Veuillez analyser ce graphique.
Veuillez répondre aux questions suivantes :
1. Quel type de graphique est-ce (diagramme à barres, graphique en courbes, diagramme circulaire, etc.) ?
2. Quels sont le titre du graphique et la signification des axes ?
3. Quel est le message principal véhiculé par le graphique ?
4. Y a-t-il des tendances ou des anomalies notables ?
Ceci est le test d'analyse de graphique du tutoriel EXEMPLE.
"""
return analyze_image_with_gpt4o(image_path, prompt)
# ============================================
# Programme principal : démonstration de différentes tâches d'analyse visuelle
# ============================================
if __name__ == "__main__":
# Supposons que nous ayons une image de test (vous devez préparer une vraie image)
# Cela peut être : photo de produit, capture d'écran, photo de document, graphique, etc.
test_image = "example_test_image.jpg"
# Vérifier si l'image existe
if not os.path.exists(test_image):
print(f"Astuce : Veuillez préparer une image, nommez-la {test_image} et placez-la dans le répertoire courant")
print("Ou modifiez le chemin de l'image dans le code")
else:
# Tâche 1 : Description générale de l'image
print("\n" + "="*50)
print("Tâche 1 : Description de l'image")
print("="*50)
result1 = analyze_image_with_gpt4o(
test_image,
"Veuillez décrire cette image en détail, y compris le sujet, l'arrière-plan, les couleurs, la composition, etc."
)
print(result1)
# Tâche 2 : Extraction de texte par OCR
print("\n" + "="*50)
print("Tâche 2 : Extraction de texte OCR")
print("="*50)
result2 = extract_text_from_image(test_image)
print(result2)
# Tâche 3 : Analyse de graphique (si l'image est un graphique)
print("\n" + "="*50)
print("Tâche 3 : Analyse de graphique")
print("="*50)
result3 = analyze_chart(test_image)
print(result3)
print("\n" + "="*50)
print("Démo du tutoriel d'exemple terminée !")
print("="*50)
Avant d'exécuter ce programme, vous devez :
-
1. Installez les dépendances :
pip install requests -
2. Préparez une image de test et nommez-la
example_test_image.jpg -
3. Remplacez la clé API par la vôtre
Remarque sur les coûts : GPT-4o Vision est facturé en fonction de la taille de l'image. Une image de 1024x1024 coûte environ $0.00765. Les images plus petites sont moins chères. Pour le débogage, utilisez des images en basse résolution ; pour la production, utilisez la haute résolution.
Texte-vers-Image
Texte-vers-Image permet à l'IA de générer des images à partir de descriptions textuelles. C'est un autre domaine d'application multimodal très mature.
Introduction aux principes des modèles de diffusion
Les outils texte-vers-image d'aujourd'hui utilisent essentiellement la technologie des modèles de diffusion.
Une façon simple de comprendre comment cela fonctionne :
Phase d'entraînement : Montrez au modèle une image nette, puis ajoutez-lui progressivement du bruit jusqu'à ce qu'elle devienne une image complètement bruitée. Le modèle apprend à retransformer l'image bruitée en une image nette, étape par étape.
-
Phase de génération : Donnez au modèle une image de bruit aléatoire et laissez-le débruiter étape par étape en fonction de l'invite textuelle, pour finalement générer une image nette qui correspond à la description.
Ce processus prend généralement 20-50 étapes, donc générer une image prend quelques secondes.
Conseils avancés pour l'utilisation de Midjourney
Midjourney est actuellement l'un des outils texte-vers-image les plus populaires, utilisé via Discord.
Une invite de haute qualité comprend généralement ces éléments :
-
Description du sujet — "un chat portant un chapeau"
-
Style — "style Studio Ghibli", "peinture à l'huile", "rendu 3D"
-
Éclairage — "lumière naturelle", "éclairage cinématographique", "néons cyberpunk"
-
Composition — "gros plan", "grand angle", "vue de dessus"
-
Qualité — "8K", "ultra détaillé", "qualité photographique"
| Paramètre | Description | Exemple |
|---|---|---|
| --ar | Définir le rapport d'aspect | --ar 16:9 (vidéo), --ar 3:4 (mobile) |
| --v | Spécifier la version du modèle | --v 6.0 (version la plus récente) |
| --s | Niveau de stylisation (0-1000) | --s 750 (forte sensation artistique) |
| --q | Qualité de rendu (0.25-2) | --q 2 (qualité supérieure, plus lent) |
| --iw | Poids de l'image de référence | --iw 1.5 (plus proche de l'image de référence) |
Déploiement local de Stable Diffusion
Si vous voulez un contrôle total, vous pouvez exécuter Stable Diffusion localement :https://github.com/compvis/stable-diffusion。
L'outil le plus couramment utilisé est le WebUI d'Automatic1111.
Les étapes sont approximativement :
-
1. Installer Python 3.10
-
2. Télécharger Stable Diffusion WebUI
-
3. Télécharger le fichier de modèle (format .safetensors)
-
4. Exécutez webui.bat (Windows) ou webui.sh (Mac/Linux)
Avantages du déploiement local : la génération est gratuite, sans restrictions de contenu, vous pouvez utiliser LoRA pour affiner les styles, et utiliser ControlNet pour un contrôle précis de la composition.
Inconvénients : vous avez besoin d'un GPU avec au moins 6GB de VRAM, et la configuration est quelque peu compliquée.
Mise en pratique : Générer des images avec l'API DALL·E 3
Si vous voulez un moyen simple via l'API pour générer des images, DALL·E 3 est un bon choix.
Exemple
# Fichier : example_dalle3_demo.py
# Fonction : Générer des images avec l'API DALL·E 3
# ============================================
import requests
import os
from datetime import datetime
# Configurez la clé API (veuillez la remplacer par votre véritable clé)
OPENAI_API_KEY = "sk-your-api-key-here"
DALLE3_API_URL = "https://api.openai.com/v1/images/generations"
def generate_image_with_dalle3(
prompt: str,
size: str = "1024x1024",
quality: str = "standard",
style: str = "vivid",
save_dir: str = "example_generated_images"
) -> dict:
"""
Génération d'images avec l'API DALL·E 3
Description des paramètres :
prompt: description textuelle, plus elle est détaillée, mieux c'est
size: taille de l'image
Options : 1024x1024, 1024x1792 (portrait), 1792x1024 (paysage)
quality: qualité de l'image
Options : standard (standard), hd (haute définition, plus coûteux)
style: style
Facultatif : vivid (vif, plus artistique), natural (naturel, plus réaliste)
save_dir: répertoire d'enregistrement des images
Retourne :
Un dictionnaire contenant l'URL de l'image et le chemin de sauvegarde
"""
# Étape 1 : Préparer les en-têtes de la requête
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
# Étape 2 : Préparer le corps de la requête
payload = {
"model": "dall-e-3",
"prompt": invite,
"n": 1, # DALL·E 3 ne peut générer qu'1 image à la fois
"size": size,
"quality": quality,
"style": style
}
# Étape 3 : Envoyer la requête
print(f"Génération de l'image, prompt : {prompt[:50]}...")
response = requests.post(DALLE3_API_URL, headers=headers, json=payload)
# Étape 4 : Traiter la réponse
if response.status_code == 200:
result = response.json()
image_url = result["data"][0]["url"]
revised_prompt = result["data"][0].get("revised_prompt", prompt)
print(f"Invite auto-optimisée DALL·E 3 : {revised_prompt}")
# Étape 5 : Télécharger et enregistrer l'image
if not os.path.exists(save_dir):
os.makedirs(save_dir)
# Générer un nom de fichier à l'aide d'un horodatage
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f"example_dalle3_{timestamp}.png"
filepath = os.path.join(save_dir, filename)
# Télécharger l'image
image_response = requests.get(image_url)
if image_response.status_code == 200:
with open(filepath, "wb") as f:
f.write(image_response.content)
print(f"Image enregistrée dans : {filepath}")
return {
"image_url": image_url,
"filepath": filepath,
"revised_prompt": revised_prompt
}
else:
error_msg = f"Échec de la requête : {response.status_code} - {response.text}"
print(error_msg)
return {"error": error_msg}
def generate_example_logo_demo():
"""Démo : Générer un logo de style EXAMPLE"""
prompt = """
Une mascotte robot mignonne et amicale pour le site de tutoriel EXAMPLE.
Palette de couleurs bleu et vert, design plat moderne, fond blanc.
Le robot semble serviable et intelligent, avec de grands yeux amicaux.
Simple, épuré, adapté à une marque d'éducation technologique.
"""
# Les invites en chinois fonctionnent aussi ; DALL·E 3 prend en charge plusieurs langues
prompt = """
Concevez une mascotte robot mignonne et amicale pour le site de tutoriels EXAMPLE.
Palette de couleurs bleu-vert, design plat moderne, fond blanc.
Le robot semble serviable et intelligent, avec de grands yeux amicaux.
Simple et épuré, adapté à une marque d'éducation technologique.
"""
return generate_image_with_dalle3(
prompt=prompt,
size="1024x1024",
quality="hd",
style="vivid"
)
def generate_book_cover_demo():
"""Démo : Générer une couverture de livre"""
prompt = """
Conception de couverture de livre pour "Tutoriel d'IA pour débutants".
Style minimaliste moderne, arrière-plan dégradé bleu profond et violet.
Le texte du titre est élégant et lisible.
Éléments technologiques subtils : formes géométriques flottantes, motifs de circuits discrets.
Professionnel, digne de confiance, adapté à un livre de programmation.
"""
return generate_image_with_dalle3(
prompt=prompt,
size="1024x1792", # Orientation portrait
quality="hd",
style="natural"
)
def generate_banner_demo():
"""Démo : Générer une bannière publicitaire"""
prompt = """
Conception de bannière web pour un site de tutoriels de programmation (EXEMPLE).
Format large 16:9. Arrière-plan dégradé moderne du bleu sarcelle au bleu.
Mise en page épurée avec de l'espace pour le texte.
Éléments technologiques abstraits : extraits de code flottants, lignes de grille subtiles.
Professionnel et accueillant.
"""
return generate_image_with_dalle3(
prompt=prompt,
size="1792x1024", # Orientation paysage
quality="standard",
style="vivid"
)
# ============================================
# Programme principal : démontrer différentes tâches de génération
# ============================================
if __name__ == "__main__":
print("="*60)
print("EXEMPLE : Démo de génération d'images DALL·E 3")
print("="*60)
# Tâche 1 : générer le logo
print("\n[Tâche 1] Génération du logo ...")
result1 = generate_example_logo_demo()
# Tâche 2 : générer la couverture de livre
print("\n[Tâche 2] Génération de la couverture de livre ...")
result2 = generate_book_cover_demo()
# Tâche 3 : Générer une bannière
print("\n[Tâche 3] Génération de la bannière ...")
result3 = generate_banner_demo()
print("\n" + "="*60)
print("Toutes les tâches sont terminées ! Vérifiez le répertoire example_generated_images")
print("="*60)
Points forts de DALL·E 3 : bonne compréhension, ne casse pas les mains et les visages, et génère bien le texte.
Mais il a aussi des limites : il ne peut générer qu'une seule image à la fois, ne peut pas contrôler précisément le style et ne peut pas être affiné comme Stable Diffusion.
Mention de droits d'auteur : Le consensus actuel est que, pour les images générées par IA, l'auteur du prompt dispose de droits d'utilisation mais ne détient pas les droits d'auteur (car les offices de droit d'auteur exigent une création humaine). Pour une utilisation commerciale, il est recommandé de vérifier les conditions d'utilisation de l'outil.
IA vidéo
L'IA vidéo est divisée en deux catégories : la génération de vidéos et la compréhension de vidéos.
Par rapport aux images, la vidéo est techniquement plus difficile — car la vidéo est une combinaison de "temps + espace," exigeant que chaque image soit cohérente et que les mouvements paraissent naturels.
Comparaison des outils de génération vidéo par IA
2024 a été la première année de la vidéo IA, avec plusieurs entreprises lançant des produits de génération vidéo.
| Outil | Développeur | Fonctionnalités | Durée typique |
|---|---|---|---|
| Sora | OpenAI | Détail d'image et compréhension spatiale des scènes de pointe, logique physique réaliste, pas encore entièrement ouvert en bêta publique | Jusqu'à 60 secondes |
| Runway Gen-4 | Runway | Plateforme de création tout-en-un, intégrant texte/image-vers-vidéo, post-édition IA, pinceau de mouvement et effets VFX ; le premier choix des créateurs professionnels à l'étranger | 10–20 secondes |
| Kling (Keling AI) | Kuaishou | Excellente adaptation aux invites en chinois, mouvements de personnages fluides, personnages stables d'un plan à l'autre, très bon rapport coût-efficacité en Chine, prend en charge l'assemblage narratif multi-segments | 5–30 secondes, jusqu’à 2 minutes par segment |
| Pika | Pika Labs | Extrêmement expressif dans les styles d’anime et d’illustration cinématographique, conception de personnages cohérente, prend en charge le redessin de style vidéo et l’interpolation d’images | 5–10 secondes |
| Veo | Éclairage cinématographique et mouvement de caméra, narration stable en plan-séquence, rendu physique naturel, pas encore rendu public | Plus de 60 secondes | |
| Jimeng AI (Seedance) | ByteDance | Intégration profonde avec l’écosystème CapCut/Douyin, compréhension sémantique précise du chinois, synchronisation labiale audiovisuelle, prend en charge la création automatique de storyboards à partir de scripts | 5–15 secondes, plusieurs segments assemblés pour former un film complet |
| Tongyi Wanxiang Video | Alibaba DAMO Academy | Modèle de base ouvert, interaction multi-sujets stable, génération de texte dans les images, peut être déployé localement pour l'inférence. | 2–15 secondes |
| Hailuo AI (Hailuo) | MiniMax (Xiyu) | Génération ultra-rapide et légère ; adaptée à la conversion d'affiches en vidéos courtes dynamiques et en contenus flash pour les réseaux sociaux, avec un rendu de style anime exceptionnel. | 4–10 secondes |
| Luma Dream Machine | Luma AI | Simulation de dynamique physique de premier ordre ; effets réalistes pour l'eau, le feu, le tissu et les explosions, mouvement de caméra cinématographique. | 5–12 secondes |
| Zhiying | Tencent | Met l'accent sur le montage IA et les vidéos d'humains numériques, avec une immense bibliothèque de modèles de vidéos courtes, des sous-titres, du doublage et du détourage tout-en-un, et de faibles barrières commerciales. | Aucune limite sur la durée de la vidéo ; les clips générés par IA font 5–15 secondes. |
| Haiyi AI | Haiyi Technology | Prend en charge la sortie 4K/60fps à fréquence d'images élevée, la génération de vidéos liées à partir de plusieurs images, est livré avec une station de travail de production complète et offre un généreux quota gratuit à durée limitée. | Un seul segment jusqu'à 30 secondes. |
La vidéo par IA n'en est encore qu'à ses débuts :
-
Avantages : créativité rapide, faible coût et capacité à obtenir des effets très difficiles à réaliser en prises de vues réelles.
-
Inconvénients : durée limitée, détails qui se dégradent facilement et logique physique parfois incorrecte (par ex., des objets qui se traversent, un nombre de doigts erroné).
-
Scénarios adaptés : démonstrations de concepts, contenu de vidéos courtes, publicités e-commerce, animations de jeu.
-
Scénarios inadaptés : longs métrages nécessitant un contrôle précis, actualités sérieuses, preuves juridiques.
Compréhension et résumé de vidéos
Outre la génération de vidéos, l’IA peut aussi comprendre les vidéos.
Tâches courantes en compréhension vidéo :
-
Résumé vidéo — « De quoi parle cette vidéo ? Résume en 3 phrases. »
-
Recherche de contenu — « Trouve l’extrait dans la vidéo où quelqu’un fait du vélo. »
-
Réponse aux questions — « Qu’a dit la troisième personne dans la vidéo ? »
L’approche technique typique consiste à : extraire des images de la vidéo (par ex., 1 image par seconde), puis utiliser un modèle de vision pour examiner chaque image une par une, et enfin intégrer les informations.
Tendances futures
La direction de développement de l’IA vidéo est claire :
-
Plus long — de 10 secondes à 1 minute, puis à 10 minutes.
-
Plus contrôlable — capable de contrôler précisément chaque plan à l’aide de storyboards.
-
Plus cohérent — le même personnage reste cohérent d’un plan à l’autre.
-
Plus pratique — de l’effet impressionnant à la résolution de problèmes réels.
-
À quoi s'attendre : dans quelques années, tout le monde pourra peut-être créer des œuvres vidéo de type cinématographique avec l'IA.
IA audio et parole
L'IA audio comprend principalement : la transcription parole-texte (ASR), la synthèse vocale (TTS) et la génération musicale.
C'est un domaine assez mature.
Transcription parole-texte (API Whisper)
Whisper est le modèle de reconnaissance vocale open source d'OpenAI. Il fonctionne très bien et prend en charge 99 langues.
Exemple
# Fichier : example_whisper_demo.py
# Fonction : Utiliser l'API Whisper pour transcrire la parole
# ============================================
import requests
import os
# Configurer la clé API
OPENAI_API_KEY = "sk-your-api-key-here"
WHISPER_API_URL = "https://api.openai.com/v1/audio/transcriptions"
def transcribe_audio_with_whisper(
audio_path: str,
language: str = "zh", # zh=chinois, en=anglais, laisser vide pour détection automatique
prompt: str = "", # Facultatif : fournir quelques indices terminologiques pour améliorer la précision
temperature: float = 0.0
) -> dict:
"""
Utiliser l'API Whisper pour transcrire des fichiers audio
Description du paramètre :
audio_path: chemin du fichier audio (prend en charge mp3, wav, m4a, etc.)
language: code de langue (facultatif, détecté automatiquement s'il n'est pas spécifié)
Codes courants : zh (chinois), en (anglais), ja (japonais)
prompt: texte de prompt (facultatif ; indiquez ici les éventuels termes techniques ou noms)
temperature: température d'échantillonnage (0.0 est le plus déterministe, 1.0 est plus diversifiée)
Retour :
Un dictionnaire contenant le texte transcrit
"""
# Étape 1 : Vérifier si le fichier existe
if not os.path.exists(audio_path):
return {"error": f"Fichier introuvable : {audio_path}"}
# Étape 2 : Préparer les en-têtes de la requête
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
# Étape 3 : Préparer le corps de la requête (remarque : l'audio doit utiliser le format multipart/form-data)
files = {
"file": open(audio_path, "rb")
}
data = {
"model": "whisper-1",
"temperature": temperature
}
if language:
data["language"] = language
if prompt:
data["prompt"] = prompt
# Étape 4 : Envoyer la requête
print(f"Transcription de l'audio : {audio_path} ...")
response = requests.post(WHISPER_API_URL, headers=headers, files=files, data=data)
# Étape 5 : Fermer le fichier
files["file"].close()
# Étape 6 : Traiter la réponse
if response.status_code == 200:
result = response.json()
text = result["text"]
print(f"Transcription terminée, un total de {len(text)} caractères.")
return {
"text": text,
"language": language
}
else:
error_msg = f"Échec de la requête : {response.status_code} - {response.text}"
print(error_msg)
return {"error": error_msg}
def transcribe_with_timestamps(audio_path: str) -> dict:
"""
Transcription horodatée (avec le format verbose_json)
"""
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
files = {"file": open(audio_path, "rb")}
data = {
"model": "whisper-1",
"response_format": "verbose_json", # Renvoie des informations détaillées, y compris les horodatages
"timestamp_granularities": ["segment", "word"] # Prend en charge les horodatages au niveau du segment et du mot
}
response = requests.post(WHISPER_API_URL, headers=headers, files=files, data=data)
files["file"].close()
if response.status_code == 200:
result = response.json()
return result
else:
return {"error": response.text}
def translate_audio_to_english(audio_path: str) -> dict:
"""
Traduire l'audio de n'importe quelle langue en texte anglais
"""
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
files = {"file": open(audio_path, "rb")}
data = {
"model": "whisper-1",
"task": "translate" # Spécifier explicitement : tâche de traduction
}
response = requests.post("https://api.openai.com/v1/audio/translations",
headers=headers, files=files, data=data)
files["file"].close()
if response.status_code == 200:
return response.json()
else:
return {"error": response.text}
def example_meeting_minutes_demo(audio_path: str) -> str:
"""
Atelier pratique : génération de compte rendu de réunion
Étape 1 : Transcrire l'enregistrement avec Whisper
Étape 2 : Organiser sous forme de compte rendu avec GPT-4o
"""
# Transcrire d'abord
print("Étape 1 : Transcription de l'enregistrement de la réunion...")
transcribe_result = transcribe_audio_with_whisper(
audio_path,
language="zh",
prompt="Ceci est une réunion de l'équipe technique EXAMPLE, qui discute du développement produit, des avancées, des solutions techniques, etc."
)
if "error" in transcribe_result:
return transcribe_result["error"]
transcript = transcribe_result["text"]
# Puis organiser (simplifié ici ; dans un projet réel, vous pouvez appeler l'API GPT-4o)
print("Étape 2 : Organisation du compte rendu de la réunion...")
# À des fins de démonstration, renvoyer directement le texte de la transcription
# Dans un projet réel, vous pouvez envoyer la transcription à GPT-4o et lui demander de l'organiser
return transcript
# ============================================
# Programme principal
# ============================================
if __name__ == "__main__":
# Préparer un fichier audio de test
test_audio = "example_test_audio.mp3"
if not os.path.exists(test_audio):
print(f"Astuce : Préparez un fichier audio et nommez-le {test_audio}")
print("Ou enregistrez un mémo vocal sur votre téléphone et sauvegardez-le au format MP3")
else:
# Tâche 1 : Transcription simple
print("\n" + "="*50)
print("Tâche 1 : Transcription simple")
print("="*50)
result1 = transcribe_audio_with_whisper(test_audio, language="zh")
if "text" in result1:
print("Résultat de la transcription :")
print(result1["text"])
# Tâche 2 : Transcription horodatée
print("\n" + "="*50)
print("Tâche 2 : Transcription horodatée")
print("="*50)
result2 = transcribe_with_timestamps(test_audio)
if "segments" in result2:
print("Informations sur les segments :")
for seg in result2["segments"][:3]: # Afficher uniquement les 3 premiers segments
start = round(seg["start"], 2)
end = round(seg["end"], 2)
text = seg["text"]
print(f"[{start}-{end}] {text}")
print("\n" + "="*50)
print("EXEMPLE Démo Whisper terminée !")
print("="*50)
Les avantages de Whisper sont : un bon support multilingue, une grande tolérance aux accents et une ponctuation automatique.
Scénarios d'application typiques : transcription d'enregistrements de réunion, génération de sous-titres vidéo, transcriptions de podcasts, journaux vocaux.
Synthèse vocale (TTS)
La synthèse vocale permet à l'IA de « lire » des articles.
OpenAI fournit également une API TTS prenant en charge plusieurs styles de voix.
Autres outils TTS : ElevenLabs (le plus proche de l'humain), Azure TTS (de qualité professionnelle), Edge TTS (gratuit), Coqui (open source).
Génération musicale (Suno, Udio)
La génération musicale a également connu des percées.
Suno et Udio sont deux produits représentatifs — vous saisissez des paroles et des descriptions de style, et ils peuvent générer une chanson complète avec voix et accompagnement.
Limites des capacités :
-
Peut faire : générer de la musique de fond, écrire des démos de chansons, essayer rapidement des styles.
-
Limité dans : reproduire entièrement une chanson spécifique, contrôler précisément les notes, post-production de qualité professionnelle.
-
Droits d'auteur : les conditions varient selon l'outil ; veuillez vérifier avant toute utilisation commerciale.
Introduction aux architectures de modèles multimodaux
Comprendre un peu la théorie vous aide à mieux utiliser les outils.
CLIP : la base de l'alignement image-texte
CLIP (Contrastive Language-Image Pre-training) est un modèle publié par OpenAI en 2021.
Son idée est simple : regarder simultanément des images et du texte, et apprendre à les associer.
Pendant l'entraînement, donnez au modèle un lot de paires deimage + description, et laissez-le apprendre :
-
1. Convertir les images en vecteurs
-
2. Convertir le texte en vecteurs
-
3. Rendre les vecteurs image-texte appariés aussi proches que possible, et les non appariés aussi éloignés que possible.
L'importance de CLIP réside dans le fait que :il a prouvé que la « compréhension intermodale » est réalisable。
Les modèles ultérieurs comme Stable Diffusion et GPT-4o se sont tous inspirés de CLIP.
LLaVA : LLM multimodal open source
LLaVA (Large Language and Vision Assistant) est un modèle multimodal open source.
Son architecture est très claire :
-
Un encodeur visuel (par ex. ViT) — chargé de voir les images
-
Un grand modèle de langage (par ex. LLaMA) — chargé de parler
-
Une couche de projection — convertit les vecteurs d'image en un format que le modèle de langage peut comprendre
L'entraînement se fait en deux étapes :
-
Étape 1 : alignement de pré-entraînement — faire en sorte que l'encodeur visuel et le modèle de langage parlent la même langue
-
Étape 2 : affinage sur instructions - entraîner avec des données image-question-réponse pour lui apprendre à répondre selon les instructions
LLaVA est un bon point de départ pour apprendre la technologie multimodale - code open source, architecture claire, bons résultats.
Atelier pratique : création d'un outil d'analyse d'images
Intégrons les connaissances précédentes et construisons un outil pratique d'analyse d'images.
Exemple
# Fichier : example_image_analyzer.py
# Fonction : un outil complet d'analyse d'images multimodal
# ============================================
import base64
import requests
import os
import json
from datetime import datetime
from typing import Optional, Dict, Any
class ExampleImageAnalyzer:
"""
EXAMPLE Image Analyzer - une classe d'outil multimodal empaquetée
"""
def __init__(self, api_key: str, base_url: str = "https://api.openai.com/v1"):
"""
Initialiser l'analyseur
Paramètres :
api_key : clé API OpenAI
base_url : adresse de l'API (proxy configurable)
"""
self.api_key = api_key
self.base_url = base_url
self.headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {api_key}"
}
def _encode_image(self, image_path: str) -> str:
"""Encoder l'image en Base64"""
with open(image_path, "rb") as f:
return base64.b64encode(f.read()).decode("utf-8")
def _call_vision_api(
self,
image_path: str,
prompt: str,
model: str = "gpt-4o",
max_tokens: int = 2000
) -> Optional[str]:
"""Méthode interne : appeler l'API de vision"""
base64_image = self._encode_image(image_path)
payload = {
"model": model,
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": prompt},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}
}
]
}
],
"max_tokens": max_tokens
}
url = f"{self.base_url}/chat/completions"
response = requests.post(url, headers=self.headers, json=payload)
if response.status_code == 200:
return response.json()["choices"][0]["message"]["content"]
else:
print(f"Erreur API : {response.status_code} - {response.text}")
return None
def describe(self, image_path: str) -> Optional[str]:
"""Décrire le contenu de l'image en détail"""
prompt = """
Veuillez décrire cette image en détail, notamment :
1. Contenu principal (quels sont les personnes/objets présents)
2. Environnement en arrière-plan
3. Couleurs et éclairage
4. Ambiance générale
Répondez en chinois, avec une structure claire.
"""
return self._call_vision_api(image_path, prompt)
def extract_text(self, image_path: str) -> Optional[str]:
"""Extraire tout le texte de l'image (OCR)"""
prompt = """
Veuillez extraire tout le contenu textuel de cette image.
Exigences :
1. Reproduire fidèlement sans omission
2. Préserver la structure originale des paragraphes
3. S'il s'agit d'un tableau, le produire au format de tableau Markdown
4. S'il n'y a pas de texte, indiquer explicitement "Aucun texte reconnaissable dans l'image"
"""
return self._call_vision_api(image_path, prompt)
def analyze_ui(self, image_path: str) -> Optional[str]:
"""Analyser la maquette de conception UI (capture d'écran)"""
prompt = """
Veuillez analyser cette maquette de conception UI :
1. Quel type d'interface est-ce (APP, page web, mini-programme, etc.) ?
2. Quels sont les principaux modules fonctionnels de l'interface ?
3. Quel est le style de design (palette de couleurs, mise en page, typographie) ?
4. Que pourrait-on améliorer ?
Répondez en chinois, sous forme de points.
"""
return self._call_vision_api(image_path, prompt)
def analyze_product(self, image_path: str) -> Optional[str]:
"""Analyser les images produit et générer un texte commercial e-commerce"""
prompt = """
Veuillez analyser cette image de produit et générer un texte commercial e-commerce.
Le texte commercial doit inclure :
1. Nom et type du produit
2. Caractéristiques d'apparence (couleur, matière, design)
3. Une courte recommandation attrayante (30-50 caractères)
Répondez en chinois, avec un ton amical et positif.
"""
return self._call_vision_api(image_path, prompt)
def classify(self, image_path: str, categories: list = None) -> Optional[str]:
"""Classer l'image"""
if categories is None:
categories = [
"Photo de portrait", "Photo de paysage", "Photo de nourriture", "Photo de produit",
"Maquette de design/capture d'écran", "Document/tableau", "Graphique/visualisation de données", "Autre"
]
cat_list = "、".join(categories)
prompt = f"""
Veuillez déterminer à quelle catégorie appartient cette image.
Catégories facultatives : {cat_list}
Ne renvoyez que le nom de la catégorie correspondant le mieux, sans autre texte.
"""
return self._call_vision_api(image_path, prompt)
def full_analysis(self, image_path: str, output_dir: str = "example_analysis") -> Dict[str, Any]:
"""
Analyse complète : générer un rapport d'analyse détaillé
Retourne un dict contenant tous les résultats d'analyse
"""
print(f"Début de l'analyse de l'image : {image_path}")
# Classer d'abord
print("[1/5] Classification...")
category = self.classify(image_path) or "Inconnu"
# Description
print("[2/5] Description...")
description = self.describe(image_path) or ""
# Extraire le texte
print("[3/5] OCR en cours...")
text = self.extract_text(image_path) or ""
# Effectuer une analyse spécialisée en fonction de la catégorie
print("[4/5] Analyse spécialisée en cours...")
special_analysis = ""
if "design" in category or "screenshot" in category:
special_analysis = self.analyze_ui(image_path) or ""
elif "product" in category or "merchandise" in category:
special_analysis = self.analyze_product(image_path) or ""
# Enregistrer le rapport
print("[5/5] Génération du rapport...")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
report = {
"image_file": os.path.basename(image_path),
"analysis_time": datetime.now().isoformat(),
"category": category,
"description": description,
"extracted_text": text,
"special_analysis": special_analysis
}
# Enregistrer JSON
json_path = os.path.join(output_dir, f"report_{timestamp}.json")
with open(json_path, "w", encoding="utf-8") as f:
json.dump(report, f, ensure_ascii=False, indent=2)
# Enregistrer le texte lisible
txt_path = os.path.join(output_dir, f"report_{timestamp}.txt")
with open(txt_path, "w", encoding="utf-8") as f:
f.write("="*60 + "\n")
f.write("EXEMPLE Rapport d'analyse d'image\n")
f.write("="*60 + "\n\n")
f.write(f"Image : {report['image_file']}"\n")
f.write(f"Heure : {report['analysis_time']}"\n")
f.write(f"Catégorie : {report['category']}"\n\n")
f.write("-"*60 + "\n")
f.write("Description de l'image :\n")
f.write("-"*60 + "\n")
f.write(report["description"] + "\n\n")
f.write("-"*60 + "\n")
f.write("Texte extrait :\n")
f.write("-"*60 + "\n")
f.write(report["extracted_text"] + "\n\n")
if report["special_analysis"]:
f.write("-"*60 + "\n")
f.write("Analyse spéciale :\n")
f.write("-"*60 + "\n")
f.write(report["special_analysis"] + "\n")
print(f"Analyse terminée ! Rapport enregistré dans : {output_dir}")
return report
# ============================================
# Exemple d'utilisation
# ============================================
def main():
# Configurez votre clé API
api_key = "sk-your-api-key-here"
# Créer un analyseur
analyzer = ExampleImageAnalyzer(api_key)
# Chemin de l'image à analyser
image_path = "example_test_image.jpg"
if not os.path.exists(image_path):
print(f"Veuillez préparer l'image : {image_path}")
return
# Méthode 1 : Utiliser une seule fonction individuellement
print("\n"Méthode 1 : Utiliser uniquement l'OCR")
print("-"*40)
text = analyzer.extract_text(image_path)
if text:
print("Texte extrait :")
print(text)
# Méthode 2 : Analyse complète
print("\n"Méthode 2 : Analyse complète")
print("-"*40)
report = analyzer.full_analysis(image_path)
print(f"Résultat de classification : {report['category']}")
print(f"Rapport enregistré")
if __name__ == "__main__":
main()
Cet outil encapsule les fonctions courantes d'analyse d'images et peut être utilisé directement dans des projets.
Vous pouvez l'étendre selon vos besoins :
Ajouter davantage de scénarios d'analyse (par ex., imagerie médicale, inspection industrielle, analyse de questions pédagogiques)
-
Ajouter une interface web simple (en utilisant Flask ou Gradio)
-
Prendre en charge le traitement par lots des images dans des dossiers
-
Stocker les résultats dans une base de données