Gradio ile Yapay Zeka Modeline Web Arayüzü Ekleme

Yazar:komut.io ekibi
0 Yorum

Yapay zeka modelleriyle çalışırken en can sıkıcı kısım, her şeyi terminal üzerinden yapmak zorunda kalmaktır. Model çıktılarını test etmek için Python scripti yazmak, argümanları düzenlemek, sonuçları gözlemlemek… Bunlar zamanla yorucu hale gelir. İşte tam bu noktada Gradio devreye giriyor. Birkaç satır kodla modelinizin önüne şık bir web arayüzü koyabilir, hem kendiniz rahatça test edebilir hem de başkalarıyla paylaşabilirsiniz.

Gradio Nedir ve Neden Kullanmalısınız?

Gradio, Hugging Face tarafından geliştirilen ve Python ile yazılmış açık kaynaklı bir web arayüzü kütüphanesidir. Flask ya da FastAPI gibi tam anlamıyla bir web framework değildir; amacı sadece ML modellerini, API’leri veya herhangi bir Python fonksiyonunu hızlıca interaktif bir arayüze dönüştürmektir.

Neden tercih edilebilir?

  • Hız: Birkaç satır kodla çalışan bir demo hazırlayabilirsiniz
  • Paylaşım kolaylığı: Tek satırla Hugging Face Spaces’e deploy edebilirsiniz
  • Sıfır frontend bilgisi: HTML, CSS veya JavaScript bilmenize gerek yok
  • Geniş bileşen desteği: Metin, görüntü, ses, video, dosya gibi pek çok input/output tipi var
  • API otomatik oluşturma: Her Gradio uygulaması otomatik olarak bir REST API’ye dönüşüyor

Dezavantajı da var tabii. Üretim ortamı için fazla basit kalabilir, karmaşık UI akışlarını yönetmek zorlaşır. Ama prototipleme ve iç kullanım araçları için mükemmel.

Kurulum ve Ortam Hazırlığı

Önce temiz bir Python sanal ortamı oluşturalım. Bu adımı atlamayın, bağımlılık karmaşasından sonradan ağlarsınız.

# Python sanal ortamı oluştur
python3 -m venv gradio-env
source gradio-env/bin/activate  # Windows için: gradio-envScriptsactivate

# Gradio ve temel bağımlılıkları yükle
pip install gradio transformers torch accelerate

# Hugging Face Hub için
pip install huggingface_hub

# GPU kullanıyorsanız CUDA destekli PyTorch için
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

Kurulum tamamlandıktan sonra hızlı bir test yapalım:

python3 -c "import gradio as gr; print(f'Gradio versiyon: {gr.__version__}')"

İlk Gradio Uygulaması: Basit Bir Metin Modeli

Konuya girmeden önce Gradio’nun mantığını kavrayalım. Her şey bir Python fonksiyonu etrafında döner. Fonksiyonunuzu yazarsınız, Gradio bu fonksiyonu alır ve web arayüzüne dönüştürür.

import gradio as gr

def metin_isle(kullanici_girdisi):
    # Şu an sadece girdiyi büyük harfe çeviriyoruz
    # Buraya model entegrasyonu gelecek
    return kullanici_girdisi.upper()

demo = gr.Interface(
    fn=metin_isle,
    inputs=gr.Textbox(label="Metninizi girin", placeholder="Buraya yazın..."),
    outputs=gr.Textbox(label="Model çıktısı"),
    title="Basit Metin İşleme Demo",
    description="Bu demo, Gradio'nun temel kullanımını gösterir."
)

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

Bu scripti çalıştırdığınızda terminal size http://127.0.0.1:7860 adresini verecektir. Tarayıcınızdan bu adrese gittiğinizde arayüzü göreceksiniz. server_name="0.0.0.0" diyerek lokal ağdaki diğer cihazlardan da erişime açtık.

Hugging Face Modeli Entegrasyonu

Şimdi gerçek işe gelelim. Hugging Face’den bir metin üretme modeli çekip Gradio arayüzüne bağlayalım. Küçük boyutlu bir model olan distilgpt2 ile başlayalım, bu model test için idealdir.

import gradio as gr
from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
import torch

# Model yükleme - bu işlem ilk çalıştırmada modeli indirecek
print("Model yükleniyor...")
model_adi = "distilgpt2"

