Multimodal Modeller
Görüntü ile Metni Birleştir.

import torch
from transformers import CLIPVisionModel, CLIPImageProcessor
from PIL import Image

# ── CLIP ViT-L/14 visual encoder yükle ──────────────────────
model_id = "openai/clip-vit-large-patch14"
processor = CLIPImageProcessor.from_pretrained(model_id)
vision_model = CLIPVisionModel.from_pretrained(
    model_id,
    torch_dtype=torch.float16
).to("cuda")

# ── Görüntüyü işle ───────────────────────────────────────────
img = Image.open("sample.jpg").convert("RGB")
inputs = processor(images=img, return_tensors="pt")
pixel_values = inputs["pixel_values"].half().to("cuda")
print(f"Pixel values shape: {pixel_values.shape}")  # (1, 3, 224, 224)

# ── Feature extraction ───────────────────────────────────────
with torch.no_grad():
    outputs = vision_model(pixel_values=pixel_values, output_hidden_states=True)

# last_hidden_state: tüm token'ların çıktısı
features = outputs.last_hidden_state
print(f"Feature map shape: {features.shape}")        # (1, 257, 1024)
# 257 = 256 patch token + 1 [CLS] token

# LLaVA gibi modeller genellikle [CLS] token'ı atar
patch_features = features[:, 1:, :]                 # (1, 256, 1024)
print(f"Patch features: {patch_features.shape}")     # (1, 256, 1024)

# İkinci-sondan önceki katmanı kullanmak bazen daha iyi sonuç verir
penultimate = outputs.hidden_states[-2][:, 1:, :]  # (1, 256, 1024)
print(f"Penultimate layer: {penultimate.shape}")

import torch
import torch.nn as nn

# ── LLaVA-1.0: Tek linear projeksiyon ───────────────────────
class LinearProjection(nn.Module):
    """LLaVA-1.0 tarzı: tek linear katman."""
    def __init__(self, visual_dim: int = 1024, llm_dim: int = 4096):
        super().__init__()
        self.proj = nn.Linear(visual_dim, llm_dim)

    def forward(self, x):
        return self.proj(x)                       # (B, N, 1024) → (B, N, 4096)


# ── LLaVA-1.5: 2-layer MLP projeksiyon ──────────────────────
class MLPProjection(nn.Module):
    """LLaVA-1.5 tarzı: Linear → GELU → Linear."""
    def __init__(self, visual_dim: int = 1024, llm_dim: int = 4096):
        super().__init__()
        self.mlp = nn.Sequential(
            nn.Linear(visual_dim, llm_dim),
            nn.GELU(),
            nn.Linear(llm_dim, llm_dim),
        )

    def forward(self, x):
        return self.mlp(x)                        # (B, N, 1024) → (B, N, 4096)


# ── Test: görsel token'ların LLM boyutuna dönüşümü ──────────
visual_features = torch.randn(1, 256, 1024)         # CLIP çıktısı

proj_v1 = LinearProjection(visual_dim=1024, llm_dim=4096)
proj_v15 = MLPProjection(visual_dim=1024, llm_dim=4096)

out_v1 = proj_v1(visual_features)
out_v15 = proj_v15(visual_features)

print(f"Giriş:       {visual_features.shape}")    # (1, 256, 1024)
print(f"LLaVA-1.0:  {out_v1.shape}")             # (1, 256, 4096)
print(f"LLaVA-1.5:  {out_v15.shape}")            # (1, 256, 4096)

# Parametre karşılaştırması
p_v1 = sum(p.numel() for p in proj_v1.parameters())
p_v15 = sum(p.numel() for p in proj_v15.parameters())
print(f"Params v1.0:  {p_v1/1e6:.1f}M")          # ~4.2M
print(f"Params v1.5:  {p_v15/1e6:.1f}M")         # ~33.6M

import torch
from transformers import LlavaForConditionalGeneration, AutoProcessor
from PIL import Image
import requests

