Update app.py

app.py

@@ -1,125 +1,106 @@
 import streamlit as st
+import pandas as pd
 import torch
 import requests
 import os
 from transformers import AutoTokenizer, AutoModelForCausalLM
 from huggingface_hub import login
-from transformers import AutoTokenizer, AutoModelForCausalLM
-from peft import PeftModel
-import torch
-
-@st.cache_resource
-def load_fingpt_lora():
-    base_model_id = "meta-llama/Llama-2-7b-hf"
-    lora_adapter_id = "FinGPT/fingpt-mt_llama2-7b_lora"
-    tokenizer = AutoTokenizer.from_pretrained(base_model_id, use_auth_token=HF_TOKEN)
-
-    base_model = AutoModelForCausalLM.from_pretrained(
-        base_model_id,
-        torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-        device_map="auto",
-        use_auth_token=HF_TOKEN
-    )
-
-    model = PeftModel.from_pretrained(base_model, lora_adapter_id, use_auth_token=HF_TOKEN)
-    return model, tokenizer
-
 
-# Load token from Hugging Face Space secrets
-HF_TOKEN = os.getenv("Allie", None)
+HF_TOKEN = os.getenv("Allie") or "<your_token_here>"
 if HF_TOKEN:
     login(HF_TOKEN)
 
-# === Available Models for Selection ===
+# Define model map
 model_map = {
-    "FinGPT LoRA" : {"id": "FinGPT/fingpt-mt_llama2-7b_lora", "local": True, "custom_loader": load_fingpt_lora},
-    "InvestLM (AWQ)": {"id": "yixuantt/InvestLM-mistral-AWQ", "local": False},
-    "FinLLaMA (LLaMA3.1-8B)": {"id": "us4/fin-llama3.1-8b", "local": False},
-    "FinanceConnect (13B)": {"id": "ceadar-ie/FinanceConnect-13B", "local": True},
-    "Sujet-Finance (8B)": {"id": "sujet-ai/Sujet-Finance-8B-v0.1", "local": True}
+    "InvestLM": {"id": "yixuantt/InvestLM-mistral-AWQ", "local": False},
+    "FinLLaMA": {"id": "us4/fin-llama3.1-8b", "local": False},
+    "FinanceConnect": {"id": "ceadar-ie/FinanceConnect-13B", "local": True},
+    "Sujet-Finance": {"id": "sujet-ai/Sujet-Finance-8B-v0.1", "local": True},
+    "FinGPT (LoRA)": {"id": "FinGPT/fingpt-mt_llama2-7b_lora", "local": True}  # Placeholder, special handling below
 }
 
-# === Load local models with caching ===
+# Load question list
+@st.cache_data
+def load_questions():
+    df = pd.read_csv("questions.csv")
+    return df["Question"].dropna().tolist()
+
+# Load local models
 @st.cache_resource
 def load_local_model(model_id):
     tokenizer = AutoTokenizer.from_pretrained(model_id, use_auth_token=HF_TOKEN)
     model = AutoModelForCausalLM.from_pretrained(
         model_id,
         torch_dtype=torch.float32,
-        device_map="auto" if torch.cuda.is_available() else None,
+        device_map="auto",
         use_auth_token=HF_TOKEN
     )
     return model, tokenizer
 
-# === Build system prompt for discursive answers ===
-def build_prompt(user_question):
-    return (
-        "You are FinGPT, a helpful and knowledgeable financial assistant. "
-        "You explain finance, controlling, and tax topics clearly, with examples when useful.\n\n"
-        f"User: {user_question.strip()}\n"
-        "FinGPT:"
-    )
+# Prompt template
+PROMPT_TEMPLATE = (
+    "You are FinGPT, a highly knowledgeable and reliable financial assistant.\n"
+    "Explain the following finance/tax/controlling question clearly, including formulas, examples, and reasons why it matters.\n"
+    "\n"
+    "Question: {question}\n"
+    "Answer:"
+)
 
