Hugging Face Spaces ile Yapay Zeka Demo Yayınlama

Yazar:komut.io ekibi
0 Yorum

Bir yapay zeka modeli geliştirdiniz, eğittiniz veya fine-tune ettiniz. Şimdi ne yapacaksınız? Modeli sadece kendi makinenizde çalıştırmak yerine dünyayla paylaşmak, müşterilerinize demo göstermek veya topluluktan geri bildirim almak istiyorsunuz. İşte tam bu noktada Hugging Face Spaces devreye giriyor. Ücretsiz, hızlı ve son derece pratik bir platform olan Spaces, yapay zeka demolarını dakikalar içinde yayına almanızı sağlıyor. Bu yazıda sıfırdan başlayıp production-ready bir demo yayınlayana kadar her adımı ele alacağız.

Hugging Face Spaces Nedir?

Hugging Face Spaces, makine öğrenmesi modellerini ve yapay zeka uygulamalarını barındırmak için tasarlanmış ücretsiz bir hosting platformudur. Arkasında Docker konteynerleri çalışır ve siz sadece uygulama kodunuza odaklanırsınız. Altyapı, deployment, SSL sertifikası gibi her şeyle platform ilgilenir.

Spaces’in desteklediği üç ana framework vardır:

  • Gradio: Python ile hızlı UI bileşenleri oluşturmanızı sağlar, en popüler seçenek
  • Streamlit: Daha esnek ve özelleştirilebilir web arayüzleri için ideal
  • Docker: Tam kontrol isteyenler için, herhangi bir uygulama çalıştırabilirsiniz

Ücretsiz tier ile 16GB RAM ve 2 vCPU alıyorsunuz. GPU gerektiren modeller için ücretli tier’lar mevcut ancak çoğu demo için CPU yeterli.

Ön Gereksinimler

Başlamadan önce şunlara ihtiyacınız var:

  • Hugging Face hesabı (huggingface.co üzerinden ücretsiz)
  • Python 3.8+
  • Git ve git-lfs kurulu olmalı
  • Temel Gradio veya Streamlit bilgisi
# Git LFS kurulumu (Ubuntu/Debian)
sudo apt-get install git-lfs
git lfs install

# macOS için
brew install git-lfs
git lfs install

# Gerekli Python paketleri
pip install huggingface_hub gradio transformers torch

Hugging Face CLI ile Hesap Bağlantısı

Önce CLI üzerinden hesabınıza giriş yapın. Bu adım token yönetimi açısından kritik.

# HuggingFace CLI kurulumu
pip install huggingface_hub

# Giriş yapma
huggingface-cli login

# Token kontrolü
huggingface-cli whoami

# Alternatif olarak environment variable ile
export HUGGING_FACE_HUB_TOKEN="hf_xxxxxxxxxxxxxxxxxxxxx"

Token’ınızı huggingface.co/settings/tokens adresinden alabilirsiniz. Write yetkisi olan bir token oluşturmanız gerekiyor çünkü Space’e dosya push edeceksiniz.

İlk Space’i Oluşturma: Web Arayüzü

En basit yöntemden başlayalım. huggingface.co/new-space adresine gidin ve şunları doldurun:

  • Space adı: küçük harf, tire ile ayrılmış (örnek: my-sentiment-demo)
  • License: Apache 2.0 veya tercihlerinize göre
  • SDK: Gradio seçin
  • Hardware: CPU Basic (ücretsiz)

Space oluşturulduktan sonra bir repository açılır ve içinde örnek bir app.py ile requirements.txt göreceksiniz.

CLI ile Space Oluşturma

Web arayüzü yerine doğrudan komut satırından da Space oluşturabilirsiniz:

# Space oluşturma
huggingface-cli repo create my-ai-demo --type space --space_sdk gradio

# Repository'yi local'e klonlama
git clone https://huggingface.co/spaces/KULLANICI_ADINIZ/my-ai-demo
cd my-ai-demo

# Ya da Python API ile
python3 -c "
from huggingface_hub import HfApi
api = HfApi()
api.create_repo(
    repo_id='my-ai-demo',
    repo_type='space',
    space_sdk='gradio',
    private=False
)
print('Space oluşturuldu!')
"

Temel Gradio Uygulaması

Sentiment analizi yapan basit bir demo ile başlayalım. Bu, gerçek dünyada müşterilere ürün gösterimi için sıkça kullanılan bir senaryo.

# app.py
import gradio as gr
from transformers import pipeline