# ── LLaVA-1.5 yükle ─────────────────────────────────────────
model_id = "llava-hf/llava-1.5-7b-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = LlavaForConditionalGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    low_cpu_mem_usage=True,
).to("cuda")

# ── Görüntü yükle ────────────────────────────────────────────
url = "https://llava-vl.github.io/static/images/view.jpg"
image = Image.open(requests.get(url, stream=True).raw)

# ── Prompt hazırla (LLaVA-1.5 formatı) ──────────────────────
# <image> token görüntünün yerleşeceği konumu belirtir
prompt = "USER: <image>\nBu fotoğrafı Türkçe olarak detaylıca açıkla.\nASSISTANT:"

# ── Input'ları hazırla ───────────────────────────────────────
inputs = processor(
    text=prompt,
    images=image,
    return_tensors="pt"
).to("cuda", dtype=torch.float16)

print(f"Input IDs: {inputs['input_ids'].shape}")
print(f"Pixel values: {inputs['pixel_values'].shape}")
# Input IDs: (1, tekst_uzunluğu)
# Pixel values: (1, 3, 336, 336)

# ── Yanıt üret ───────────────────────────────────────────────
with torch.no_grad():
    output = model.generate(
        **inputs,
        max_new_tokens=200,
        do_sample=False,
        temperature=1.0,
    )

# Sadece yeni üretilen token'ları decode et
generated = output[0][inputs["input_ids"].shape[1]:]
response = processor.decode(generated, skip_special_tokens=True)
print(f"Model yanıtı:\n{response}")

import base64
import io
from PIL import Image

# ── Görüntüyü base64'e çevir ─────────────────────────────────
def image_to_base64(image_path: str) -> str:
    with open(image_path, "rb") as f:
        img_bytes = f.read()
    return base64.b64encode(img_bytes).decode("utf-8")

# ── LLaVA-1.5 konuşma formatı ───────────────────────────────
# Sistem: model rolünü tanımla
# User: <image> token + soru (görüntü ilk turda bir kez verilir)
# Assistant: yanıt
# Çok turlu konuşmada görüntü sadece ilk turda verilir

single_turn = """USER: <image>
Bu grafikte hangi ürün en yüksek satış rakamına ulaşmıştır?
ASSISTANT:"""

multi_turn = """USER: <image>
Bu faturanın toplam tutarı nedir?
ASSISTANT: Faturanın toplam tutarı 2.450,00 TL'dir.
USER: Vergi oranı nedir ve vergi tutarı kaçtır?
ASSISTANT:"""

# ── HuggingFace chat template ile otomatik formatlama ────────
from transformers import AutoProcessor

processor = AutoProcessor.from_pretrained("llava-hf/llava-1.5-7b-hf")

# Chat template formatı (daha modern yaklaşım)
conversation = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Bu görüntüdeki metni Türkçeye çevir."}
        ]
    }
]

prompt = processor.apply_chat_template(
    conversation,
    add_generation_prompt=True
)
print(prompt)
# USER: <image>\nBu görüntüdeki metni Türkçeye çevir. ASSISTANT:

import torch
import fitz                                         # PyMuPDF
from PIL import Image
from transformers import LlavaForConditionalGeneration, AutoProcessor

# ── PDF sayfasını görüntüye dönüştür ─────────────────────────
def pdf_page_to_image(pdf_path: str, page_num: int = 0, dpi: int = 200) -> Image:
    """PyMuPDF ile PDF sayfasını PIL Image olarak döndür."""
    doc = fitz.open(pdf_path)
    page = doc[page_num]
    # DPI'yı artır: daha iyi metin okunabilirliği
    mat = fitz.Matrix(dpi / 72.0, dpi / 72.0)
    pix = page.get_pixmap(matrix=mat, colorspace=fitz.csRGB)
    img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
    doc.close()
    return img

# ── Model ve processor yükle ─────────────────────────────────
model_id = "llava-hf/llava-1.5-7b-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = LlavaForConditionalGeneration.from_pretrained(
    model_id, torch_dtype=torch.float16
).to("cuda")