-# === Clean repeated/extra outputs ===
-def clean_output(output_text):
-    parts = output_text.split("FinGPT:")
-    return parts[-1].strip() if len(parts) > 1 else output_text.strip()
-
-# === Generate with local model ===
+# Local generation
 def query_local_model(model_id, prompt):
     model, tokenizer = load_local_model(model_id)
     inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
     outputs = model.generate(
         **inputs,
-        max_new_tokens=300,
+        max_new_tokens=400,
         temperature=0.7,
-        top_k=50,
-        top_p=0.95,
+        top_p=0.9,
+        top_k=40,
         repetition_penalty=1.2,
         do_sample=True,
         pad_token_id=tokenizer.eos_token_id,
         eos_token_id=tokenizer.eos_token_id
     )
-    raw_output = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    return clean_output(raw_output)
+    return tokenizer.decode(outputs[0], skip_special_tokens=True)
 
-# === Generate with remote HF API ===
+# Remote HF inference
 def query_remote_model(model_id, prompt):
-    headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
-    payload = {"inputs": prompt, "parameters": {"max_new_tokens": 300}}
+    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+    payload = {"inputs": prompt, "parameters": {"max_new_tokens": 400}}
     response = requests.post(
         f"https://api-inference.huggingface.co/models/{model_id}",
         headers=headers,
         json=payload
     )
-    if response.status_code == 200:
-        result = response.json()
-        return result[0]["generated_text"] if isinstance(result, list) else result.get("generated_text", "No output")
-    else:
-        raise RuntimeError(f"API Error {response.status_code}: {response.text}")
-
-# === Unified model query handler ===
-def query_model(model_entry, user_question):
-    prompt = build_prompt(user_question)
-    if model_entry["local"]:
+    result = response.json()
+    return result[0]["generated_text"] if isinstance(result, list) else result.get("generated_text", "ERROR")
+
+# Route to appropriate model
+def query_model(model_entry, question):
+    prompt = PROMPT_TEMPLATE.format(question=question)
+    if model_entry["id"] == "FinGPT/fingpt-mt_llama2-7b_lora":
+        return "⚠️ FinGPT (LoRA) integration requires manual loading with PEFT and is not available via HF API."
+    elif model_entry["local"]:
         return query_local_model(model_entry["id"], prompt)
     else:
-        return clean_output(query_remote_model(model_entry["id"], prompt))
+        return query_remote_model(model_entry["id"], prompt)
 
-# === Streamlit UI Layout ===
-st.set_page_config(page_title="Finance LLM Comparison", layout="centered")
-st.title("💼 Financial LLM Evaluation Interface")
+# === UI ===
+st.set_page_config(page_title="Finanzmodell Tester", layout="centered")
+st.title("📊 Finanzmodell Vergleichs-Interface")
 
-model_choice = st.selectbox("Select a Financial Model", list(model_map.keys()))
-user_question = st.text_area("Enter your financial question:", "What is EBIT vs EBITDA?", height=150)
+questions = load_questions()
+question_choice = st.selectbox("Wähle eine Frage", questions)
+model_choice = st.selectbox("Wähle ein Modell", list(model_map.keys()))
 
-if st.button("Get Response"):
-    with st.spinner("Thinking like a CFO..."):
+if st.button("Antwort generieren"):
+    with st.spinner("Antwort wird generiert..."):
+        model_entry = model_map[model_choice]
         try:
-            model_entry = model_map[model_choice]
-            answer = query_model(model_entry, user_question)
-            st.text_area("💬 Response:", value=answer, height=300, disabled=True)
+            answer = query_model(model_entry, question_choice)
         except Exception as e:
-            st.error(f"❌ Error: {e}")
+            answer = f"[Fehler: {str(e)}]"
+        st.text_area("💬 Antwort des Modells:", value=answer, height=400, disabled=True)
+