Мультимодальные
LLM

import torch
from PIL import Image
import math

def dynamic_tile_encode(
    image: Image.Image,
    vision_encoder,          # ViT принимает 224×224
    max_tiles: int = 12,      # максимум тайлов
    tile_size: int = 224,
) -> torch.Tensor:
    """
    Делит изображение на тайлы + добавляет уменьшенный thumbnail.
    Результат: (1 + num_tiles) × num_patches × D
    """
    w, h = image.size
    # Определяем оптимальную сетку тайлов
    aspect = w / h
    num_tiles_w = min(int(math.ceil(w / tile_size)), max_tiles)
    num_tiles_h = min(int(math.ceil(h / tile_size)), max_tiles)
    # Ограничиваем общее число тайлов
    while num_tiles_w * num_tiles_h > max_tiles:
        if num_tiles_w > num_tiles_h: num_tiles_w -= 1
        else: num_tiles_h -= 1

    tiles = []
    # 1. Thumbnail: всё изображение сжатое до 224×224
    thumbnail = image.resize((tile_size, tile_size))
    tiles.append(vision_encoder(thumbnail))   # глобальный контекст

    # 2. Локальные тайлы (перекрытие 10% для continuity)
    stride_w = w // num_tiles_w
    stride_h = h // num_tiles_h
    for row in range(num_tiles_h):
        for col in range(num_tiles_w):
            x0 = col * stride_w
            y0 = row * stride_h
            tile = image.crop((x0, y0, x0 + tile_size, y0 + tile_size))
            tile_emb = vision_encoder(tile)
            tiles.append(tile_emb)

    # (1 + num_tiles) × 196 × D
    return torch.stack(tiles, dim=0)

# Для 1080p (1920×1080) с tile_size=224:
# num_tiles_w = 8, num_tiles_h = 4 → 32+1=33 тайла
# 33 × 196 = 6468 visual tokens → дорого, но качественно
# Qwen2.5-VL использует динамическое разрешение с сжатием

from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
from qwen_vl_utils import process_vision_info
import torch

model = Qwen2VLForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2.5-VL-7B-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-7B-Instruct")

# ── Видео через URL или локальный файл ───────────────────────
messages = [{
    "role": "user",
    "content": [
        {
            "type": "video",
            "video": "video.mp4",           # или URL
            "max_pixels": 360 * 420,      # ограничение разрешения
            "fps": 1.0,                   # 1 кадр в секунду
        },
        {"type": "text", "text": "Опиши, что происходит на видео. Когда появляется человек?"},
    ],
}]

text_prompt = processor.apply_chat_template(messages, tokenize=False)
image_inputs, video_inputs = process_vision_info(messages)

inputs = processor(
    text=[text_prompt],
    images=image_inputs,
    videos=video_inputs,
    padding=True,
    return_tensors="pt",
).to(model.device)

with torch.no_grad():
    output_ids = model.generate(**inputs, max_new_tokens=512)

output_text = processor.batch_decode(
    output_ids[:, inputs.input_ids.shape[1]:],
    skip_special_tokens=True
)[0]
print(output_text)

from transformers import PaliGemmaForConditionalGeneration, PaliGemmaProcessor
from PIL import Image
import torch

# PaliGemma: SigLIP-SO400M + Gemma 2B — отличен для document tasks
model = PaliGemmaForConditionalGeneration.from_pretrained(
    "google/paligemma-3b-mix-448",   # 448 = высокое разрешение
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
processor = PaliGemmaProcessor.from_pretrained("google/paligemma-3b-mix-448")

def extract_from_document(image_path: str, question: str) -> str:
    image = Image.open(image_path).convert("RGB")

    inputs = processor(
        images=image,
        text=question,
        return_tensors="pt",
    ).to(model.device, torch.bfloat16)

    with torch.inference_mode():
        generated = model.generate(**inputs, max_new_tokens=256, do_sample=False)

    # Убираем входные токены из вывода
    output = processor.decode(
        generated[0][inputs.input_ids.shape[1]:],
        skip_special_tokens=True
    )
    return output

# Примеры использования на PDF/скан документах:
questions = [
    "Извлеки все суммы из таблицы. Верни JSON.",
    "Какова итоговая сумма в строке Total?",
    "Кто подписал этот договор?",
    "Что написано в колонке 'Описание работ'?",
    "ocr",  # PaliGemma понимает прямые задачи: ocr, detect, caption
]

for q in questions:
    answer = extract_from_document("invoice.png", q)
    print(f"Q: {q}\nA: {answer}\n")

import sounddevice as sd
import numpy as np
import whisper, edge_tts
from openai import OpenAI
import asyncio, tempfile

# Загружаем модели
asr_model = whisper.load_model("base")   # быстрее medium, для real-time
llm = OpenAI()
history = []

async def voice_turn():
    """Один цикл: записать → распознать → ответить → озвучить."""
    # 1. Запись аудио (VAD в реальном приложении)
    print("Говорите...")
    audio = sd.rec(int(5 * 16000), samplerate=16000, channels=1, dtype='float32')
    sd.wait()

    # 2. ASR: float32 array → текст
    audio_flat = audio.flatten()
    result = asr_model.transcribe(audio_flat, language="ru", fp16=False)
    user_text = result["text"].strip()
    print(f"Пользователь: {user_text}")

    if not user_text: return

    # 3. LLM генерация
    history.append({"role": "user", "content": user_text})
    resp = llm.chat.completions.create(
        model="gpt-4o-mini", messages=history,
        max_tokens=200, temperature=0.7,
    )
    assistant_text = resp.choices[0].message.content
    history.append({"role": "assistant", "content": assistant_text})
    print(f"Ассистент: {assistant_text}")

    # 4. TTS через edge-tts (Microsoft, бесплатно)
    communicate = edge_tts.Communicate(assistant_text, voice="ru-RU-SvetlanaNeural")
    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as f:
        await communicate.save(f.name)
        # воспроизводим через pygame или sounddevice

asyncio.run(voice_turn())