Конспект 10: Multimodal AI - Текст, изображения, аудио, видео

Unimodal (один тип данных):
- Текстовый LLM: только текст → текст
- Image classifier: только изображения → класс
- Speech-to-text: только аудио → текст

Multimodal (несколько типов):
- GPT-4 Vision: текст + изображения → текст
- CLIP: текст + изображения → embeddings
- LLaVA: изображение + вопрос → ответ

Реальный мир multimodal:
❌ Никогда нет чистого текста или чистых картинок
✅ Всё комбинации текста, изображений, видео, аудио

Примеры:
- Документы со скриншотами (PDF анализ)
- Видео с субтитрами (понимание контента)
- Изображения с подписями (caption generation)
- Таблицы с иконками (table understanding)

2015: VGG + LSTM (базовая vision-language)
2016: Attention механизм между модальностями
2019: CLIP (OpenAI) - революция
2021: ViT (Vision Transformer)
2023: GPT-4 Vision (понимание любых изображений)
2024: Gemini 2.0 (лучше всех в multimodal)
2025: Reasoning models с vision

Маленькие (32×32): Классификация, быстро
Средние (224×224): Standard для большинства
Большие (512×512+): Детали, но медленнее

Speech: говорение (можно convert в текст)
Music: музыкальное аудио (análisis ритма, жанра)
Sound: звуковые эффекты

Input: $0.01 per 1K tokens + $0.25 per image
Output: $0.03 per 1K tokens

Пример: 5 изображений + 100 токенов текста
= (100 × $0.01 + 5 × $0.25) / 1000 + 0 = $0.00135

import openai

response = openai.ChatCompletion.create(
    model="gpt-4-vision-preview",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/image.jpg"
                    }
                },
                {
                    "type": "text",
                    "text": "Что ты видишь на этом изображении?"
                }
            ]
        }
    ]
)

Дешевле чем GPT-4 Vision
Input: $0.075 per 1M tokens
Images: включены в токен count

Claude 3 Haiku: быстро, дешево
Claude 3 Sonnet: баланс
Claude 3 Opus: лучше всех

┌──────────────┐
│   Изображение│
└──────┬───────┘
       │
   ┌───▼────────────┐
   │ Vision Encoder │ (ViT)
   │ (извлекает     │
   │  features)     │
   └───┬────────────┘
       │
   ┌───▼─────────────────┐
   │  Feature Projection │ (привести к размеру токенов)
   └───┬─────────────────┘
       │
   ┌───▼────────────────────────────┐
   │  LLM (например, GPT)           │ ◄──── ┌──────────────┐
   │  (понимает и отвечает)         │       │   Текстовый  │
   │                                │       │   вопрос     │
   └───┬────────────────────────────┘       └──────────────┘
       │
   ┌───▼────────────┐
   │ Текстовый ответ│
   └────────────────┘

Изображение (H×W×3)
    ↓
Vision Transformer (ViT)
    ↓
Фичи изображения (N×D)
где N = количество патчей, D = размерность

Фичи изображения (N×D_vision)
    ↓
Linear projection
    ↓
Токен-подобное представление (N×D_language)

[<image_tokens> + <text_tokens>]
    ↓
LLM (например, GPT)
    ↓
Текстовый ответ

OpenAI Whisper:
- Точность: 95%+
- Языки: 98
- Бесплатно (может быть локально)

Google Cloud Speech-to-Text:
- Accuracy: 95%+
- Real-time streaming

Azure Speech Services:
- Multilingual
- Custom models

import openai

audio_file = open("audio.mp3", "rb")
transcript = openai.Audio.transcribe(
    model="whisper-1",
    file=audio_file,
    language="ru"  # Опционально
)

print(transcript["text"])

import openai

speech = openai.Audio.create(
    model="tts-1",
    voice="nova",
    input="Привет, это голосовое сообщение",
    speed=1.0
)

speech.stream_to_file("output.mp3")

alloy, echo, fable, onyx, nova, shimmer

tts-1: быстро, дешево (используй для real-time)
tts-1-hd: лучше качество (используй для записей)

Жанр классификации
Mood recognition
Beat detection
Instrument identification

Эмоции (happiness, anger, sadness)
Уверенность говорящего
Скорость речи
Акцент/язык

import cv2

video = cv2.VideoCapture("video.mp4")
frames = []
while True:
    ret, frame = video.read()
    if not ret:
        break
    frames.append(frame)

# Выбрать ключевые фреймы (каждый N-й)
key_frames = frames[::30]  # Каждый 30-й фрейм

Определить действия в видео:
- Ходьба, бег, прыжок
- Сидение, стояние
- Взаимодействия между людьми

Input: видео
Output: "Люди играют в футбол в парке"

# 1. Извлечь ключевые фреймы
key_frames = extract_key_frames(video)

# 2. Описать каждый фрейм с VLM
descriptions = []
for frame in key_frames:
    desc = gpt4_vision(frame, "Опиши что происходит")
    descriptions.append(desc)

# 3. Объединить в сценарий видео
full_description = " → ".join(descriptions)

# Используй video embedding модели
# Например: ViViT, TimeSformer

# Все видео в датасете → embeddings
video_embeddings = []
for video in videos:
    embedding = video_encoder(video)
    video_embeddings.append(embedding)

# Search похожих видео
query_embedding = video_encoder(query_video)
similar = search_nearest(query_embedding, video_embeddings)

Изображение: "Кот спит"
    ↓
CLIP Image Encoder
    ↓
[0.123, -0.456, ..., 0.789] (512D)

