Hugging Face Ekosistemi: Modeller, Datasetler ve Spaces

Yapay zeka dünyasına adım atan her sistem yöneticisinin eninde sonunda kapısına dayandığı bir yer var: Hugging Face. Başlangıçta sadece bir model deposu gibi görünse de aslında içine girdikçe genişleyen, araştırmacıdan hobiciye, startup’tan kurumsal şirkete kadar herkesin bir şeyler bulduğu bir ekosistem. Bu yazıda Hugging Face’in üç temel ayağını, yani Modeller, Datasetler ve Spaces’i, bir sysadmin gözüyle ele alacağız. Nasıl kullanılır, production ortamında nasıl entegre edilir, hangi tuzaklara dikkat etmek gerekir, bunların hepsini konuşacağız.

Hugging Face Nedir, Neden Önemli?

Hugging Face, 2016 yılında kurulmuş ve başlangıçta bir chatbot uygulaması olarak hayata geçmiş. Zamanla transformer modellerinin yükselişiyle birlikte dönüşüm geçirerek bugün yapay zeka topluluğunun GitHub’ı haline gelmiş bir platform. Üzerinde 500.000’den fazla model, 100.000’den fazla dataset ve binlerce Spaces uygulaması bulunuyor.

Bir sysadmin olarak neden ilgilenmeniz gerekiyor? Çünkü geliştirici ekipleriniz bu platformdan model indiriyor, veri çekiyor ve demo ortamları kuruyor. Bu trafiği yönetmek, önbelleğe almak, güvenlik açısından denetlemek ve kurumsal ortama entegre etmek artık bir sistem yöneticisinin sorumluluğu haline geldi.

Hub’a Bağlanmak: Temel Kurulum

Her şeyden önce huggingface_hub kütüphanesini ve transformers paketini kurmamız gerekiyor. Python ortamını izole tutmak için sanal ortam kullanmak şart.

# Python sanal ortamı oluştur
python3 -m venv hf-env
source hf-env/bin/activate

# Temel paketleri kur
pip install huggingface_hub transformers datasets torch

# CLI aracını da kur
pip install -U "huggingface_hub[cli]"

# Versiyon kontrolü
huggingface-cli --version

Kurulum tamamlandıktan sonra kimlik doğrulama adımına geçiyoruz. Kamuya açık modeller için token gerekmese de rate limit’e takılmamak ve özel modellere erişmek için mutlaka bir token almanız öneriliyor.

# Hugging Face hesabınızla giriş yapın
huggingface-cli login

# Token'ı environment variable olarak da tanımlayabilirsiniz
export HUGGINGFACE_TOKEN="hf_xxxxxxxxxxxxxxxxxxxx"

# Token'ı kalıcı hale getirmek için
echo 'export HUGGINGFACE_TOKEN="hf_xxxxxxxxxxxxxxxxxxxx"' >> ~/.bashrc
source ~/.bashrc

Token’larınızı asla kod içine gömmeden, her zaman environment variable veya secrets manager üzerinden yönetin. Bu, özellikle CI/CD pipeline’larında kritik bir kural.

Modeller: İndirmek, Yönetmek, Optimize Etmek

Model İndirme Stratejileri

Hugging Face üzerindeki modeller, genellikle PyTorch ağırlıkları, tokenizer dosyaları ve konfigürasyon json’larından oluşuyor. Bu dosyalar bazen onlarca gigabayta ulaşabiliyor. Llama 3 70B modeli yaklaşık 140 GB, Mistral 7B ise yaklaşık 14 GB disk alanı kaplıyor. Bu nedenle indirme stratejinizi önceden belirlemek önemli.

# Tek bir modeli CLI ile indirme
huggingface-cli download mistralai/Mistral-7B-v0.1

# Belirli bir klasöre indirme
huggingface-cli download mistralai/Mistral-7B-v0.1 
  --local-dir /data/models/mistral-7b 
  --local-dir-use-symlinks False

# Sadece belirli dosyaları indirme (tokenizer için)
huggingface-cli download mistralai/Mistral-7B-v0.1 
  --include "tokenizer*" "config.json" 
  --local-dir /data/models/mistral-7b-tokenizer

--local-dir-use-symlinks False parametresini kullanmak önemli çünkü varsayılan davranış, dosyaları cache dizinine koyup symlink oluşturmak. Production ortamlarında gerçek dosya kopyalarını tercih etmek, taşınabilirlik açısından daha güvenli.

Cache Yönetimi

Hugging Face varsayılan olarak ~/.cache/huggingface/hub dizinine indiriyor. Çok kullanıcılı sunucularda bu disk yönetimi sorunlarına yol açabiliyor.

# Cache konumunu değiştirmek için
export HF_HOME=/data/huggingface-cache
export HF_HUB_CACHE=/data/huggingface-cache/hub

