Hugging Face ile Özetleme ve Çeviri Modelleri Nasıl Kullanılır?

Metin özetleme ve çeviri, yapay zekanın en çok iş yükü azaltan iki kullanım alanı. Günde onlarca teknik doküman okumak zorunda kalan bir sysadmin olarak, bu modelleri keşfettiğimde hayatım gerçekten kolaylaştı. Hugging Face üzerindeki hazır modeller sayesinde ne bir API anahtarı satın almak gerekiyor ne de karmaşık bir altyapı kurmak. Sunucunuza modeli indirin, Python ile birkaç satır kod yazın, işiniz bitti.

Bu yazıda özetleme ve çeviri modellerini production ortamında nasıl kullanacağınızı, hangi modellerin hangi senaryolara uygun olduğunu ve performans optimizasyonlarını ele alacağız.

Ortamı Hazırlamak

Başlamadan önce temel bağımlılıkları kurmanız gerekiyor. Özellikle GPU kullanacaksanız CUDA sürümünüzle uyumlu PyTorch kurulumuna dikkat edin.

# Sanal ortam oluşturun
python3 -m venv hf-nlp-env
source hf-nlp-env/bin/activate

# Temel paketleri kurun
pip install transformers torch sentencepiece sacrebleu

# GPU kullanıyorsanız (CUDA 11.8 örneği)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# Hızlı inference için
pip install accelerate optimum

# Model önbelleği için dizin ayarlayın
export HF_HOME=/data/huggingface-cache
export TRANSFORMERS_CACHE=/data/huggingface-cache/transformers

Model dosyaları büyük olabiliyor. Varsayılan olarak ~/.cache/huggingface altına iniyorlar. Sunucunuzda /home bölümü küçükse mutlaka HF_HOME değişkenini ayrı bir diske yönlendirin. 10-15 GB model indirip ardından disk doldu hatası almak can sıkıcı.

Özetleme Modelleri

BART ile Belge Özetleme

Facebook’un geliştirdiği BART, İngilizce metin özetleme için hâlâ en güvenilir seçeneklerden biri. facebook/bart-large-cnn modeli özellikle haber metinleri ve teknik belgeler için iyi sonuç veriyor.

#!/usr/bin/env python3
# summarizer.py

from transformers import pipeline
import sys

def summarize_text(text, max_length=150, min_length=50):
    """Metni özetle"""
    summarizer = pipeline(
        "summarization",
        model="facebook/bart-large-cnn",
        device=0  # GPU için 0, CPU için -1
    )
    
    # BART maksimum 1024 token alabiliyor
    # Uzun metinler için parçalara bölmek gerekiyor
    max_chunk_length = 1000
    
    if len(text.split()) > max_chunk_length:
        chunks = chunk_text(text, max_chunk_length)
        summaries = []
        for chunk in chunks:
            result = summarizer(
                chunk,
                max_length=max_length,
                min_length=min_length,
                do_sample=False
            )
            summaries.append(result[0]['summary_text'])
        return " ".join(summaries)
    else:
        result = summarizer(
            text,
            max_length=max_length,
            min_length=min_length,
            do_sample=False
        )
        return result[0]['summary_text']

def chunk_text(text, chunk_size):
    """Metni parçalara böl"""
    words = text.split()
    chunks = []
    for i in range(0, len(words), chunk_size):
        chunk = " ".join(words[i:i + chunk_size])
        chunks.append(chunk)
    return chunks

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Kullanim: python summarizer.py <dosya.txt>")
        sys.exit(1)
    
    with open(sys.argv[1], 'r', encoding='utf-8') as f:
        text = f.read()
    
    print("Ozet:")
    print(summarize_text(text))

Türkçe Özetleme için mT5

BART İngilizce odaklı çalışıyor. Türkçe metinler için Google’ın multilingual T5 modelini kullanmak daha mantıklı. csebuetnlp/mT5_multilingual_XLSum modeli 45 dili destekliyor ve Türkçe performansı oldukça iyi.

#!/usr/bin/env python3
# turkish_summarizer.py

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
import torch

WHITESPACE_HANDLER = lambda k: ' '.join(k.strip().split())