tokenizer = AutoTokenizer.from_pretrained(model_adi)
model = AutoModelForCausalLM.from_pretrained(
    model_adi,
    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
    device_map="auto"
)

# Pipeline oluştur
metin_uretici = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    device_map="auto"
)

def metin_uret(prompt, max_uzunluk, temperature, top_p):
    sonuc = metin_uretici(
        prompt,
        max_new_tokens=int(max_uzunluk),
        temperature=float(temperature),
        top_p=float(top_p),
        do_sample=True,
        pad_token_id=tokenizer.eos_token_id
    )
    return sonuc[0]["generated_text"]

# Gradio arayüzü
demo = gr.Interface(
    fn=metin_uret,
    inputs=[
        gr.Textbox(
            label="Başlangıç metni (prompt)",
            placeholder="Bir cümle ile başlayın...",
            lines=3
        ),
        gr.Slider(minimum=20, maximum=500, value=100, step=10,
                  label="Maksimum token sayısı"),
        gr.Slider(minimum=0.1, maximum=2.0, value=0.7, step=0.1,
                  label="Temperature (yaratıcılık seviyesi)"),
        gr.Slider(minimum=0.1, maximum=1.0, value=0.9, step=0.05,
                  label="Top-p (çekirdek örnekleme)")
    ],
    outputs=gr.Textbox(label="Üretilen metin", lines=10),
    title="GPT-2 Metin Üretici",
    description="Distil-GPT2 modeli ile metin üretme demosu"
)

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

Burada dikkat etmeniz gereken bir nokta var: model her istek geldiğinde yeniden yüklenmez, uygulama başlangıcında bir kez yüklenir ve bellekte kalır. Bu sayede ilk istek sonrasında yanıt süreleri oldukça kısalır.

Sohbet Arayüzü: ChatInterface Kullanımı

Tek seferlik metin üretmek yerine gerçek bir sohbet deneyimi istiyorsanız Gradio’nun ChatInterface bileşenini kullanmalısınız. Bu özellikle LLM’lerle çalışırken çok işe yarıyor.

import gradio as gr
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_adi = "microsoft/DialoGPT-medium"
print(f"{model_adi} modeli yükleniyor...")

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

def sohbet_et(mesaj, gecmis):
    # Konuşma geçmişini birleştir
    if gecmis:
        gecmis_metin = tokenizer.eos_token.join(
            [f"{k}: {c}" for k, c in gecmis]
        )
        tam_girdi = gecmis_metin + tokenizer.eos_token + mesaj
    else:
        tam_girdi = mesaj

    girdi_idleri = tokenizer.encode(
        tam_girdi + tokenizer.eos_token,
        return_tensors="pt"
    )

    # Maksimum context uzunluğunu aşmamak için kırp
    if girdi_idleri.shape[-1] > 1000:
        girdi_idleri = girdi_idleri[:, -1000:]

    with torch.no_grad():
        cikti = model.generate(
            girdi_idleri,
            max_new_tokens=150,
            pad_token_id=tokenizer.eos_token_id,
            do_sample=True,
            temperature=0.8,
            top_k=50
        )

    yanit = tokenizer.decode(
        cikti[:, girdi_idleri.shape[-1]:][0],
        skip_special_tokens=True
    )
    return yanit

demo = gr.ChatInterface(
    fn=sohbet_et,
    title="DialoGPT Sohbet Botu",
    description="Microsoft DialoGPT-medium modeli ile sohbet edin",
    theme=gr.themes.Soft(),
    examples=["Merhaba, nasılsın?", "Bugün hava nasıl?"]
)

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

Streaming ile Gerçek Zamanlı Yanıt

GPT tarzı modellerde kullanıcılar yanıtın kelime kelime gelmesini bekler, tüm çıktının birden gelmesi değil. Buna streaming deniyor ve Gradio bunu destekliyor.

import gradio as gr
from transformers import AutoTokenizer, TextIteratorStreamer
from transformers import AutoModelForCausalLM
import torch
from threading import Thread

model_adi = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_adi)
model = AutoModelForCausalLM.from_pretrained(model_adi)

