app.py

"""

🚀 Nova AI - Hugging Face Spaces ZeroGPU

Teknova tarafından geliştirilen özgün yapay zeka modeli

ZeroGPU ile hızlandırılmış

"""

import gradio as gr
import torch
import os
import logging
import time
import spaces
from typing import List, Tuple

# Logging setup
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Global variables
model = None
tokenizer = None
device = "cuda" if torch.cuda.is_available() else "cpu"

def load_demo_responses():
    """

    Demo yanıtları - model yokken kullanılacak

    """
    demo_responses = {
        "merhaba": "Merhaba! Ben Nova AI, Teknova'nın özgün yapay zeka teknolojisi. Size nasıl yardımcı olabilirim?",
        "nasılsın": "Ben Nova AI'yım ve harika hissediyorum! Sizinle sohbet etmek için buradayım. Ne konuşmak istersiniz?",
        "nova ai nedir": "Nova AI, Teknova tarafından geliştirilen özgün bir yapay zeka modelidir. Türkçe konuşabilir ve çeşitli konularda yardımcı olabilirim.",
        "teknova": "Teknova, Türkiye'nin öncü yapay zeka teknoloji şirketidir. Özgün AI çözümleri geliştiriyoruz.",
        "yapay zeka": "Yapay zeka, bilgisayarların insan benzeri düşünme ve öğrenme yetenekleri göstermesidir. Ben de bir yapay zeka örneğiyim!",
        "projeler": "Size yenilikçi proje fikirleri önerebilirim: AI chatbot, veri analizi, web uygulaması, mobil uygulama gibi...",
        "gelecek": "Gelecekte yapay zeka, otonom araçlar, akıllı şehirler ve personalize eğitim gibi alanlarda devrim yaratacak!"
    }
    return demo_responses

def generate_demo_response(message: str) -> str:
    """

    Demo yanıt oluştur (model olmadığında)

    """
    message_lower = message.lower().strip()
    demo_responses = load_demo_responses()
    
    # Exact match
    if message_lower in demo_responses:
        return demo_responses[message_lower]
    
    # Partial match
    for key, response in demo_responses.items():
        if key in message_lower:
            return response
    
    # Default responses
    if "?" in message:
        return f"'{message}' hakkında çok ilginç bir soru sordunuz! Nova AI olarak elimden geldiğince yardımcı olmaya çalışırım. Bu konuda daha spesifik sorular sorabilirsiniz."
    
    return f"Nova AI burada! '{message}' konusunda konuşmak güzel. Size nasıl yardımcı olabilirim? Daha detaylı sorular sorabilirsiniz."

def chat_response(message: str, history: List[List[str]], max_length: int, temperature: float) -> Tuple[str, List[List[str]]]:
    """

    Chat response function

    """
    if not message.strip():
        return "", history
    
    # Simulate thinking time
    time.sleep(0.5)
    
    # Generate response
    if model and tokenizer:
        # Gerçek model ile yanıt (model yüklü ise)
        try:
            response = generate_real_response(message, max_length, temperature)
        except Exception as e:
            response = f"Model hatası: {str(e)} - Demo moduna geçiliyor..."
            response += "\n\n" + generate_demo_response(message)
    else:
        # Demo yanıt
        response = generate_demo_response(message)
        response += "\n\n💡 *Not: Bu demo modunda çalışıyor. Gerçek Nova AI modeli yüklendiğinde daha gelişmiş yanıtlar alacaksınız.*"
    
    # Add to history
    history.append([message, response])
    return "", history