def summarize_turkish(text, model_name="csebuetnlp/mT5_multilingual_XLSum"):
    """Turkce metin ozetleme"""
    
    tokenizer = AutoTokenizer.from_pretrained(
        model_name,
        use_fast=False
    )
    model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
    
    # GPU varsa kullan
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = model.to(device)
    
    # Dil token'i ekle (Turkce icin)
    LANGUAGE_TOKEN = tokenizer.special_tokens_map.get(
        'additional_special_tokens', []
    )
    
    input_ids = tokenizer(
        [WHITESPACE_HANDLER(text)],
        return_tensors="pt",
        padding="max_length",
        truncation=True,
        max_length=512
    )["input_ids"].to(device)
    
    output_ids = model.generate(
        input_ids=input_ids,
        max_length=200,
        no_repeat_ngram_size=2,
        num_beams=4,
        early_stopping=True
    )
    
    summary = tokenizer.decode(
        output_ids[0],
        skip_special_tokens=True,
        clean_up_tokenization_spaces=False
    )
    
    return summary

# Test
if __name__ == "__main__":
    test_text = """
    Kubernetes, konteyner orkestrasyon platformu olarak modern altyapı yönetiminin 
    vazgeçilmez bir parçası haline gelmiştir. Google tarafından geliştirilen bu açık 
    kaynak sistem, uygulamaların dağıtımını, ölçeklenmesini ve yönetimini otomatize 
    eder. Cluster yapısı sayesinde onlarca hatta yüzlerce sunucu tek bir platform 
    üzerinden yönetilebilmektedir. Pod, Service, Deployment gibi temel kavramlar 
    üzerine kurulu olan sistem, declarative konfigürasyon anlayışını benimser.
    """
    
    print(summarize_turkish(test_text))

Çeviri Modelleri

Helsinki-NLP Modelleri

Helsinki-NLP grubu, Hugging Face üzerinde yüzlerce dil çifti için model yayınlamış durumda. Helsinki-NLP/opus-mt-{kaynak}-{hedef} formatında isimlendirilen bu modeller hafif ve hızlı çalışıyor.

#!/usr/bin/env python3
# translator.py

from transformers import MarianMTModel, MarianTokenizer
from typing import List
import torch

class TextTranslator:
    def __init__(self, source_lang: str, target_lang: str):
        """
        Ornek: TextTranslator('en', 'tr')
        Desteklenen diller: en, tr, de, fr, es, ru, ar...
        """
        model_name = f"Helsinki-NLP/opus-mt-{source_lang}-{target_lang}"
        self.tokenizer = MarianTokenizer.from_pretrained(model_name)
        self.model = MarianMTModel.from_pretrained(model_name)
        
        self.device = torch.device(
            "cuda" if torch.cuda.is_available() else "cpu"
        )
        self.model = self.model.to(self.device)
        
    def translate(self, texts: List[str], batch_size: int = 8) -> List[str]:
        """Toplu ceviri yapar"""
        all_translations = []
        
        for i in range(0, len(texts), batch_size):
            batch = texts[i:i + batch_size]
            
            encoded = self.tokenizer(
                batch,
                return_tensors="pt",
                padding=True,
                truncation=True,
                max_length=512
            ).to(self.device)
            
            with torch.no_grad():
                translated = self.model.generate(**encoded)
            
            decoded = self.tokenizer.batch_decode(
                translated,
                skip_special_tokens=True
            )
            all_translations.extend(decoded)
        
        return all_translations

# Kullanim ornegi
if __name__ == "__main__":
    # Ingilizce'den Turkce'ye
    en_to_tr = TextTranslator("en", "tr")
    
    texts = [
        "The server is running out of disk space.",
        "Please restart the service after configuration changes.",
        "Memory usage has exceeded the threshold limit."
    ]
    
    translations = en_to_tr.translate(texts)
    for original, translated in zip(texts, translations):
        print(f"EN: {original}")
        print(f"TR: {translated}")
        print()

Büyük ve Kaliteli Çeviri: NLLB-200