def streaming_uret(prompt, max_token):
    girdi = tokenizer(prompt, return_tensors="pt")

    streamer = TextIteratorStreamer(
        tokenizer,
        skip_prompt=True,
        skip_special_tokens=True
    )

    uretim_parametreleri = dict(
        girdi,
        streamer=streamer,
        max_new_tokens=int(max_token),
        do_sample=True,
        temperature=0.7
    )

    # Üretimi ayrı bir thread'de başlat
    thread = Thread(target=model.generate, kwargs=uretim_parametreleri)
    thread.start()

    uretilen_metin = ""
    for yeni_metin in streamer:
        uretilen_metin += yeni_metin
        yield uretilen_metin  # Generator ile streaming

demo = gr.Interface(
    fn=streaming_uret,
    inputs=[
        gr.Textbox(label="Prompt", lines=2),
        gr.Slider(50, 300, value=100, label="Max token")
    ],
    outputs=gr.Textbox(label="Çıktı", lines=8),
    title="Streaming Metin Üretici"
)

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

yield kullanarak fonksiyonu bir generator’a dönüştürdük. Gradio bu generator’ı anlıyor ve her yield çıktısını arayüze anlık olarak gönderiyor.

Çoklu Model Desteği: Tabs Kullanımı

Birden fazla modeli tek bir arayüzde sunmak isteyebilirsiniz. Örneğin hem metin özetleme hem de sınıflandırma işlevi olan bir araç. Bunun için Gradio’nun Blocks API’sini kullanacağız.

import gradio as gr
from transformers import pipeline
import torch

# Modelleri başlangıçta yükle
print("Modeller yükleniyor...")
ozetleyici = pipeline("summarization", model="facebook/bart-large-cnn")
siniflandirici = pipeline("text-classification", model="distilbert-base-uncased-finetuned-sst-2-english")
ceviri = pipeline("translation_en_to_fr", model="Helsinki-NLP/opus-mt-en-fr")

def ozetle(metin, min_uzunluk, max_uzunluk):
    if len(metin.split()) < 30:
        return "Lütfen en az 30 kelimelik bir metin girin."
    sonuc = ozetleyici(metin, min_length=int(min_uzunluk),
                       max_length=int(max_uzunluk))
    return sonuc[0]["summary_text"]

def duygu_analiz(metin):
    sonuc = siniflandirici(metin)[0]
    etiket = "Olumlu" if sonuc["label"] == "POSITIVE" else "Olumsuz"
    return f"{etiket} (Güven skoru: {sonuc['score']:.2%})"

def ingilizce_fransizca(metin):
    sonuc = ceviri(metin)
    return sonuc[0]["translation_text"]

# Blocks ile çoklu tab arayüzü
with gr.Blocks(title="Çoklu NLP Aracı", theme=gr.themes.Base()) as demo:
    gr.Markdown("## NLP Araç Seti")
    gr.Markdown("Metin özetleme, duygu analizi ve çeviri araçlarını bir arada kullanın.")

    with gr.Tabs():
        with gr.TabItem("Metin Özetleme"):
            with gr.Row():
                ozet_girdi = gr.Textbox(label="Uzun metin", lines=8)
                ozet_cikti = gr.Textbox(label="Özet", lines=4)
            with gr.Row():
                min_len = gr.Slider(10, 50, value=20, label="Min uzunluk")
                max_len = gr.Slider(50, 300, value=150, label="Max uzunluk")
            ozet_btn = gr.Button("Özetle", variant="primary")
            ozet_btn.click(ozetle, inputs=[ozet_girdi, min_len, max_len],
                          outputs=ozet_cikti)

        with gr.TabItem("Duygu Analizi"):
            duygu_girdi = gr.Textbox(label="Analiz edilecek metin", lines=4)
            duygu_cikti = gr.Textbox(label="Sonuç")
            duygu_btn = gr.Button("Analiz Et", variant="primary")
            duygu_btn.click(duygu_analiz, inputs=duygu_girdi,
                           outputs=duygu_cikti)

        with gr.TabItem("İngilizce > Fransızca Çeviri"):
            ceviri_girdi = gr.Textbox(label="İngilizce metin", lines=4)
            ceviri_cikti = gr.Textbox(label="Fransızca çeviri", lines=4)
            ceviri_btn = gr.Button("Çevir", variant="primary")
            ceviri_btn.click(ingilizce_fransizca, inputs=ceviri_girdi,
                            outputs=ceviri_cikti)

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

Systemd ile Servis Olarak Çalıştırma

