Update app.py

app.py

@@ -1,9 +1,8 @@
 import streamlit as st
 from transformers import (
     AutoTokenizer,
-    AutoModelForCausalLM,
-    TextIteratorStreamer,
-    AutoConfig
+    AutoModelForSeq2SeqLM,
+    TextIteratorStreamer
 )
 from huggingface_hub import login
 from threading import Thread
@@ -13,50 +12,27 @@ import torch
 import time
 import os
 
-# Check if 'peft' is installed
-try:
-    from peft import PeftModel, PeftConfig
-except ImportError:
-    raise ImportError(
-        "The 'peft' library is required but not installed. "
-        "Please install it using: `pip install peft`"
-    )
-
 # 🔐 Hugging Face Token via Environment Variable
 HF_TOKEN = os.environ.get("HF_TOKEN")
 if not HF_TOKEN:
     raise ValueError("Missing Hugging Face Token. Please set the HF_TOKEN environment variable.")
 
-# 🎛 Model base and adapters
-BASE_MODEL_NAME = "unicamp-dl/ptt5-base-portuguese-vocab" #"neuralmind/bert-base-portuguese-cased" #"pierreguillou/gpt2-small-portuguese" # #"mistralai/Mistral-7B-Instruct-v0.2"
-MODEL_OPTIONS = {
-    "Full Fine-Tuned": "amiguel/mistral-angolan-laborlaw-ptt5", #"amiguel/mistral-angolan-laborlaw-bert-base-pt", #"amiguel/mistral-angolan-laborlaw-gpt2",#, #"amiguel/mistral-angolan-laborlaw",
-    "LoRA Adapter": "amiguel/SmolLM2-360M-concise-reasoning-lora",
-    "QLoRA Adapter": "amiguel/SmolLM2-360M-concise-reasoning-qlora"
-}
-
+# ✅ Only PT-T5 Model
+MODEL_NAME = "amiguel/mistral-angolan-laborlaw-ptt5"
 
-# 🖼 UI Setup
+# UI Setup
 st.set_page_config(page_title="Assistente LGT | Angola", page_icon="🚀", layout="centered")
 st.title("🚀 Assistente LGT | Angola 🚀")
 
 USER_AVATAR = "https://raw.githubusercontent.com/achilela/vila_fofoka_analysis/9904d9a0d445ab0488cf7395cb863cce7621d897/USER_AVATAR.png"
 BOT_AVATAR = "https://raw.githubusercontent.com/achilela/vila_fofoka_analysis/991f4c6e4e1dc7a8e24876ca5aae5228bcdb4dba/Ataliba_Avatar.jpg"
 
-# Sidebar
+# Upload sidebar
 with st.sidebar:
-    st.header("Model Selection 🤖")
-    model_type = st.selectbox("Choose Model Type", list(MODEL_OPTIONS.keys()), index=0)
-    selected_model = MODEL_OPTIONS[model_type]
-
-    st.header("Upload Documents 📂")
-    uploaded_file = st.file_uploader("Choose a PDF or XLSX file", type=["pdf", "xlsx"], label_visibility="collapsed")
-
-# Chat memory
-if "messages" not in st.session_state:
-    st.session_state.messages = []
+    st.header("Upload Documentos 📂")
+    uploaded_file = st.file_uploader("Escolhe um ficheiro PDF ou XLSX", type=["pdf", "xlsx"], label_visibility="collapsed")
 
-# 🔍 File processing
+# Cache file processing
 @st.cache_data
 def process_file(uploaded_file):
     if uploaded_file is None:
@@ -69,57 +45,32 @@ def process_file(uploaded_file):
             df = pd.read_excel(uploaded_file)
             return df.to_markdown()
     except Exception as e:
-        st.error(f"📄 Error processing file: {str(e)}")
+        st.error(f"📄 Erro ao processar o ficheiro: {str(e)}")
         return ""
 
-# 🧠 Load model and tokenizer
+# Cache model loading
 @st.cache_resource
-def load_model(model_type, selected_model):
+def load_model():
     try:
         login(token=HF_TOKEN)
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float32
-
-        tokenizer = AutoTokenizer.from_pretrained(selected_model, token=HF_TOKEN)
-
-        if model_type == "Full Fine-Tuned":
-            model = AutoModelForCausalLM.from_pretrained(
-                selected_model,
-                device_map="auto",
-                torch_dtype=dtype,
-                token=HF_TOKEN
-            )
-        else:
-            base_model = AutoModelForCausalLM.from_pretrained(
-                BASE_MODEL_NAME,
-                device_map="auto",
-                torch_dtype=dtype,
-                token=HF_TOKEN
-            )
-            model = PeftModel.from_pretrained(
-                base_model,
-                selected_model,
-                is_trainable=False,
-                torch_dtype=dtype,
-                token=HF_TOKEN
-            )
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, token=HF_TOKEN, use_fast=False)
+        model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME, torch_dtype=torch.float32).to("cuda" if torch.cuda.is_available() else "cpu")
         return model, tokenizer
     except Exception as e:
