Systèmes d’IA multimodale : analyse d’images, de texte et d’audio

L’IA multimodale désigne des systèmes d’intelligence artificielle capables de comprendre et de traiter plusieurs types de données (texte, image, audio, vidéo). Des modèles comme GPTV, Gemini et Claude 3 ont ouvert de nouvelles perspectives dans ce domaine.

Fondamentaux de l’IA multimodale

Types de modalités

1. Texte : langage naturel, code, données structurées
2. Vision : photo, schéma, capture d’écran
3. Audio : voix, musique, sons environnementaux
4. Vidéo : combinaison d’images animées + audio

Pourquoi la multimodalité ?

• La communication humaine est intrinsèquement multimodale
• Perte d’informations contextuelles avec une seule modalité
• Extraction de sens plus riche
• Pertinence pour les applications réelles

Modèles vision-langage

Approches architecturales

1. Apprentissage contrastif (type CLIP)

1Image Encoder → Image Embedding
2Text Encoder → Text Embedding
3Contrastive Loss: Match(image, text)

2. Génératif (type GPTV)

Image → Vision Encoder → Visual Tokens
Visual Tokens + Text Tokens → LLM → Response

3. Fusion par cross-attention

Image Features ←Cross-Attention→ Text Features

Types d’encodeurs de vision

Tokenisation d’images

Patch Embedding :

224×224 image → 14×14 patch grid → 196 visual tokens
Each patch: 16×16 pixel → Linear projection → Embedding

Résolution variable :

1Anyres approach:
21. Divide image into tiles
32. Encode each tile separately
43. Add global thumbnail
54. Concatenate all tokens

Implémentation d’un LLM multimodal

Utilisation de GPTV

1from openai import OpenAI
2import base64
3
4client = OpenAI()
5
6def encode_image(image_path):
7    with open(image_path, "rb") as f:
8        return base64.b64encode(f.read()).decode('utf-8')
9
10response = client.chat.completions.create(
11    model="gpt-4-vision-preview",
12    messages=[
13        {
14            "role": "user",
15            "content": [
16                {"type": "text", "text": "Analyze this image"},
17                {
18                    "type": "image_url",
19                    "image_url": {
20                        "url": f"data:image/jpeg;base64,{encode_image('image.webp')}",
21                        "detail": "high"  # low, high, auto
22                    }
23                }
24            ]
25        }
26    ],
27    max_tokens=1000
28)

Claude 3 Vision