Geliştirme tamam, şimdi bu uygulamayı bir Linux sunucusunda kalıcı olarak nasıl çalıştırırsınız? Cevap her zamanki gibi: systemd servisi.

# Servis dosyası oluştur
sudo nano /etc/systemd/system/gradio-app.service
[Unit]
Description=Gradio Yapay Zeka Web Arayüzü
After=network.target

[Service]
Type=simple
User=www-data
WorkingDirectory=/opt/gradio-app
Environment="PATH=/opt/gradio-app/gradio-env/bin"
Environment="HF_HOME=/opt/gradio-app/model-cache"
ExecStart=/opt/gradio-app/gradio-env/bin/python app.py
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
# Servisi etkinleştir ve başlat
sudo systemctl daemon-reload
sudo systemctl enable gradio-app
sudo systemctl start gradio-app

# Durumu kontrol et
sudo systemctl status gradio-app

# Logları takip et
sudo journalctl -u gradio-app -f

Eğer uygulamayı Nginx arkasına almak istiyorsanız, reverse proxy ayarlarını da yapmanız gerekiyor:

# /etc/nginx/sites-available/gradio dosyasına ekleyin
server {
    listen 80;
    server_name your-domain.com;

    location / {
        proxy_pass http://127.0.0.1:7860;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_read_timeout 300s;
    }
}

Performans ve Bellek Yönetimi

Gradio ile çalışırken karşılaşılan en büyük sorun bellek yönetimidir. Bir model yüklediğinizde GPU veya RAM’i önemli ölçüde kullanır. Birden fazla kullanıcı aynı anda istek atarsa sorunlar çıkabilir.

Bazı pratik önlemler:

  • Kuyruk sistemi aktif edin: demo.queue(max_size=20) ile eş zamanlı istekleri sınırlayın. Bu olmadan sunucu aşırı yük altında çökebilir.
  • Model cache’leme: Modeli global değişken olarak tutun, her fonksiyon çağrısında yeniden yüklemeyin. Yukarıdaki örneklerde bunu zaten yaptık.
  • GPU bellek temizleme: Her işlem sonrasında torch.cuda.empty_cache() çağırmak bazı durumlarda yardımcı olur ama sihirli değnek değildir.
  • Concurrency limiti: demo.queue(concurrency_count=2) ile aynı anda kaç isteğin işleneceğini kontrol edin.
  • Model quantization: load_in_8bit=True veya load_in_4bit=True parametreleriyle modelleri daha az bellekle çalıştırabilirsiniz, bunun için bitsandbytes kütüphanesi gerekir.
  • HF_HOME değişkeni: Model cache klasörünü belirtin, disk dolmasına karşı önlem alın. Büyük modeller onlarca GB yer kaplayabilir.

Kimlik doğrulama eklemek de önemli. Kurumsal ortamda herkese açık bırakmak istemezsiniz:

# Temel HTTP auth için launch parametresi
demo.launch(
    server_name="0.0.0.0",
    server_port=7860,
    auth=[("admin", "gizli_sifre"), ("kullanici", "diger_sifre")],
    auth_message="Bu araç sadece yetkili personel içindir."
)

Sonuç

Gradio, yapay zeka modellerini hızlıca kullanılabilir araçlara dönüştürmenin en pratik yollarından biridir. Birkaç satır Python kodyla, frontend geliştirme deneyimine ihtiyaç duymadan, modellerinizi ekibinizle paylaşabilir veya müşterilere demo yapabilirsiniz.

Özetlemek gerekirse izlemeniz gereken yol şudur: Önce Hugging Face’den istediğiniz modeli pipeline ile çekip test edin, ardından Gradio arayüzünü ekleyin, sonra systemd ile servise alın. Bu üç adım çoğu kullanım senaryosunu karşılar. Ölçeklenmesi gereken production ortamları için Gradio yerine FastAPI üzerine kurulu özel bir servis daha uygun olabilir; ama prototipleme, iç araçlar ve küçük takımlar için Gradio neredeyse mükemmel bir çözümdür.

Bir sonraki adım olarak Hugging Face Spaces’e deploy etmeyi de inceleyebilirsiniz, tamamen ücretsiz ve tek satır komutla hallediliyor. Ama o ayrı bir yazının konusu.

Bir yanıt yazın

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