Meta’nın NLLB (No Language Left Behind) modeli 200 dili destekliyor ve Helsinki modellerine kıyasla çok daha yüksek kalite sunuyor. Tabii ki boyutu da büyük: küçük versiyonu 1.3 GB, büyük versiyonu 2.46 GB.

#!/usr/bin/env python3
# nllb_translator.py

from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
import torch

def translate_with_nllb(
    text: str,
    source_lang: str = "eng_Latn",
    target_lang: str = "tur_Latn",
    model_size: str = "1.3B"
):
    """
    NLLB-200 ile ceviri
    
    Dil kodlari:
    - Ingilizce: eng_Latn
    - Turkce: tur_Latn  
    - Almanca: deu_Latn
    - Rusca: rus_Cyrl
    - Arapca: arb_Arab
    - Fransizca: fra_Latn
    """
    
    model_name = f"facebook/nllb-200-distilled-{model_size}"
    
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForSeq2SeqLM.from_pretrained(
        model_name,
        torch_dtype=torch.float16  # Bellek tasarrufu
    )
    
    device = "cuda" if torch.cuda.is_available() else "cpu"
    model = model.to(device)
    
    inputs = tokenizer(text, return_tensors="pt").to(device)
    
    target_lang_id = tokenizer.lang_code_to_id[target_lang]
    
    translated_tokens = model.generate(
        **inputs,
        forced_bos_token_id=target_lang_id,
        max_length=512,
        num_beams=5,
        length_penalty=1.0
    )
    
    result = tokenizer.batch_decode(
        translated_tokens,
        skip_special_tokens=True
    )[0]
    
    return result

# Test
if __name__ == "__main__":
    text = "Critical security vulnerability detected in the authentication module."
    result = translate_with_nllb(text)
    print(f"Ceviri: {result}")

Gerçek Dünya Senaryosu: Log Analizi ve Raporlama

Şimdi bu iki yeteneği birleştiren pratik bir senaryo yazalım. Elimde İngilizce sistem logları ve hata raporları var. Bunları otomatik olarak Türkçe özetleyip ekibe günlük rapor göndermem gerekiyor.

#!/usr/bin/env python3
# log_analyzer.py
# Sistem loglarini analiz et, ozetle ve Turkce raporla

import re
import json
from datetime import datetime
from transformers import pipeline, MarianMTModel, MarianTokenizer
import torch

class LogAnalyzer:
    def __init__(self):
        self.device = 0 if torch.cuda.is_available() else -1
        
        print("Modeller yukleniyor...")
        
        # Ozetleme modeli
        self.summarizer = pipeline(
            "summarization",
            model="facebook/bart-large-cnn",
            device=self.device,
            max_length=150,
            min_length=40
        )
        
        # Ceviri modeli
        tr_model = "Helsinki-NLP/opus-mt-en-tr"
        self.translator_tokenizer = MarianTokenizer.from_pretrained(tr_model)
        self.translator_model = MarianMTModel.from_pretrained(tr_model)
        
        if torch.cuda.is_available():
            self.translator_model = self.translator_model.cuda()
        
        print("Hazir!")
    
    def parse_logs(self, log_file: str) -> dict:
        """Log dosyasini parse et ve kategorize et"""
        errors = []
        warnings = []
        critical = []
        
        with open(log_file, 'r') as f:
            for line in f:
                if 'CRITICAL' in line or 'FATAL' in line:
                    critical.append(line.strip())
                elif 'ERROR' in line:
                    errors.append(line.strip())
                elif 'WARNING' in line or 'WARN' in line:
                    warnings.append(line.strip())
        
        return {
            "critical": critical,
            "errors": errors,
            "warnings": warnings
        }
    
    def summarize_logs(self, logs: list) -> str:
        """Log listesini tek metin olarak ozetle"""
        if not logs:
            return "No issues found."
        
        combined = " ".join(logs[:20])  # Ilk 20 satir yeterli
        combined = combined[:1000]  # Token limitini asma
        
        result = self.summarizer(combined)
        return result[0]['summary_text']
    
    def translate_to_turkish(self, text: str) -> str:
        """Ingilizce metni Turkce'ye cevir"""
        tokens = self.translator_tokenizer(
            [text],
            return_tensors="pt",
            padding=True,
            truncation=True,
            max_length=512
        )
        
        if torch.cuda.is_available():
            tokens = {k: v.cuda() for k, v in tokens.items()}
        
        with torch.no_grad():
            translated = self.translator_model.generate(**tokens)
        
        return self.translator_tokenizer.decode(
            translated[0],
            skip_special_tokens=True
        )
    
    def generate_report(self, log_file: str) -> str:
        """Tam rapor olustur"""
        logs = self.parse_logs(log_file)
        report_date = datetime.now().strftime("%Y-%m-%d %H:%M")
        
        report = f"# Gunluk Sistem Raporu - {report_date}nn"
        
        sections = [
            ("critical", "KRITIK HATALAR"),
            ("errors", "HATALAR"),
            ("warnings", "UYARILAR")
        ]
        
        for key, title in sections:
            count = len(logs[key])
            report += f"## {title} ({count} adet)n"
            
            if logs[key]:
                en_summary = self.summarize_logs(logs[key])
                tr_summary = self.translate_to_turkish(en_summary)
                report += f"{tr_summary}nn"
            else:
                report += "Sorun tespit edilmedi.nn"
        
        return report