# Bu değişkenleri sistem genelinde geçerli yapmak için
cat >> /etc/environment << EOF
HF_HOME=/data/huggingface-cache
HF_HUB_CACHE=/data/huggingface-cache/hub
EOF

# Cache içeriğini görüntüleme
huggingface-cli scan-cache

# Kullanılmayan modelleri temizleme
huggingface-cli delete-cache

Ekip ortamlarında ortak bir cache dizini tanımlamak, aynı modelin defalarca indirilmesini önlüyor. /data/shared-hf-cache gibi bir dizin oluşturup tüm kullanıcılara erişim vermek disk tasarrufu sağlıyor.

Python ile Programatik Model İndirme

# model_downloader.py
from huggingface_hub import snapshot_download, hf_hub_download
import os

def download_model(repo_id, local_dir, token=None):
    """
    Modeli güvenli şekilde indir ve doğrula
    """
    token = token or os.environ.get("HUGGINGFACE_TOKEN")
    
    print(f"İndiriliyor: {repo_id}")
    
    local_path = snapshot_download(
        repo_id=repo_id,
        local_dir=local_dir,
        token=token,
        ignore_patterns=["*.msgpack", "*.h5", "flax_model*"],  # Sadece PyTorch
        resume_download=True  # Yarıda kalan indirmeleri devam ettir
    )
    
    print(f"Model indirildi: {local_path}")
    return local_path

if __name__ == "__main__":
    download_model(
        repo_id="microsoft/phi-2",
        local_dir="/data/models/phi-2"
    )

Bu scripti bir systemd timer veya cron job ile birleştirerek model güncellemelerini otomatize edebilirsiniz.

Datasetler: Büyük Veri Yönetimi

Dataset İndirme ve Kullanım

Hugging Face Datasets kütüphanesi, büyük veri setlerini akış modunda işleyebilme yeteneği sayesinde RAM sınırlamalarını aşmanızı sağlıyor. 100 GB’lık bir dataset’i belleğe almak yerine streaming ile satır satır işleyebilirsiniz.

# dataset_stream.py
from datasets import load_dataset
import json

# Streaming modunda dataset yükle (RAM dostu)
dataset = load_dataset(
    "allenai/c4",
    "en",
    split="train",
    streaming=True,
    trust_remote_code=True
)

# İlk 1000 örneği işle ve kaydet
output_file = "/data/datasets/c4_sample.jsonl"
count = 0

with open(output_file, "w") as f:
    for example in dataset:
        if count >= 1000:
            break
        f.write(json.dumps(example, ensure_ascii=False) + "n")
        count += 1

print(f"{count} örnek kaydedildi: {output_file}")

Lokal Dataset Yönetimi

Kurumsal ortamlarda veri setlerini şirket içi depolarda tutmak gerekebiliyor. Hugging Face’in dataset formatını koruyarak kendi sunucunuza taşıyabilirsiniz.

# Dataset'i CLI ile indir
huggingface-cli download datasets/squad 
  --repo-type dataset 
  --local-dir /data/datasets/squad

# Dataset bilgilerini görüntüle
python3 -c "
from datasets import load_dataset
ds = load_dataset('/data/datasets/squad')
print(ds)
print(ds['train'].features)
print(f'Toplam örnek: {len(ds["train"])}')
"

Dataset Filtreleme ve Dönüştürme

# dataset_processor.py
from datasets import load_dataset, DatasetDict

def preprocess_dataset(dataset_path, output_path, min_length=50):
    """
    Dataset'i filtrele ve işle
    """
    print("Dataset yükleniyor...")
    dataset = load_dataset(dataset_path)
    
    def filter_examples(example):
        # Minimum uzunluk kontrolü
        text = example.get("text", "")
        return len(text) >= min_length
    
    def clean_text(example):
        # Metin temizleme
        text = example.get("text", "")
        example["text"] = text.strip().replace("x00", "")
        example["char_count"] = len(text)
        return example
    
    print("Filtreleniyor...")
    filtered = dataset.filter(
        filter_examples,
        num_proc=4  # Paralel işlem
    )
    
    print("Dönüştürülüyor...")
    processed = filtered.map(
        clean_text,
        num_proc=4
    )
    
    print(f"Kaydediliyor: {output_path}")
    processed.save_to_disk(output_path)
    
    print(f"Orijinal: {len(dataset['train'])} örnek")
    print(f"İşlenmiş: {len(processed['train'])} örnek")

preprocess_dataset(
    "/data/datasets/raw/mydataset",
    "/data/datasets/processed/mydataset"
)

Spaces: Demo ve Prodüksiyon Ortamları

Spaces Nedir?