@spaces.GPU
def generate_real_response(message: str, max_length: int, temperature: float) -> str:
    """

    Gerçek model ile yanıt oluştur - ZeroGPU destekli

    """
    if not model or not tokenizer:
        return generate_demo_response(message)
    
    try:
        inputs = tokenizer.encode(message, return_tensors="pt")
        if device == "cuda":
            inputs = inputs.to(device)
        
        with torch.no_grad():
            outputs = model.generate(
                inputs,
                max_length=max_length,
                temperature=temperature,
                do_sample=True,
                pad_token_id=tokenizer.eos_token_id,
                no_repeat_ngram_size=3,
                top_p=0.9
            )
        
        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
        if message in response:
            response = response.replace(message, "").strip()
        
        return response if response else generate_demo_response(message)
        
    except Exception as e:
        logger.error(f"Model generation error: {e}")
        return generate_demo_response(message)

@spaces.GPU
def load_model():
    """

    Teknova Nova AI modelini yükle - ZeroGPU destekli

    """
    global model, tokenizer
    
    try:
        from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
        
        # Model path - Local model kullan
        model_path = "./nova-ai-small"
        
        # Eğer local model yoksa, demo modunda çalış
        if not os.path.exists(model_path):
            logger.info("⚠️ Local model bulunamadı, demo modunda çalışacak")
            return "⚠️ Demo modunda çalışıyor"
        
        logger.info(f"🚀 Teknova Nova AI modeli yükleniyor: {model_path}")
        
        # Tokenizer yükle
        tokenizer = AutoTokenizer.from_pretrained(
            model_path, 
            trust_remote_code=True,
            use_fast=True
        )
        
        # Pad token ayarla
        if tokenizer.pad_token is None:
            tokenizer.pad_token = tokenizer.eos_token
        
        # Model yükle - ZeroGPU optimizasyonu
        model = AutoModelForCausalLM.from_pretrained(
            model_path,
            device_map="auto",
            trust_remote_code=True,
            torch_dtype=torch.float16,
            low_cpu_mem_usage=True
        )
        
        logger.info(f"✅ Nova AI model yüklendi ({device})")
        return f"✅ Teknova Nova AI hazır! ({device})"
        
    except Exception as e:
        logger.error(f"Model yükleme hatası: {e}")
        return f"❌ Model yüklenemedi: {str(e)} - Demo modunda çalışacak"

@spaces.GPU
def chat_with_nova(message: str, history: List[Tuple[str, str]]) -> str:
    """

    Nova AI ile sohbet et - ZeroGPU destekli

    """
    global model, tokenizer
    
    if model is None or tokenizer is None:
        # Demo yanıt ver
        return generate_demo_response(message) + "\n\n💡 *Not: Demo modunda çalışıyor.*"
    
    if not message.strip():
        return "❓ Lütfen bir mesaj yazın."
    
    try:
        # Konuşma geçmişini hazırla
        conversation = ""
        for user_msg, bot_msg in history:
            if user_msg and bot_msg:
                conversation += f"Kullanıcı: {user_msg}\nNova AI: {bot_msg}\n"
        
        # Yeni mesajı ekle
        conversation += f"Kullanıcı: {message}\nNova AI:"
        
        # Tokenize et
        inputs = tokenizer(
            conversation, 
            return_tensors="pt", 
            truncation=True, 
            max_length=2048,
            padding=True
        )
        
        # GPU'ya taşı
        if torch.cuda.is_available():
            inputs = {k: v.to(model.device) for k, v in inputs.items()}
        
        # Yanıt üret
        with torch.no_grad():
            outputs = model.generate(
                **inputs,
                max_new_tokens=256,
                temperature=0.7,
                top_p=0.9,
                do_sample=True,
                pad_token_id=tokenizer.pad_token_id,
                eos_token_id=tokenizer.eos_token_id,
                repetition_penalty=1.1
            )
        
        # Yanıtı decode et
        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
        
        # Sadece yeni üretilen kısmı al
        new_response = response[len(conversation):].strip()
        
        return new_response if new_response else "Üzgünüm, yanıt üretemedi."
        
    except Exception as e:
        logger.error(f"Chat hatası: {e}")
        return f"❌ Yanıt üretirken hata: {str(e)}"