if __name__ == "__main__":
    analyzer = LogAnalyzer()
    report = analyzer.generate_report("/var/log/application.log")
    
    # Raporu kaydet
    with open(f"report_{datetime.now().strftime('%Y%m%d')}.md", 'w') as f:
        f.write(report)
    
    print(report)

Model Önbellekleme ve Performans Optimizasyonu

Her çalıştırmada modeli indirmemek için önbellekleme mekanizmasını doğru yapılandırmak kritik. Özellikle birden fazla uygulama aynı modeli kullanıyorsa paylaşımlı önbellek büyük fark yaratıyor.

#!/bin/bash
# model_preloader.sh
# Modelleri onceden indirip hazir tut

export HF_HOME=/data/huggingface-cache
export TRANSFORMERS_CACHE=/data/huggingface-cache/transformers

MODELS=(
    "facebook/bart-large-cnn"
    "Helsinki-NLP/opus-mt-en-tr"
    "Helsinki-NLP/opus-mt-tr-en"
    "csebuetnlp/mT5_multilingual_XLSum"
)

echo "Model indirme basliyor..."

for model in "${MODELS[@]}"; do
    echo "Indiriliyor: $model"
    python3 -c "
from transformers import AutoTokenizer, AutoModel
print('Tokenizer indiriliyor...')
AutoTokenizer.from_pretrained('$model')
print('Model indiriliyor...')
# Sadece indirme, yukleme degil
from huggingface_hub import snapshot_download
snapshot_download(repo_id='$model')
print('Tamamlandi: $model')
"
done

echo "Tum modeller hazir!"
df -h /data/huggingface-cache

GPU olmayan sunucularda büyük modeller çok yavaş çalışıyor. Bu durumda quantization ile model boyutunu ve bellek kullanımını düşürebilirsiniz.

#!/usr/bin/env python3
# quantized_model.py
# Dusuk bellek kullanimi icin quantize edilmis model

from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
import torch

def load_quantized_model(model_name: str):
    """INT8 quantization ile model yukle"""
    
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    
    # CPU'da INT8 quantization
    model = AutoModelForSeq2SeqLM.from_pretrained(
        model_name,
        torch_dtype=torch.float32,
        low_cpu_mem_usage=True
    )
    
    # Dynamic quantization uygula
    quantized_model = torch.quantization.quantize_dynamic(
        model,
        {torch.nn.Linear},
        dtype=torch.qint8
    )
    
    print(f"Normal model boyutu: {sum(p.numel() for p in model.parameters()) * 4 / 1024**2:.1f} MB")
    print(f"Quantize model parametreleri: {sum(p.numel() for p in quantized_model.parameters())}")
    
    return tokenizer, quantized_model

# Helsinki modeli ile test
tokenizer, model = load_quantized_model("Helsinki-NLP/opus-mt-en-tr")
print("Quantize model yuklendi, bellek kullanimi azaltildi")