Spaces, Hugging Face üzerinde çalışan uygulama hosting servisi. Gradio veya Streamlit uygulamalarını doğrudan Hub üzerinde çalıştırmanızı sağlıyor. Ücretsiz katmanda CPU ile sınırlı olsa da ücretli T4 GPU’ya kadar yükseltebiliyorsunuz.

Sysadmin açısından Spaces’in önemi şu: Geliştirici ekibiniz model demolarını Spaces üzerinde yayınlıyorsa, bu uygulamaların kaynak kullanımını, erişim kontrollerini ve veri akışını izlemeniz gerekiyor.

Spaces API ile Etkileşim

# spaces_client.py
from gradio_client import Client
import json

def query_space(space_url, input_text, timeout=60):
    """
    Hugging Face Space'e istek gönder
    """
    try:
        client = Client(space_url)
        
        # Space'in API endpoint'ini keşfet
        print("Mevcut endpoint'ler:")
        print(client.view_api())
        
        # Tahmin yap
        result = client.predict(
            input_text,
            api_name="/predict"
        )
        
        return result
    
    except Exception as e:
        print(f"Hata: {e}")
        return None

# Kullanım örneği
response = query_space(
    "https://huggingface.co/spaces/stabilityai/stable-diffusion",
    "a beautiful mountain landscape at sunset"
)
print(f"Sonuç: {response}")

Kendi Space’inizi Yönetmek

# Space repository'sini klonla
git clone https://huggingface.co/spaces/kullaniciadiniz/space-adiniz
cd space-adiniz

# Değişiklik yap ve push et
git add .
git commit -m "Model güncellendi"
git push

# Space durumunu API ile kontrol et
curl -H "Authorization: Bearer ${HUGGINGFACE_TOKEN}" 
  "https://huggingface.co/api/spaces/kullaniciadiniz/space-adiniz"

Kurumsal Ortam için Özel Hub Kurulumu

Çevrimdışı ve Air-Gapped Ortamlar

Pek çok kurumsal ortam internet erişimini kısıtlıyor. Bu durumda Hugging Face modellerini önce internete bağlı bir makinede indirip, ardından iç ağa aktarmanız gerekiyor.

# İnternet bağlantılı makinede modeli hazırla
huggingface-cli download meta-llama/Llama-3.2-3B 
  --local-dir /tmp/llama-3.2-3b 
  --local-dir-use-symlinks False

# Tüm dosyaları arşivle
tar -czf llama-3.2-3b.tar.gz -C /tmp llama-3.2-3b

# SHA256 checksum oluştur
sha256sum llama-3.2-3b.tar.gz > llama-3.2-3b.tar.gz.sha256

# İç ağ sunucusuna aktar (güvenli kanal üzerinden)
scp llama-3.2-3b.tar.gz user@internal-server:/data/models/
scp llama-3.2-3b.tar.gz.sha256 user@internal-server:/data/models/

# İç sunucuda doğrula ve aç
ssh user@internal-server
cd /data/models
sha256sum -c llama-3.2-3b.tar.gz.sha256
tar -xzf llama-3.2-3b.tar.gz

Offline Mod Aktivasyonu

# Hugging Face'in internet erişimini tamamen devre dışı bırak
export TRANSFORMERS_OFFLINE=1
export HF_DATASETS_OFFLINE=1
export HF_HUB_OFFLINE=1

# Bu ayarları systemd servis dosyasına ekle
cat > /etc/systemd/system/llm-service.service << EOF
[Unit]
Description=LLM Inference Service
After=network.target

[Service]
Type=simple
User=llm-user
Environment="TRANSFORMERS_OFFLINE=1"
Environment="HF_HUB_OFFLINE=1"
Environment="HF_HOME=/data/huggingface-cache"
ExecStart=/opt/llm-env/bin/python /opt/llm-service/app.py
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable llm-service
systemctl start llm-service

Model Güvenliği: Dikkat Edilmesi Gereken Noktalar

Hugging Face’den model indirmek, npm veya pip paket indirmekle benzer riskler taşıyor. Zararlı kod içeren modeller mevcut. Özellikle trust_remote_code=True parametresini kullanırken dikkatli olmak gerekiyor.

# Model dosyalarını indirmeden önce metadata kontrol et
curl -s "https://huggingface.co/api/models/mistralai/Mistral-7B-v0.1" | 
  python3 -c "
import sys, json
data = json.load(sys.stdin)
print('Model ID:', data.get('id'))
print('Downloads:', data.get('downloads'))
print('Likes:', data.get('likes'))
print('Created:', data.get('createdAt'))
print('Tags:', data.get('tags', []))
"

# Pickle güvenlik taraması için
pip install picklescan
picklescan --path /data/models/mistral-7b -r

Ayrıca indirilen modellerin SHA256 hash değerlerini Hugging Face’in sağladığı değerlerle karşılaştırmak iyi bir pratik.