# Model yükleme - ilk çalıştırmada indirilir, sonra cache'lenir
sentiment_pipeline = pipeline(
    "sentiment-analysis",
    model="cardiffnlp/twitter-roberta-base-sentiment-latest"
)

def analyze_sentiment(text):
    if not text or len(text.strip()) == 0:
        return "Lütfen bir metin girin."
    
    result = sentiment_pipeline(text)[0]
    label = result['label']
    score = result['score']
    
    emoji_map = {
        "positive": "Pozitif",
        "negative": "Negatif", 
        "neutral": "Nötr"
    }
    
    label_tr = emoji_map.get(label.lower(), label)
    return f"Duygu: {label_tr}nGüven Skoru: {score:.2%}"

# Gradio arayüzü
demo = gr.Interface(
    fn=analyze_sentiment,
    inputs=gr.Textbox(
        placeholder="Analiz edilecek metni buraya yazın...",
        lines=3,
        label="Metin Girişi"
    ),
    outputs=gr.Textbox(label="Analiz Sonucu"),
    title="Türkçe Duygu Analizi Demo",
    description="Bu demo Twitter-RoBERTa modelini kullanarak metin duygu analizi yapar.",
    examples=[
        ["Bu ürün gerçekten harika, çok memnun kaldım!"],
        ["Berbat bir deneyimdi, kesinlikle tavsiye etmem."],
        ["Ürün beklediğim gibi geldi, fena değil."]
    ]
)

if __name__ == "__main__":
    demo.launch()
# requirements.txt
gradio==4.19.2
transformers==4.38.1
torch==2.2.0

Dosyaları Push Etme ve Deploy

Kod hazır olduğunda deployment son derece basit:

# Dosyaları ekle
git add app.py requirements.txt
git commit -m "İlk sentiment analizi demosu"

# Push et - otomatik build başlar
git push

# Push sırasında token gerekirse
git remote set-url origin https://KULLANICI_ADINIZ:[email protected]/spaces/KULLANICI_ADINIZ/my-ai-demo

Push ettikten sonra Hugging Face otomatik olarak build sürecini başlatır. Build loglarını Space sayfasından takip edebilirsiniz. İlk build genellikle 2-5 dakika sürer.

Daha Kapsamlı Bir Senaryo: LLM Chat Demo

Şimdi daha gerçekçi bir kullanım senaryosuna bakalım. Diyelim ki bir müşteri hizmetleri chatbotu demo’su hazırlıyorsunuz.

# app.py - Gelişmiş Chat Demo
import gradio as gr
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

MODEL_NAME = "microsoft/DialoGPT-medium"

tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)

def chat(message, history):
    # Conversation history'yi token'lara çevir
    conversation = ""
    for human, assistant in history[-3:]:  # Son 3 turu al
        conversation += f"User: {human}nBot: {assistant}n"
    conversation += f"User: {message}nBot:"
    
    inputs = tokenizer.encode(
        conversation,
        return_tensors="pt",
        max_length=512,
        truncation=True
    )
    
    with torch.no_grad():
        outputs = model.generate(
            inputs,
            max_new_tokens=150,
            pad_token_id=tokenizer.eos_token_id,
            temperature=0.7,
            do_sample=True,
            top_p=0.9
        )
    
    response_tokens = outputs[0][inputs.shape[1]:]
    response = tokenizer.decode(response_tokens, skip_special_tokens=True)
    
    # Boş yanıt kontrolü
    if not response.strip():
        response = "Üzgünüm, bu konuda yardımcı olamıyorum."
    
    return response

demo = gr.ChatInterface(
    fn=chat,
    title="Müşteri Hizmetleri Asistanı Demo",
    description="Bu demo, müşteri hizmetleri senaryoları için eğitilmiş bir dil modeli kullanır.",
    theme=gr.themes.Soft(),
    retry_btn="Tekrar Dene",
    undo_btn="Son Mesajı Geri Al",
    clear_btn="Temizle"
)

demo.launch(server_name="0.0.0.0", server_port=7860)

Secrets ve Environment Variables Yönetimi

Production demo’larında API key’leri ve hassas bilgileri kod içine gömmek güvenlik açığı oluşturur. Spaces bunun için Secrets özelliği sunuyor.

# Python API ile secret ekleme
python3 -c "
from huggingface_hub import HfApi
api = HfApi()

# Secret ekleme
api.add_space_secret(
    repo_id='KULLANICI_ADINIZ/my-ai-demo',
    key='OPENAI_API_KEY',
    value='sk-xxxxxxxxxxxxx'
)

# Space variable ekleme (gizli olmayan ayarlar için)
api.add_space_variable(
    repo_id='KULLANICI_ADINIZ/my-ai-demo',
    key='MAX_TOKENS',
    value='500'
)
"