1from anthropic import Anthropic
2import base64
3
4client = Anthropic()
5
6with open("image.webp", "rb") as f:
7    image_data = base64.standard_b64encode(f.read()).decode("utf-8")
8
9message = client.messages.create(
10    model="claude-3-opus-20240229",
11    max_tokens=1024,
12    messages=[
13        {
14            "role": "user",
15            "content": [
16                {
17                    "type": "image",
18                    "source": {
19                        "type": "base64",
20                        "media_type": "image/jpeg",
21                        "data": image_data
22                    }
23                },
24                {"type": "text", "text": "What is in this image?"}
25            ]
26        }
27    ]
28)
29## Traitement Audio
30
31### Speech-to-Text (STT)
32
33**Modèle Whisper :**
34```python
35from openai import OpenAI
36
37client = OpenAI()
38
39with open("audio.mp3", "rb") as audio_file:
40    transcript = client.audio.transcriptions.create(
41        model="whisper-1",
42        file=audio_file,
43        language="en"
44    )
45    
46print(transcript.text)

Text-to-Speech (TTS)

1response = client.audio.speech.create(
2    model="tts-1-hd",
3    voice="alloy",  # alloy, echo, fable, onyx, nova, shimmer
4    input="Hello, I am an AI assistant."
5)
6
7response.stream_to_file("output.mp3")

Pipeline Audio en Temps Réel

1Microphone → VAD → Découpage → STT → LLM → TTS → Haut-parleur
2             ↓
3        Détection de
4        l'activité vocale

Compréhension Vidéo

Stratégies d’Échantillonnage de Frames

1. Échantillonnage Uniforme :

1def uniform_sample(video_path, num_frames=8):
2    cap = cv2.VideoCapture(video_path)
3    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
4    indices = np.linspace(0, total_frames-1, num_frames, dtype=int)
5    
6    frames = []
7    for idx in indices:
8        cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
9        ret, frame = cap.read()
10        if ret:
11            frames.append(frame)
12    
13    return frames

2. Extraction de Keyframes :

1def extract_keyframes(video_path, threshold=30):
2    # Finding keyframes with Scene change detection
3    pass

Pipeline Vidéo-LLM

1Vidéo → Échantillonnage Frames → Encodage par Frame → Agrégation Temporelle → LLM
2                              ↓
3                        Extraction Audio → STT → Texte

Fusion de Modalités

Early Fusion

Combinaison des modalités à l’entrée du modèle :

[CLS] [IMG_1] ... [IMG_N] [SEP] [TXT_1] ... [TXT_M] [SEP]

Late Fusion

Traitement de chaque modalité séparément puis combinaison des résultats :

1Image → Modèle Image → Features Image ─┐
2                                       ├→ Couche de Fusion → Sortie
3Texte → Modèle Texte → Features Texte ─┘

Cross-Modal Attention

Attention entre modalités :

1Q = Text Features
2K, V = Image Features
3Cross_Attention(Q, K, V) = softmax(QK^T/√d)V

OCR et Compréhension de Documents

Pipeline Document AI

1def process_document(image_path):
2    # 1. Layout Detection
3    layout = detect_layout(image)  # Headings, paragraphs, tables
4    
5    # 2. OCR
6    text_regions = ocr_extract(image)
7    
8    # 3. Structure Understanding
9    structured_doc = parse_structure(layout, text_regions)
10    
11    # 4. LLM Analysis
12    analysis = llm_analyze(structured_doc)
13    
14    return analysis

Extraction de Tables

1response = client.chat.completions.create(
2    model="gpt-4-vision-preview",
3    messages=[{
4        "role": "user",
5        "content": [
6            {"type": "image_url", "image_url": {"url": table_image_url}},
7            {"type": "text", "text": "Extract this table in JSON format"}
8        ]
9    }]
10)

Applications Multimodales Entreprise

1. Traitement de Documents

• OCR de factures/reçus
• Analyse de contrats
• Extraction de données de formulaires

2. Recherche Visuelle

• Recherche à partir d’une image produit
• Recherche d’images similaires
• Questions/Réponses visuelles

3. Modération de Contenu

• Détection d’images inappropriées
• Vérification de logos de marque
• Cohérence texte + image

4. Support Client

• Analyse de captures d’écran
• Dépannage visuel
• Support vocal

Optimisation des performances

Prétraitement des images

1def optimize_image(image_path, max_size=1024, quality=85):
2    img = Image.open(image_path)
3    
4    # Resize
5    if max(img.size) > max_size:
6        ratio = max_size / max(img.size)
7        new_size = tuple(int(d * ratio) for d in img.size)
8        img = img.resize(new_size, Image.LANCZOS)
9    
10    # Compress
11    buffer = io.BytesIO()
12    img.save(buffer, format="JPEG", quality=quality)
13    
14    return buffer.getvalue()

Traitement par lots

1async def batch_image_analysis(images, batch_size=5):
2    results = []
3    for i in range(0, len(images), batch_size):
4        batch = images[i:i+batch_size]
5        tasks = [analyze_image(img) for img in batch]
6        batch_results = await asyncio.gather(*tasks)
7        results.extend(batch_results)
8    return results

Gestion des coûts

Calcul des tokens (Vision)

1GPTV Token Cost:
2- Low detail: 85 token/image
3- High detail: 85 + 170 × tile_count
4
5Example (2048×1024, high):
6Tiles: ceil(2048/512) × ceil(1024/512) = 4 × 2 = 8
7Tokens: 85 + 170 × 8 = 1445 tokens

Stratégies d’optimisation

1. Ajuster le niveau de détail : n’utilisez pas "high" sauf si nécessaire
2. Réduire la taille de l’image : réduit le nombre de tokens
3. Mise en cache : ne réanalysez pas la même image
4. Opérations par lots : réduit le nombre d’appels API

Conclusion

L’IA multimodale est l’approche la plus proche de la capacité de compréhension humaine pour l’intelligence artificielle. La combinaison des modalités image, texte et audio permet de créer des applications d’IA plus puissantes et plus utiles.

Chez Veni AI, nous développons des solutions d’IA multimodale. Contactez-nous pour vos projets.