Monitoring ve Gözlemlenebilirlik

Üretim ortamında model servislerini izlemek için basit bir health check ve metrik toplama mekanizması kurmak gerekiyor.

# health_check.py
import psutil
import torch
import time
from datetime import datetime

def check_system_resources():
    """
    Model servisi için sistem kaynaklarını kontrol et
    """
    report = {
        "timestamp": datetime.now().isoformat(),
        "cpu_percent": psutil.cpu_percent(interval=1),
        "ram_total_gb": round(psutil.virtual_memory().total / 1e9, 2),
        "ram_used_gb": round(psutil.virtual_memory().used / 1e9, 2),
        "ram_percent": psutil.virtual_memory().percent,
        "disk_free_gb": round(psutil.disk_usage('/data').free / 1e9, 2),
    }
    
    if torch.cuda.is_available():
        for i in range(torch.cuda.device_count()):
            props = torch.cuda.get_device_properties(i)
            used = torch.cuda.memory_allocated(i)
            total = props.total_memory
            report[f"gpu_{i}_name"] = props.name
            report[f"gpu_{i}_used_gb"] = round(used / 1e9, 2)
            report[f"gpu_{i}_total_gb"] = round(total / 1e9, 2)
            report[f"gpu_{i}_percent"] = round(used / total * 100, 2)
    
    return report

if __name__ == "__main__":
    import json
    resources = check_system_resources()
    print(json.dumps(resources, indent=2))
    
    # Kritik eşik uyarıları
    if resources["ram_percent"] > 90:
        print("UYARI: RAM kullanımı %90 üzerinde!")
    
    if resources["disk_free_gb"] < 20:
        print("UYARI: Disk alanı 20 GB'ın altına düştü!")

Bu scripti cron ile 5 dakikada bir çalıştırıp çıktıyı Prometheus veya InfluxDB’ye besleyebilirsiniz.

Gerçek Dünya Senaryosu: Şirket İçi Model Servisi

Diyelim ki bir fintech şirketinde çalışıyorsunuz ve müşteri destek ekibine yardımcı olacak bir LLM servisi kurmanız isteniyor. İşte adım adım yapılacaklar:

Adım 1: Uygun modeli seçin. 7B parametre civarı bir model, tüketici GPU’larında bile çalışabiliyor. Mistral 7B veya Llama 3.2 3B iyi başlangıç noktaları.

Adım 2: Modeli air-gapped ortam için hazırlayın, yukarıdaki yöntemle indirip transfer edin.

Adım 3: Quantization ile model boyutunu küçültün. 7B modeli INT4 quantization ile 4 GB’a kadar indirgemek mümkün.

Adım 4: vLLM veya Ollama gibi bir inference server kurun ve modeli buraya yükleyin.

Adım 5: Systemd servisi olarak çalıştırın, Nginx ile reverse proxy ekleyin ve monitoring kurun.

Bu pipeline’ın her adımında Hugging Face Hub’dan çektiğiniz bileşenler var: model ağırlıkları, tokenizer, konfigürasyon dosyaları. Bu varlıkları sürüm kontrolü altında tutmak ve her değişikliği kayıt altına almak, sorun giderme süreçlerini önemli ölçüde kolaylaştırıyor.

Sonuç

Hugging Face ekosistemi artık yalnızca araştırmacıların oyun bahçesi değil. Modeller, Datasetler ve Spaces üçlüsü, yapay zeka destekli sistemleri production’a taşımak için gereken altyapının önemli bir parçasını oluşturuyor. Sistem yöneticisi olarak bu platformla efektif çalışmak için birkaç kritik alışkanlık edinmek gerekiyor: cache yönetimini ihmal etmemek, güvenlik taramalarını indirme sürecine dahil etmek, offline ortamlar için hazırlıklı olmak ve model servislerini diğer kritik servisler gibi izlemek.

Platform hızla gelişiyor ve yeni özellikler sürekli ekleniyor. Özellikle Hub üzerindeki model kartlarını okuma alışkanlığı edinmek, bir modelin lisansını, kısıtlamalarını ve önerilen kullanım senaryolarını anlamak açısından hayat kurtarıcı. Ticari projelerde meta-llama/Llama gibi modelleri kullanmadan önce lisans koşullarını mutlaka incelemenizi öneririm.

Son olarak, Hugging Face’in kendi inference endpoint servisini de değerlendirmeye almanızı öneririm. Kendi sunucunuzu kurmak yerine, belirli model servislerini doğrudan Hugging Face’in altyapısında çalıştırmak bazen çok daha ekonomik ve pratik olabiliyor. Her iki yaklaşımın maliyet ve fayda analizini yapmak, doğru kararı vermenizi sağlayacaktır.