# ── Belge üzerinde soru-cevap ────────────────────────────────
def document_qa(image: Image, question: str) -> str:
    prompt = f"USER: <image>\n{question}\nASSISTANT:"
    inputs = processor(text=prompt, images=image, return_tensors="pt")
    inputs = {k: v.to("cuda") for k, v in inputs.items()}
    if "pixel_values" in inputs:
        inputs["pixel_values"] = inputs["pixel_values"].half()
    with torch.no_grad():
        out = model.generate(**inputs, max_new_tokens=300, do_sample=False)
    generated = out[0][inputs["input_ids"].shape[1]:]
    return processor.decode(generated, skip_special_tokens=True)

# ── Kullanım örneği ──────────────────────────────────────────
page_img = pdf_page_to_image("invoice.pdf", page_num=0, dpi=200)

sorular = [
    "Bu faturanın tarihi nedir?",
    "Toplam ödenecek tutar nedir?",
    "Faturayı düzenleyen şirketin adı nedir?",
    "Bu belgede kaç satır ürün/hizmet var?",
]

for soru in sorular:
    yanit = document_qa(page_img, soru)
    print(f"S: {soru}\nC: {yanit}\n")

import torch
import json
from PIL import Image
from transformers import LlavaForConditionalGeneration, AutoProcessor

model_id = "llava-hf/llava-1.5-13b-hf"               # 13B daha iyi sayısal anlama
processor = AutoProcessor.from_pretrained(model_id)
model = LlavaForConditionalGeneration.from_pretrained(
    model_id, torch_dtype=torch.float16
).to("cuda")

# ── Yapılandırılmış çıkarım prompt'u ─────────────────────────
CHART_PROMPT = """USER: <image>
Bu grafiği analiz et ve aşağıdaki bilgileri çıkar:
1. Grafik türü (bar, line, pie, scatter, vb.)
2. X ekseni: ne temsil ediyor ve birimler neler?
3. Y ekseni: ne temsil ediyor ve birimler neler?
4. En yüksek değer: hangi kategori/zaman, değer nedir?
5. En düşük değer: hangi kategori/zaman, değer nedir?
6. Genel trend ya da öne çıkan gözlem (1-2 cümle)

Yanıtını şu JSON formatında ver:
{
  "grafik_turu": "...",
  "x_ekseni": "...",
  "y_ekseni": "...",
  "en_yuksek": {"kategori": "...", "deger": "..."},
  "en_dusuk": {"kategori": "...", "deger": "..."},
  "gozlem": "..."
}
ASSISTANT:"""

def analyze_chart(image_path: str) -> dict:
    image = Image.open(image_path).convert("RGB")
    inputs = processor(
        text=CHART_PROMPT, images=image, return_tensors="pt"
    ).to("cuda", dtype=torch.float16)

    with torch.no_grad():
        out = model.generate(**inputs, max_new_tokens=400, do_sample=False)
    generated = out[0][inputs["input_ids"].shape[1]:]
    text = processor.decode(generated, skip_special_tokens=True)

    # JSON bloğu çıkarmayı dene
    try:
        start = text.find("{")
        end = text.rfind("}") + 1
        if start != -1 and end > start:
            return json.loads(text[start:end])
    except json.JSONDecodeError:
        pass
    return {"ham_yanit": text}

# ── Kullanım ─────────────────────────────────────────────────
result = analyze_chart("sales_chart.png")
print(json.dumps(result, ensure_ascii=False, indent=2))
# Örnek çıktı:
# {
#   "grafik_turu": "bar chart",
#   "x_ekseni": "Çeyrekler (Q1-Q4 2023)",
#   "y_ekseni": "Satış (milyon TL)",
#   "en_yuksek": {"kategori": "Q4", "deger": "~48M TL"},
#   "en_dusuk": {"kategori": "Q1", "deger": "~31M TL"},
#   "gozlem": "Satışlar yıl boyunca tutarlı artış göstermiş..."
# }