# Model yüklemeyi başlat
logger.info("Model yükleme başlatılıyor...")
load_status = load_model()
logger.info(f"Model durumu: {load_status}")

# Gradio arayüzü
with gr.Blocks(
    theme=gr.themes.Soft(),
    title="Teknova Nova AI - ZeroGPU",
    css="""

    .gradio-container {

        max-width: 900px;

        margin: 0 auto;

    }

    .header-text {

        text-align: center;

        padding: 20px;

        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);

        color: white;

        border-radius: 15px;

        margin-bottom: 20px;

    }

    """
) as demo:
    
    # Header
    gr.HTML("""

    <div class="header-text">

        <h1 style="font-size: 2.5rem; margin: 0; font-weight: bold;">

            🚀 Teknova Nova AI

        </h1>

        <p style="font-size: 1.2rem; margin: 10px 0; opacity: 0.9;">

            Türkiye'nin Özgün Yapay Zeka Modeli

        </p>

        <div style="background: rgba(255,255,255,0.2); padding: 8px 16px; border-radius: 20px; display: inline-block; font-size: 0.9rem;">

            🧠 Nova AI • 🇹�� Türkçe Optimize • ⚡ ZeroGPU Hızlı

        </div>

    </div>

    """)
    
    # Chat interface
    chatbot = gr.Chatbot(
        height=500,
        show_label=False,
        show_share_button=True,
        show_copy_button=True,
        avatar_images=[None, "🤖"],
        bubble_full_width=False
    )
    
    with gr.Row():
        msg = gr.Textbox(
            placeholder="Nova AI'ya mesajınızı yazın... (Örn: Merhaba, nasılsın?)",
            show_label=False,
            scale=4,
            container=False
        )
        submit = gr.Button("🚀 Gönder", scale=1, variant="primary")
    
    with gr.Row():
        clear = gr.Button("🗑️ Temizle", scale=1)
        retry = gr.Button("🔄 Tekrar Dene", scale=1)
    
    # Examples
    gr.Examples(
        examples=[
            "Merhaba Nova AI, nasılsın?",
            "Yapay zeka nedir?",
            "Teknova hakkında bilgi ver",
            "Bana bir hikaye anlat",
            "Python programlama hakkında bilgi ver"
        ],
        inputs=msg,
        label="💡 Örnek Sorular"
    )
    
    # Footer
    gr.HTML("""

    <div style="text-align: center; padding: 15px; color: #666; font-size: 0.9rem;">

        <p>🌟 <strong>Teknova Nova AI</strong> - Tamamen özgün Türkçe dil modeli</p>

        <p>🚀 ZeroGPU teknolojisi ile hızlandırılmış</p>

        <p style="color: #999;">⚡ Teknova Innovation ile güçlendirilmiştir</p>

    </div>

    """)
    
    # Event handlers
    def user_message(message, history):
        return "", history + [[message, None]]
    
    @spaces.GPU
    def bot_message(history):
        """Bot yanıtı oluştur - ZeroGPU destekli"""
        if history and history[-1][1] is None:
            user_msg = history[-1][0]
            bot_response = chat_with_nova(user_msg, history[:-1])
            history[-1][1] = bot_response
        return history
    
    @spaces.GPU
    def retry_last(history):
        """Son mesajı yeniden dene - ZeroGPU destekli"""
        if history and history[-1][1] is not None:
            user_msg = history[-1][0]
            bot_response = chat_with_nova(user_msg, history[:-1])
            history[-1][1] = bot_response
        return history
    
    # Event bindings
    msg.submit(user_message, [msg, chatbot], [msg, chatbot], queue=False).then(
        bot_message, chatbot, chatbot
    )
    submit.click(user_message, [msg, chatbot], [msg, chatbot], queue=False).then(
        bot_message, chatbot, chatbot
    )
    clear.click(lambda: None, None, chatbot, queue=False)
    retry.click(retry_last, chatbot, chatbot)

# Launch
if __name__ == "__main__":
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False,
        show_error=True
    )