Systemd Servisi Olarak Kurulum

Bu araçları production’da çalıştırmak istiyorsanız, bir API servisi olarak sarmalamak mantıklı. FastAPI ile basit bir REST API kurup systemd ile yönetebilirsiniz.

# /etc/systemd/system/nlp-api.service

[Unit]
Description=NLP Translation and Summarization API
After=network.target
Wants=network-online.target

[Service]
Type=simple
User=nlpservice
Group=nlpservice
WorkingDirectory=/opt/nlp-api
ExecStart=/opt/nlp-api/venv/bin/python app.py
Restart=always
RestartSec=10

# Cevre degiskenleri
Environment=HF_HOME=/data/huggingface-cache
Environment=TRANSFORMERS_CACHE=/data/huggingface-cache/transformers
Environment=CUDA_VISIBLE_DEVICES=0
Environment=PORT=8080

# Kaynak limitleri
MemoryMax=8G
CPUQuota=80%

# Guvenlik
NoNewPrivileges=true
PrivateTmp=true

StandardOutput=journal
StandardError=journal
SyslogIdentifier=nlp-api

[Install]
WantedBy=multi-user.target

# Servisi etkinlestir ve baslat
sudo systemctl daemon-reload
sudo systemctl enable nlp-api
sudo systemctl start nlp-api

# Durumu kontrol et
sudo systemctl status nlp-api
sudo journalctl -u nlp-api -f

Dikkat Edilmesi Gereken Noktalar

Hugging Face modellerini production’da kullanırken karşılaştığım bazı önemli sorunlar ve çözümleri:

• Token limiti: BART ve benzeri encoder-decoder modeller genellikle 512-1024 token ile sınırlı. Uzun belgeler için mutlaka chunking mekanizması yazın, aksi takdirde sessizce kesiyor.

• Dil karışması: Helsinki modellerinde kaynak ve hedef dil yanlış seçilirse anlamsız çıktı üretiyor, hata vermiyor. Kullanıcı girdisini validate edin.

• Bellek sızıntısı: Pipeline objelerini döngü içinde sürekli oluşturmayın. Bir kez oluşturup sınıf değişkeni olarak saklayın.

• GPU bellek yönetimi: torch.cuda.empty_cache() çağrısını uzun batch işlemler sonrasında yapmayı unutmayın.

• Model versiyonları: revision parametresiyle belirli bir model versiyonunu sabitleyin. Model güncellenmesi çıktı kalitesini değiştirebilir.

• Türkçe encoding: Türkçe karakterlerin doğru işlenmesi için her zaman encoding='utf-8' belirtin ve sentencepiece kütüphanesinin kurulu olduğundan emin olun.

• Ağ bağımlılığı: Air-gapped ortamlarda çalışıyorsanız modelleri TRANSFORMERS_OFFLINE=1 ortam değişkeniyle tamamen offline modda çalıştırabilirsiniz.

Sonuç

Hugging Face’in özetleme ve çeviri modelleri, günlük sysadmin iş akışına entegre edildiğinde ciddi zaman tasarrufu sağlıyor. İngilizce dokümantasyonu anında Türkçeye çevirmek, uzun hata raporlarını özetlemek ya da çok dilli loglarda anlam aramak artık dakikalar değil saniyeler alıyor.

Başlangıç için Helsinki-NLP’nin İngilizce-Türkçe modeli en pratik seçenek çünkü hızlı, hafif ve kurulumu kolay. Kalite önemliyse NLLB-200’e geçin. Özetleme için mT5 multilingual modeli Türkçe içerik üretiminde BART’tan belirgin biçimde üstün.

Önemli olan bu modelleri sistemin geri kalanıyla entegre edecek altyapıyı kurmak: önbellekleme, servis olarak çalıştırma, kaynak limitleri. Model seçimi ikincil geliyor, sağlam bir deployment altyapısı olmadan en iyi model bile production’da sorun çıkarır. Bu yazıdaki şablonları kendi ortamınıza uyarlayın ve ihtiyaçlarınıza göre genişletin.