import torch
import numpy as np
from PIL import Image
from transformers import AutoTokenizer, AutoModel
import torchvision.transforms as T
from torchvision.transforms.functional import InterpolationMode

# ── InternVL2-8B yükle ───────────────────────────────────────
model_id = "OpenGVLab/InternVL2-8B"
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModel.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    trust_remote_code=True,
    low_cpu_mem_usage=True,
).eval().cuda()

# ── InternVL görüntü ön işleme ───────────────────────────────
IMAGENET_MEAN = (0.485, 0.456, 0.406)
IMAGENET_STD  = (0.229, 0.224, 0.225)

transform = T.Compose([
    T.Lambda(lambda img: img.convert("RGB")),
    T.Resize((448, 448), interpolation=InterpolationMode.BICUBIC),
    T.ToTensor(),
    T.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD),
])

def load_image(path: str) -> torch.Tensor:
    img = Image.open(path).convert("RGB")
    pixel_values = transform(img).unsqueeze(0).to(torch.bfloat16).cuda()
    return pixel_values

# ── Inference ────────────────────────────────────────────────
pixel_values = load_image("chart.png")
generation_config = {
    "max_new_tokens": 512,
    "do_sample": False,
}

response = model.chat(
    tokenizer,
    pixel_values,
    "Bu grafiği analiz ederek ana trendleri ve önemli veri noktalarını Türkçe açıkla.",
    generation_config,
)
print(response)

import torch
from PIL import Image
from transformers import LlavaForConditionalGeneration, AutoProcessor

model_id = "llava-hf/llava-1.5-7b-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = LlavaForConditionalGeneration.from_pretrained(
    model_id, torch_dtype=torch.float16
).to("cuda")

# ── Önce-Sonra karşılaştırma ─────────────────────────────────
img_before = Image.open("before.jpg").convert("RGB")
img_after  = Image.open("after.jpg").convert("RGB")

# Her görüntü için ayrı <image> token
prompt = ("USER: <image><image>\n"
          "İlk görüntü 'önce', ikinci görüntü 'sonra' durumunu gösteriyor. "
          "İkisi arasındaki temel farkları listele.\nASSISTANT:")

inputs = processor(
    text=prompt,
    images=[img_before, img_after],            # görüntü listesi
    return_tensors="pt"
).to("cuda", dtype=torch.float16)

with torch.no_grad():
    out = model.generate(**inputs, max_new_tokens=300, do_sample=False)
generated = out[0][inputs["input_ids"].shape[1]:]
print(processor.decode(generated, skip_special_tokens=True))

# ── Video frame sampling ─────────────────────────────────────
import cv2

def sample_video_frames(video_path: str, n_frames: int = 8) -> list:
    """Videodan eşit aralıklı n_frames kare çıkar."""
    cap = cv2.VideoCapture(video_path)
    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    indices = [int(i * total / n_frames) for i in range(n_frames)]
    frames = []
    for idx in indices:
        cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
        ret, frame = cap.read()
        if ret:
            rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            frames.append(Image.fromarray(rgb))
    cap.release()
    return frames

def video_qa(video_path: str, question: str, n_frames: int = 8) -> str:
    frames = sample_video_frames(video_path, n_frames)
    # Her kare için <image> token
    image_tokens = "<image>" * len(frames)
    prompt = f"USER: {image_tokens}\n{question}\nASSISTANT:"

    inputs = processor(
        text=prompt, images=frames, return_tensors="pt"
    ).to("cuda", dtype=torch.float16)

    with torch.no_grad():
        out = model.generate(**inputs, max_new_tokens=200, do_sample=False)
    generated = out[0][inputs["input_ids"].shape[1]:]
    return processor.decode(generated, skip_special_tokens=True)

# Kullanım
# answer = video_qa("tutorial.mp4", "Bu videoda hangi adımlar gösteriliyor?", n_frames=8)
# print(answer)