Bu secret’lara uygulamadan şöyle erişirsiniz:

# app.py içinde environment variable kullanımı
import os
import openai
import gradio as gr

# Secret'ı environment variable olarak okuma
openai.api_key = os.getenv("OPENAI_API_KEY")
max_tokens = int(os.getenv("MAX_TOKENS", "200"))

def generate_response(prompt, system_prompt="Yardımcı bir asistansın."):
    if not openai.api_key:
        return "API anahtarı yapılandırılmamış."
    
    try:
        response = openai.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": prompt}
            ],
            max_tokens=max_tokens,
            temperature=0.7
        )
        return response.choices[0].message.content
    except Exception as e:
        return f"Hata oluştu: {str(e)}"

demo = gr.Interface(
    fn=generate_response,
    inputs=[
        gr.Textbox(label="Sorunuz", lines=3),
        gr.Textbox(
            label="Sistem Prompt",
            value="Yardımcı bir asistansın.",
            lines=2
        )
    ],
    outputs=gr.Textbox(label="Yanıt", lines=5),
    title="GPT-3.5 Demo"
)

demo.launch()

Streamlit ile Alternatif Yaklaşım

Bazı senaryolarda Gradio yerine Streamlit daha iyi bir seçim olabilir. Özellikle özel bileşenler, karmaşık layout veya sidebar gerektiren uygulamalarda Streamlit tercih edilir.

# app.py - Streamlit versiyonu
import streamlit as st
from transformers import pipeline
import time

st.set_page_config(
    page_title="AI Demo Platformu",
    page_icon="🤖",
    layout="wide"
)

@st.cache_resource
def load_model():
    return pipeline("summarization", model="facebook/bart-large-cnn")

def main():
    st.title("Metin Özetleme Demo")
    st.markdown("Bu uygulama BART modelini kullanarak uzun metinleri özetler.")
    
    with st.sidebar:
        st.header("Ayarlar")
        max_length = st.slider("Maksimum Özet Uzunluğu", 50, 300, 150)
        min_length = st.slider("Minimum Özet Uzunluğu", 20, 100, 50)
    
    col1, col2 = st.columns(2)
    
    with col1:
        st.subheader("Orijinal Metin")
        input_text = st.text_area(
            "Metni buraya yapıştırın:",
            height=300,
            placeholder="Özetlemek istediğiniz uzun metni buraya girin..."
        )
        word_count = len(input_text.split()) if input_text else 0
        st.caption(f"Kelime sayısı: {word_count}")
    
    with col2:
        st.subheader("Özet")
        if st.button("Özetle", type="primary"):
            if len(input_text.split()) < 50:
                st.warning("Lütfen en az 50 kelimelik bir metin girin.")
            else:
                with st.spinner("Özetleniyor..."):
                    summarizer = load_model()
                    start_time = time.time()
                    result = summarizer(
                        input_text,
                        max_length=max_length,
                        min_length=min_length,
                        do_sample=False
                    )
                    elapsed = time.time() - start_time
                    
                    summary = result[0]['summary_text']
                    st.text_area("Özet:", value=summary, height=200)
                    st.success(f"İşlem süresi: {elapsed:.2f} saniye")
                    
                    compression = (1 - len(summary.split()) / word_count) * 100
                    st.metric("Sıkıştırma Oranı", f"{compression:.1f}%")

if __name__ == "__main__":
    main()

Streamlit Space için requirements.txt dosyanıza streamlit eklemeyi ve Space ayarlarında SDK olarak Streamlit seçmeyi unutmayın.

Space Yeniden Başlatma ve Durum Yönetimi

Spaces, bir süre kullanılmadığında uyku moduna geçer. Bu normaldir ve ücretsiz tier’ın bir kısıtlamasıdır. Yönetimini otomatikleştirmek için:

# Space durumunu kontrol etme
python3 -c "
from huggingface_hub import HfApi
api = HfApi()

# Space runtime bilgisi
runtime = api.get_space_runtime('KULLANICI_ADINIZ/my-ai-demo')
print(f'Stage: {runtime.stage}')
print(f'Hardware: {runtime.hardware}')

# Space'i yeniden başlatma
api.restart_space('KULLANICI_ADINIZ/my-ai-demo')
print('Space yeniden başlatıldı.')
"

# Cron job ile Space'i aktif tutma (her 30 dakikada bir)
# crontab -e ile ekleyin:
# */30 * * * * curl -s https://KULLANICI_ADINIZ-my-ai-demo.hf.space/ > /dev/null