-        st.error(f"🤖 Model loading failed: {str(e)}")
+        st.error(f"🤖 Erro ao carregar o modelo: {str(e)}")
         return None, None
 
-# 🚀 Generate response
-def generate_with_streaming(prompt, file_context, model, tokenizer):
-    full_prompt = f"Analisa este contexto:\n{file_context}\n\nPergunta: {prompt}\nResposta:"
-
-    inputs = tokenizer(full_prompt, return_tensors="pt")
-    inputs = {k: v.to(model.device) for k, v in inputs.items()}
+# Streaming response generation
+def generate_response(prompt, context, model, tokenizer):
+    full_prompt = f"Contexto:\n{context}\n\nPergunta: {prompt}\nResposta:"
 
+    inputs = tokenizer(full_prompt, return_tensors="pt", truncation=True).to(model.device)
     streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
-    gen_kwargs = {
+
+    generation_kwargs = {
         "input_ids": inputs["input_ids"],
         "attention_mask": inputs["attention_mask"],
-        "max_new_tokens": 1024,
+        "max_new_tokens": 512,
         "temperature": 0.7,
         "top_p": 0.9,
         "repetition_penalty": 1.1,
@@ -128,37 +79,38 @@ def generate_with_streaming(prompt, file_context, model, tokenizer):
         "streamer": streamer
     }
 
-    Thread(target=model.generate, kwargs=gen_kwargs).start()
+    Thread(target=model.generate, kwargs=generation_kwargs).start()
     return streamer
 
-# 🧾 Display chat history
-for msg in st.session_state.messages:
-    avatar = USER_AVATAR if msg["role"] == "user" else BOT_AVATAR
-    with st.chat_message(msg["role"], avatar=avatar):
-        st.markdown(msg["content"])
+# Store chat history
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# Show chat history
+for message in st.session_state.messages:
+    avatar = USER_AVATAR if message["role"] == "user" else BOT_AVATAR
+    with st.chat_message(message["role"], avatar=avatar):
+        st.markdown(message["content"])
 
-# 🔎 Main interaction loop
-if prompt := st.chat_input("Pergunta sobre a LGT?"):
-    # Display user message
+# Chat input
+if prompt := st.chat_input("Faca uma pergunta sobre a LGT..."):
     with st.chat_message("user", avatar=USER_AVATAR):
         st.markdown(prompt)
     st.session_state.messages.append({"role": "user", "content": prompt})
 
-    # Load model if needed
-    if "model" not in st.session_state or st.session_state.get("model_type") != model_type:
-        with st.spinner("🔄 A carregar modelo..."):
-            model, tokenizer = load_model(model_type, selected_model)
+    # Load model if not loaded
+    if "model" not in st.session_state:
+        with st.spinner("🔄 A carregar o modelo PT-T5..."):
+            model, tokenizer = load_model()
             if not model:
                 st.stop()
             st.session_state.model = model
             st.session_state.tokenizer = tokenizer
-            st.session_state.model_type = model_type
     else:
         model = st.session_state.model
         tokenizer = st.session_state.tokenizer
 
-    # Prepare context
-    file_context = process_file(uploaded_file) or "Sem contexto adicional disponível."
+    context = process_file(uploaded_file) or "Sem contexto adicional disponível."
 
     # Generate assistant response
     with st.chat_message("assistant", avatar=BOT_AVATAR):
@@ -166,13 +118,12 @@ if prompt := st.chat_input("Pergunta sobre a LGT?"):
         full_response = ""
         try:
             start_time = time.time()
-            streamer = generate_with_streaming(prompt, file_context, model, tokenizer)
+            streamer = generate_response(prompt, context, model, tokenizer)
 
             for chunk in streamer:
                 full_response += chunk.strip() + " "
                 response_box.markdown(full_response + "▌", unsafe_allow_html=True)
 
-            # Token and speed metrics
             end_time = time.time()
             input_tokens = len(tokenizer(prompt)["input_ids"])
             output_tokens = len(tokenizer(full_response)["input_ids"])
@@ -181,8 +132,8 @@ if prompt := st.chat_input("Pergunta sobre a LGT?"):
             cost_aoa = cost_usd * 1160
 
             st.caption(
-                f"🔑 Input Tokens: {input_tokens} | Output Tokens: {output_tokens} | "
-                f"🕒 Speed: {speed:.1f}t/s | 💰 USD: ${cost_usd:.4f} | 🇦🇴 AOA: {cost_aoa:.2f}"
+                f"🔑 Tokens: {input_tokens} → {output_tokens} | 🕒 Velocidade: {speed:.1f}t/s | "
+                f"💰 USD: ${cost_usd:.4f} | 🇦🇴 AOA: {cost_aoa:.2f}"
             )
 
             response_box.markdown(full_response.strip())