Текст: "Спящий кот"
    ↓
CLIP Text Encoder
    ↓
[0.125, -0.450, ..., 0.791] (512D)

Similarity: cosine_sim = 0.98 (очень похожи!)

Image Encoder (ViT)
    ↓
    └─→ Image embeddings (512D)

Text Encoder (Transformer)
    ↓
    └─→ Text embeddings (512D)

Обучение: Maximal similarity между paired images и текстов

from PIL import Image
import clip
import torch

device = "cuda" if torch.cuda.is_available() else "cpu"
model, preprocess = clip.load("ViT-B/32", device=device)

image = preprocess(Image.open("photo.jpg")).unsqueeze(0).to(device)
text = clip.tokenize(["собака", "кот", "птица"]).to(device)

with torch.no_grad():
    image_features = model.encode_image(image)
    text_features = model.encode_text(text)

    # Вычислить similarity
    logits_per_image = image_features @ text_features.T
    probs = logits_per_image.softmax(dim=-1)

print(probs)  # [0.85, 0.10, 0.05] - скорее всего собака

Пользователь: "Красная роза"
    ↓
Text encoder (CLIP)
    ↓
Text embedding
    ↓
Vector DB поиск
    ↓
Найти похожие изображения
    ↓
Результаты: [foto1.jpg, foto2.jpg, ...]

import clip
from qdrant_client import QdrantClient
import torch
from PIL import Image

# 1. Загрузить модель
device = "cuda"
model, preprocess = clip.load("ViT-B/32", device=device)
qdrant = QdrantClient("http://localhost:6333")

# 2. Индексировать изображения
images = load_all_images()
for i, img_path in enumerate(images):
    img = Image.open(img_path)
    img_tensor = preprocess(img).unsqueeze(0).to(device)

    with torch.no_grad():
        embedding = model.encode_image(img_tensor)[0].cpu().numpy()

    qdrant.upsert(
        collection_name="images",
        points=[{"id": i, "vector": embedding, "payload": {"path": img_path}}]
    )

# 3. Поиск по тексту
query = "красная роза"
query_tokens = clip.tokenize(query).to(device)
with torch.no_grad():
    query_embedding = model.encode_text(query_tokens)[0].cpu().numpy()

results = qdrant.search(
    collection_name="images",
    query_vector=query_embedding,
    limit=5
)

# Вывод результатов
for result in results:
    print(f"Image: {result.payload['path']}, Score: {result.score:.3f}")

Пользователь загружает изображение
    ↓
Image encoder (CLIP)
    ↓
Image embedding
    ↓
Vector DB поиск (в текстовых embeddings)
    ↓
Найти похожий текст
    ↓
Результаты: [document1.txt, document2.txt, ...]

import openai
from PIL import Image
import base64

def image_to_base64(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode()

def analyze_document(image_path, question):
    """Анализ документа с изображением"""

    image_data = image_to_base64(image_path)

    response = openai.ChatCompletion.create(
        model="gpt-4-vision-preview",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/jpeg;base64,{image_data}"
                        }
                    },
                    {
                        "type": "text",
                        "text": question
                    }
                ]
            }
        ]
    )

    return response.choices[0].message.content

# Использование
answer = analyze_document(
    "invoice.jpg",
    "Какая общая сумма счета?"
)

import cv2
import openai

def summarize_video(video_path):
    """Резюме видео через анализ ключевых фреймов"""

    video = cv2.VideoCapture(video_path)
    frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))

    # Извлечь ключевые фреймы
    key_frames = []
    for i in range(0, frame_count, frame_count // 5):  # 5 фреймов
        video.set(cv2.CAP_PROP_POS_FRAMES, i)
        ret, frame = video.read()
        if ret:
            key_frames.append(frame)

    # Описать каждый фрейм
    descriptions = []
    for frame in key_frames:
        # Конвертировать frame → base64
        # Отправить в GPT-4 Vision
        # Получить описание
        pass

    # Объединить в итоговое резюме
    summary = "\n".join(descriptions)

    return summary

import openai

def analyze_podcast(audio_path):
    """Транскрибировать и проанализировать подкаст"""

    # 1. Транскрибировать
    with open(audio_path, "rb") as audio_file:
        transcript = openai.Audio.transcribe(
            model="whisper-1",
            file=audio_file
        )

    text = transcript["text"]

    # 2. Анализировать с LLM
    analysis = openai.ChatCompletion.create(
        model="gpt-4-turbo",
        messages=[
            {
                "role": "system",
                "content": "Ты аналитик подкастов"
            },
            {
                "role": "user",
                "content": f"""Проанализируй этот транскрипт подкаста:

{text}

Дай:
1. Основные темы
2. Ключевые выводы
3. Интересные моменты
"""
            }
        ]
    )

    return {
        "transcript": text,
        "analysis": analysis.choices[0].message.content
    }

Выбор модели:
☑️ Задача определена (caption, QA, search)
☑️ Модель выбрана (GPT-4V, Gemini, Claude)
☑️ Цена проверена
☑️ Качество протестировано

Подготовка данных:
☑️ Изображения отресайзены
☑️ Аудио в правильном формате
☑️ Видео ключевые фреймы извлечены
☑️ Нет приватных данных

Обработка:
☑️ Batch обработка (если много)
☑️ Кэширование включено
☑️ Error handling настроено
☑️ Rate limiting соблюдается

Оценка:
☑️ Результаты проверены вручную
☑️ Метрики считаются (если возможно)
☑️ A/B тестирование сделано
☑️ Performance оптимизирован