Update app.py

app.py

@@ -1,115 +1,128 @@
 import gradio as gr
 import torch
-from transformers import AutoTokenizer, AutoModelForCausalLM
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+import requests
 
-MODELS = [
-    "Smilyai-labs/Sam-reason-A1",
+# Verified existing SmilyAI models on Huggingface
+MODEL_CANDIDATES = [
     "Smilyai-labs/Sam-reason-S1",
     "Smilyai-labs/Sam-reason-S1.5",
-    "Smilyai-labs/Sam-reason-S2",
-    "Smilyai-labs/Sam-reason-S3",
+    "Smilyai-labs/Sam-reason-S2.1",
     "Smilyai-labs/Sam-reason-v1",
     "Smilyai-labs/Sam-reason-v2",
-    "Smilyai-labs/Sam-flash-mini-v1"
+    "Smilyai-labs/Sam-large-v1",
+    "Smilyai-labs/Sam-flash-mini-v1",
+    "Smilyai-labs/Sam-reason-A1"
 ]
 
+def model_exists(repo_id):
+    url = f"https://huggingface.co/api/models/{repo_id}"
+    try:
+        response = requests.get(url)
+        return response.status_code == 200
+    except Exception:
+        return False
+
+# Filter models that actually exist
+AVAILABLE_MODELS = [m for m in MODEL_CANDIDATES if model_exists(m)]
+
+if not AVAILABLE_MODELS:
+    raise RuntimeError("No verified SmilyAI models are available from Huggingface!")
+
 device = "cuda" if torch.cuda.is_available() else "cpu"
 
+# Globals to hold current model and tokenizer
 model = None
 tokenizer = None
+generator = None
 
 def load_model(model_name):
-    global model, tokenizer
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    model = AutoModelForCausalLM.from_pretrained(model_name).to(device)
-    model.eval()
-    return f"Loaded model: {model_name}"
-
-def build_prompt(chat_history):
+    global model, tokenizer, generator
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        model = AutoModelForCausalLM.from_pretrained(model_name).to(device)
+        model.eval()
+        # Use pipeline for generation with streaming support
+        generator = pipeline("text-generation", model=model, tokenizer=tokenizer, device=0 if device=="cuda" else -1)
+        return f"✅ Loaded model: {model_name} on {device}"
+    except Exception as e:
+        return f"❌ Failed to load model: {model_name}\n{str(e)}"
+
+def chat_stream(user_message, history, model_name):
+    global model, tokenizer, generator
+
+    if model is None or tokenizer is None or generator is None:
+        load_status = load_model(model_name)
+        if load_status.startswith("❌"):
+            yield history, load_status
+            return
+
+    if history is None:
+        history = []
+
+    # Append user input to history
+    history.append((user_message, ""))
+
+    # Prepare prompt with conversation history for multi-turn chat
     prompt = ""
-    for role, text in chat_history:
-        prompt += f"{role}: {text}\n"
-    prompt += "Assistant: "
-    return prompt
-
-def generate_stream(chat_history, max_length=100, temperature=0.7, top_p=0.9):
-    global model, tokenizer
-    if model is None or tokenizer is None:
-        yield "Model not loaded. Please select a model first."
-        return
-
-    prompt = build_prompt(chat_history)
-    input_ids = tokenizer(prompt, return_tensors="pt").input_ids.to(device)
-    generated_ids = input_ids
-    output_text = prompt
-
-    for _ in range(max_length):
-        outputs = model(generated_ids)
-        logits = outputs.logits
-        next_token_logits = logits[:, -1, :] / temperature
-
-        sorted_logits, sorted_indices = torch.sort(next_token_logits, descending=True)
-        cumulative_probs = torch.softmax(sorted_logits, dim=-1).cumsum(dim=-1)
-
-        sorted_indices_to_remove = cumulative_probs > top_p
-        sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
-        sorted_indices_to_remove[..., 0] = 0
-
-        filtered_logits = next_token_logits.clone()
-        filtered_logits[:, sorted_indices[sorted_indices_to_remove]] = -float('Inf')
-
-        probabilities = torch.softmax(filtered_logits, dim=-1)
-        next_token = torch.multinomial(probabilities, num_samples=1)
-        generated_ids = torch.cat([generated_ids, next_token], dim=-1)
-
-        new_token_text = tokenizer.decode(next_token[0])
-        output_text += new_token_text
-
-        assistant_reply = output_text.split("Assistant:")[-1].strip()
-
-        yield assistant_reply
-
-        if next_token.item() == tokenizer.eos_token_id:
-            break
-
-def chatbot_step(user_input, chat_history):
-    if not user_input.strip():
-        # Return chat_history and error message (no change to chat display)
-        return chat_history, chat_history
-
-    # Append user message to chat history
-    chat_history = chat_history + [("User", user_input)]
-
-    assistant_response = ""
-
-    def response_generator():
-        nonlocal assistant_response
-        for partial_reply in generate_stream(chat_history):
-            assistant_response = partial_reply
-            # Yield tuple: (chatbot content, updated state)
-            yield (chat_history + [("Assistant", assistant_response)], chat_history + [("Assistant", assistant_response)])
-
-    return response_generator()
+    for user, bot in history[:-1]:
+        prompt += f"User: {user}\nSam: {bot}\n"
+    prompt += f"User: {user_message}\nSam:"
+
+    # Streaming token generation
+    response_text = ""
+    try:
+        # Set parameters to generate text token by token
+        # Use generator with `stream=True` if supported (Huggingface pipeline streaming)
+        # Note: some transformers versions or models may not support streaming in pipeline.
+        # We'll simulate streaming here by chunking output.
+
+        # Generate full text first (fallback)
+        output = generator(prompt, max_new_tokens=128, do_sample=True, top_p=0.9, temperature=0.8)[0]['generated_text']
+
+        # Extract the new bot output (everything after prompt)
+        bot_reply = output[len(prompt):].strip()
+
+        # Stream output token-by-token to Gradio
+        for i in range(1, len(bot_reply)+1):
+            partial = bot_reply[:i]
+            history[-1] = (user_message, partial)
+            yield history, ""
+    except Exception as e:
+        history[-1] = (user_message, f"Error during generation: {str(e)}")
+        yield history, ""
+
+def reset_chat():
+    return [], ""
 
 with gr.Blocks() as demo:
-    gr.Markdown("# SmilyAI Sam Multi-turn Chatbot with Token Streaming")
+    gr.Markdown("# SmilyAI Sam Chatbot")
 
     with gr.Row():
-        model_selector = gr.Dropdown(choices=MODELS, value=MODELS[0], label="Select Model")
-        status = gr.Textbox(label="Status", interactive=False)
+        model_dropdown = gr.Dropdown(choices=AVAILABLE_MODELS, value=AVAILABLE_MODELS[0], label="Select Sam Model")
 
     chatbot = gr.Chatbot()
-    msg = gr.Textbox(label="Your message")
-    send_btn = gr.Button("Send")
+    state = gr.State([])  # conversation history
+    status = gr.Textbox(value="", interactive=False, visible=True, label="Status")
+
+    with gr.Row():
+        user_input = gr.Textbox(show_label=False, placeholder="Type your message and hit Enter", lines=2)
+        submit_btn = gr.Button("Send")
+
+    def on_submit(user_message, history, model_name):
+        return chat_stream(user_message, history, model_name)
 
-    # Load default model
-    status.value = load_model(MODELS[0])
+    submit_btn.click(on_submit, inputs=[user_input, state, model_dropdown], outputs=[chatbot, status], queue=True)
+    user_input.submit(on_submit, inputs=[user_input, state, model_dropdown], outputs=[chatbot, status], queue=True)
 
-    model_selector.change(lambda m: load_model(m), inputs=model_selector, outputs=status)
+    def on_model_change(new_model):
+        # Reload model on change, reset chat
+        status_message = load_model(new_model)
+        return [], status_message
 
-    state = gr.State([])
+    model_dropdown.change(on_model_change, inputs=model_dropdown, outputs=[chatbot, status])
 
-    send_btn.click(chatbot_step, inputs=[msg, state], outputs=[chatbot, state])
-    msg.submit(chatbot_step, inputs=[msg, state], outputs=[chatbot, state])
+    reset_btn = gr.Button("Reset Chat")
+    reset_btn.click(reset_chat, outputs=[chatbot, status])
 
 demo.launch()