Build Sürecini Hızlandırma

Büyük modeller yüklenirken build süreleri uzayabilir. Birkaç optimizasyon tekniği:

# app.py - Lazy loading ile optimize edilmiş versiyon
import gradio as gr
from functools import lru_cache
import threading

_model = None
_model_lock = threading.Lock()

def get_model():
    global _model
    if _model is None:
        with _model_lock:
            if _model is None:
                from transformers import pipeline
                _model = pipeline(
                    "text-classification",
                    model="distilbert-base-uncased-finetuned-sst-2-english",
                    device=-1  # CPU kullan
                )
    return _model

def classify_text(text):
    if not text.strip():
        return "Metin boş olamaz."
    
    model = get_model()
    result = model(text[:512])[0]  # Max 512 token
    
    label = "Pozitif" if result['label'] == "POSITIVE" else "Negatif"
    return f"{label} ({result['score']:.2%})"

# Model'i arka planda önceden yükle
def preload_model():
    get_model()
    print("Model yüklendi ve hazır.")

threading.Thread(target=preload_model, daemon=True).start()

demo = gr.Interface(
    fn=classify_text,
    inputs=gr.Textbox(label="Metin", placeholder="Analiz edilecek metni girin..."),
    outputs=gr.Textbox(label="Sınıflandırma"),
    title="Metin Sınıflandırma"
)

demo.launch()

Sorun Giderme

Spaces ile çalışırken en sık karşılaşılan sorunlar ve çözümleri:

  • Build hatası – requirements.txt: Paket versiyonlarını pin’leyin, == operatörü kullanın, >= kullanmaktan kaçının
  • Out of Memory hatası: Model boyutunu küçültün, quantization uygulayın veya ücretli tier’a geçin
  • Space uyku modundan çıkmıyor: Space sayfasındaki “Restart this Space” butonunu kullanın veya API ile restart edin
  • CUDA bulunamadı hatası: CPU tier’da GPU kodu çalışmaz, device=-1 veya device="cpu" kullanın
  • Push rejected hatası: Token’ın write yetkisi olduğundan emin olun
  • Build timeout: Büyük bağımlılıkları dockerfile ile önbelleğe alın
# Build loglarını CLI ile takip etme
python3 -c "
from huggingface_hub import HfApi
api = HfApi()

# Build logları
for log in api.space_info('KULLANICI_ADINIZ/my-ai-demo').runtime.raw:
    print(log)
"

# Alternatif: curl ile log akışı
curl -H 'Authorization: Bearer hf_TOKEN' 
  'https://huggingface.co/api/spaces/KULLANICI_ADINIZ/my-ai-demo'

Özel Domain ve Embedding

Space’inizi kendi web sitenize veya müşteri portalına gömmek isteyebilirsiniz:

<!-- Web sitenize Space ekleme -->
<iframe
  src="https://KULLANICI_ADINIZ-my-ai-demo.hf.space"
  frameborder="0"
  width="850"
  height="650"
></iframe>

Space’i embed etmek için Space’in public olması gerekir. Private Space’leri embed etmek ücretli Pro hesap gerektirir.

Sonuç

Hugging Face Spaces, yapay zeka demolarını yayınlamak için gerçekten iyi düşünülmüş bir platform. Ücretsiz tier ile ciddi işler yapabilirsiniz: sentiment analizi, metin sınıflandırma, özetleme, çeviri gibi CPU bazlı modeller sorunsuz çalışır. GPU gerektiren büyük modeller için ücretli tier kaçınılmaz ama Gradio ve Streamlit’in sağladığı kolaylık göz önüne alındığında deployment maliyeti oldukça düşük kalıyor.

Sysadmin perspektifinden değerlendirdiğimde en çok beğendiğim özellikler şunlar: Git tabanlı deployment ile alışık olduğunuz workflow’u kullanabiliyorsunuz, Secrets yönetimi güvenli ve pratik, build logları şeffaf ve sorun giderme için yeterli bilgi sağlıyor. Ekip içi model paylaşımı için private Space’ler, dış dünyaya açık demolar için public Space’ler ideal bir denge sunuyor.

Eğer hâlâ lokal makinenizde geliştirdiğiniz modelleri kimseyle paylaşmıyorsanız, bu yazıdaki adımlarla bugün ilk Space’inizi yayınlayabilirsiniz. Birkaç dakika içinde kendinize ait çalışan bir yapay zeka demo URL’ine sahip olmak, hem motivasyon hem de geri bildirim açısından inanılmaz değerli.

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir