add performance_tracker, pure llm w/o pandas bypass, full english

app.py

@@ -30,6 +30,7 @@ MODEL_CACHE = {
 
 # Create directories for user data
 os.makedirs("user_data", exist_ok=True)
+os.makedirs("performance_metrics", exist_ok=True)
 
 # Model configuration dictionary
 MODEL_CONFIG = {
@@ -40,7 +41,7 @@ MODEL_CONFIG = {
     },
     "TinyLlama Chat": {
         "name": "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF",
-        "description": "Model ringan dengan 1.1B parameter, cepat dan ringan",
+        "description": "Lightweight model with 1.1B parameters, fast and efficient",
         "dtype": torch.float16 if torch.cuda.is_available() else torch.float32
     },
     "Mistral Instruct": {
@@ -50,12 +51,12 @@ MODEL_CONFIG = {
     },
     "Phi-4 Mini Instruct": {
         "name": "microsoft/Phi-4-mini-instruct",
-        "description": "Model yang ringan dari Microsoft cocok untuk tugas instruksional",
+        "description": "Lightweight model from Microsoft suitable for instructional tasks",
         "dtype": torch.float16 if torch.cuda.is_available() else torch.float32
     },
     "DeepSeek Coder Instruct": {
         "name": "deepseek-ai/deepseek-coder-1.3b-instruct",
-        "description": "1.3B model untuk kode dan analisis data",
+        "description": "1.3B model for code and data analysis",
         "dtype": torch.float16 if torch.cuda.is_available() else torch.float32
     },
     "DeepSeek Lite Chat": {
@@ -81,6 +82,28 @@ MODEL_CONFIG = {
     }
 }
 
+# Performance metrics tracking
+class PerformanceTracker:
+    def __init__(self):
+        self.metrics_file = "performance_metrics/model_performance.csv"
+        
+        # Create metrics file if it doesn't exist
+        if not os.path.exists(self.metrics_file):
+            with open(self.metrics_file, "w") as f:
+                f.write("timestamp,model,question,processing_time,response_length\n")
+    
+    def log_performance(self, model_name, question, processing_time, response):
+        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        response_length = len(response)
+        
+        with open(self.metrics_file, "a") as f:
+            f.write(f'"{timestamp}","{model_name}","{question}",{processing_time},{response_length}\n')
+        
+        print(f"Logged performance for {model_name}: {processing_time:.2f}s")
+
+# Initialize performance tracker
+performance_tracker = PerformanceTracker()
+
 def initialize_model_once(model_key):
     with MODEL_CACHE["init_lock"]:
         current_model = MODEL_CACHE["model_name"]
@@ -99,20 +122,20 @@ def initialize_model_once(model_key):
             try:
                 print(f"Loading model: {model_name}")
                 
-                # Periksa apakah ini model GGUF
+                # Check if this is a GGUF model
                 if "GGUF" in model_name:
-                    # Download model file terlebih dahulu jika belum ada
+                    # Download the model file first if it doesn't exist
                     from huggingface_hub import hf_hub_download
                     try:
-                        # Coba temukan file GGUF di repo
+                        # Try to find the GGUF file in the repo
                         repo_id = model_name
                         model_path = hf_hub_download(
                             repo_id=repo_id, 
-                            filename="model.gguf"  # Nama file dapat berbeda
+                            filename="model.gguf"  # File name may differ
                         )
                     except Exception as e:
                         print(f"Couldn't find model.gguf, trying other filenames: {str(e)}")
-                        # Coba cari file GGUF dengan nama lain
+                        # Try to find GGUF file with other names
                         import requests
                         from huggingface_hub import list_repo_files
                         
@@ -122,17 +145,17 @@ def initialize_model_once(model_key):
                         if not gguf_files:
                             raise ValueError(f"No GGUF files found in {repo_id}")
                         
-                        # Gunakan file GGUF pertama yang ditemukan
+                        # Use first GGUF file found
                         model_path = hf_hub_download(repo_id=repo_id, filename=gguf_files[0])
                     
-                    # Load model GGUF dengan llama-cpp-python
+                    # Load GGUF model with llama-cpp-python
                     MODEL_CACHE["model"] = Llama(
                         model_path=model_path,
-                        n_ctx=2048,  # Konteks yang lebih kecil untuk penghematan memori
+                        n_ctx=2048,  # Smaller context for memory savings
                         n_batch=512,
-                        n_threads=2  # Sesuaikan dengan 2 vCPU
+                        n_threads=2  # Adjust for 2 vCPU
                     )
-                    MODEL_CACHE["tokenizer"] = None  # GGUF tidak membutuhkan tokenizer terpisah
+                    MODEL_CACHE["tokenizer"] = None  # GGUF doesn't need separate tokenizer
                     MODEL_CACHE["is_gguf"] = True
                 
                 # Handle T5 models
@@ -148,21 +171,34 @@ def initialize_model_once(model_key):
                     
                 # Handle standard HF models
                 else:
-                    quantization_config = BitsAndBytesConfig(
-                        load_in_4bit=True,
-                        bnb_4bit_compute_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                        bnb_4bit_quant_type="nf4",
-                        bnb_4bit_use_double_quant=True
-                    )
-                    MODEL_CACHE["tokenizer"] = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
-                    MODEL_CACHE["model"] = AutoModelForCausalLM.from_pretrained(
-                        model_name,
-                        quantization_config=quantization_config,
-                        torch_dtype=model_info["dtype"],
-                        device_map="auto" if torch.cuda.is_available() else None,
-                        low_cpu_mem_usage=True,
-                        trust_remote_code=True
-                    )
+                    # Only use quantization if CUDA is available
+                    if torch.cuda.is_available():
+                        quantization_config = BitsAndBytesConfig(
+                            load_in_4bit=True,
+                            bnb_4bit_compute_dtype=torch.float16,
+                            bnb_4bit_quant_type="nf4",
+                            bnb_4bit_use_double_quant=True
+                        )
+                        
+                        MODEL_CACHE["tokenizer"] = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+                        MODEL_CACHE["model"] = AutoModelForCausalLM.from_pretrained(
+                            model_name,
+                            quantization_config=quantization_config,
+                            torch_dtype=model_info["dtype"],
+                            device_map="auto",
+                            low_cpu_mem_usage=True,
+                            trust_remote_code=True
+                        )
+                    else:
+                        # For CPU-only environments, load without quantization
+                        MODEL_CACHE["tokenizer"] = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+                        MODEL_CACHE["model"] = AutoModelForCausalLM.from_pretrained(
+                            model_name,
+                            torch_dtype=torch.float32,  # Use float32 for CPU
+                            device_map=None,
+                            low_cpu_mem_usage=True,
+                            trust_remote_code=True
+                        )
                     MODEL_CACHE["is_gguf"] = False
                     
                 print(f"Model {model_name} loaded successfully")
@@ -180,17 +216,20 @@ def create_llm_pipeline(model_key):
         print(f"Creating pipeline for model: {model_key}")
         tokenizer, model, is_gguf = initialize_model_once(model_key)
 
+        # Get the model info for reference
+        model_info = MODEL_CONFIG[model_key]
+        
         if model is None:
             raise ValueError(f"Model is None for {model_key}")
 
         # For GGUF models from llama-cpp-python
         if is_gguf:
-            # Buat adaptor untuk menggunakan model GGUF seperti HF pipeline
+            # Create adapter to use GGUF model like HF pipeline
             from langchain.llms import LlamaCpp
             llm = LlamaCpp(
                 model_path=model.model_path,
                 temperature=0.3,
-                max_tokens=128,
+                max_tokens=256,  # Increased for more comprehensive answers
                 top_p=0.9,
                 n_ctx=2048,
                 streaming=False
@@ -198,13 +237,13 @@ def create_llm_pipeline(model_key):
             return llm
             
         # Create appropriate pipeline for HF models
-        elif getattr(model_info, "is_t5", False):
+        elif model_info.get("is_t5", False):
             print("Creating T5 pipeline")
             pipe = pipeline(
                 "text2text-generation",
                 model=model,
                 tokenizer=tokenizer,
-                max_new_tokens=128,
+                max_new_tokens=256,  # Increased for more comprehensive answers
                 temperature=0.3,
                 top_p=0.9,
                 return_full_text=False,
@@ -215,7 +254,7 @@ def create_llm_pipeline(model_key):
                 "text-generation",
                 model=model,
                 tokenizer=tokenizer,
-                max_new_tokens=128,
+                max_new_tokens=256,  # Increased for more comprehensive answers
                 temperature=0.3,
                 top_p=0.9,
                 top_k=30,
@@ -229,6 +268,7 @@ def create_llm_pipeline(model_key):
         import traceback
         print(f"Error creating pipeline: {str(e)}")
         print(traceback.format_exc())
+        raise RuntimeError(f"Failed to create pipeline: {str(e)}")
 
 def handle_model_loading_error(model_key, session_id):
     """Handle model loading errors by providing alternative model suggestions"""
@@ -244,113 +284,73 @@ def handle_model_loading_error(model_key, session_id):
         suggested_models.remove(model_key)
     
     suggestions = ", ".join(suggested_models[:3])  # Only show top 3 suggestions
-    return None, f"Tidak dapat memuat model {model_key}. Silakan coba model lain seperti: {suggestions}"
+    return None, f"Unable to load model {model_key}. Please try another model such as: {suggestions}"
         
 def create_conversational_chain(db, file_path, model_key):
     llm = create_llm_pipeline(model_key)
     
-    # Load the file into pandas to enable code execution for data analysis
+    # Load the file into pandas to get metadata about the CSV
     df = pd.read_csv(file_path)
     
-    # Create improved prompt template that focuses on direct answers, not code
+    # Create improved prompt template that focuses on pure LLM analysis
     template = """
-    Berikut ini adalah informasi tentang file CSV:
-    
-    Kolom-kolom dalam file: {columns}
-    
-    Beberapa baris pertama:
+    You are an expert data analyst tasked with answering questions about a CSV file. The file has been analyzed, and its structure is provided below.
+
+    CSV File Structure:
+    - Total rows: {row_count}
+    - Total columns: {column_count}
+    - Columns: {columns_list}
+
+    Sample data (first few rows):
     {sample_data}
-    
-    Konteks tambahan dari vector database:
+
+    Additional context from the document:
     {context}
-    
-    Pertanyaan: {question}
-    
-    INSTRUKSI PENTING:
-    1. Jangan tampilkan kode Python, berikan jawaban langsung dalam Bahasa Indonesia.
-    2. Jika pertanyaan terkait statistik data (rata-rata, maksimum dll), lakukan perhitungan dan berikan hasilnya.
-    3. Jawaban harus singkat, jelas dan akurat berdasarkan data yang ada.
-    4. Gunakan format yang sesuai untuk angka (desimal 2 digit untuk nilai non-integer).
-    5. Jangan menyebutkan proses perhitungan, fokus pada hasil akhir.
-    
-    Jawaban:
+
+    User Question: {question}
+
+    IMPORTANT INSTRUCTIONS:
+    1. Answer the question directly about the CSV data with accurate information.
+    2. If asked for basic statistics (mean, sum, max, min, count, etc.), perform the calculation mentally and provide the result. Include up to 2 decimal places for non-integer values.
+    3. If asked about patterns or trends, analyze the data thoughtfully.
+    4. Keep answers concise but informative. Respond in the same language as the question.
+    5. If you are not certain of a precise answer, explain what you can determine from the available data.
+    6. You can perform simple calculations including: counts, sums, averages, minimums, maximums, and basic filtering.
+    7. For questions about specific values in the data, reference the sample data and available context.
+    8. Do not mention any programming language or how you would code the solution.
+
+    Your analysis:
     """
     
     PROMPT = PromptTemplate(
         template=template,
-        input_variables=["columns", "sample_data", "context", "question"]
+        input_variables=["row_count", "column_count", "columns_list", "sample_data", "context", "question"]
     )
     
     # Create retriever
-    retriever = db.as_retriever(search_kwargs={"k": 3})  # Reduced k for better performance
+    retriever = db.as_retriever(search_kwargs={"k": 5})  # Increase k for better context
     
     # Process query with better error handling
     def process_query(query, chat_history):
         try:
+            start_time = time.time()
+            
             # Get information from dataframe for context
-            columns_str = ", ".join(df.columns.tolist())
-            sample_data = df.head(2).to_string()  # Reduced to 2 rows for performance
+            columns_list = ", ".join(df.columns.tolist())
+            sample_data = df.head(5).to_string()  # Show 5 rows for better context
+            row_count = len(df)
+            column_count = len(df.columns)
             
             # Get context from vector database
             docs = retriever.get_relevant_documents(query)
             context = "\n\n".join([doc.page_content for doc in docs])
             
-            # Dynamically calculate answers for common statistical queries
-            def preprocess_query():
-                query_lower = query.lower()
-                result = None
-                
-                # Handle statistical queries directly
-                if "rata-rata" in query_lower or "mean" in query_lower or "average" in query_lower:
-                    for col in df.columns:
-                        if col.lower() in query_lower and pd.api.types.is_numeric_dtype(df[col]):
-                            try:
-                                result = f"Rata-rata {col} adalah {df[col].mean():.2f}"
-                            except:
-                                pass
-                
-                elif "maksimum" in query_lower or "max" in query_lower or "tertinggi" in query_lower:
-                    for col in df.columns:
-                        if col.lower() in query_lower and pd.api.types.is_numeric_dtype(df[col]):
-                            try:
-                                result = f"Nilai maksimum {col} adalah {df[col].max():.2f}"
-                            except:
-                                pass
-                
-                elif "minimum" in query_lower or "min" in query_lower or "terendah" in query_lower:
-                    for col in df.columns:
-                        if col.lower() in query_lower and pd.api.types.is_numeric_dtype(df[col]):
-                            try:
-                                result = f"Nilai minimum {col} adalah {df[col].min():.2f}"
-                            except:
-                                pass
-                
-                elif "total" in query_lower or "jumlah" in query_lower or "sum" in query_lower:
-                    for col in df.columns:
-                        if col.lower() in query_lower and pd.api.types.is_numeric_dtype(df[col]):
-                            try:
-                                result = f"Total {col} adalah {df[col].sum():.2f}"
-                            except:
-                                pass
-                
-                elif "baris" in query_lower or "jumlah data" in query_lower or "row" in query_lower:
-                    result = f"Jumlah baris data adalah {len(df)}"
-                
-                elif "kolom" in query_lower or "field" in query_lower:
-                    if "nama" in query_lower or "list" in query_lower or "sebutkan" in query_lower:
-                        result = f"Kolom dalam data: {', '.join(df.columns.tolist())}"
-                
-                return result
-            
-            # Try direct calculation first
-            direct_answer = preprocess_query()
-            if direct_answer:
-                return {"answer": direct_answer}
-            
-            # If no direct calculation, use the LLM
+            # Run the chain
             chain = LLMChain(llm=llm, prompt=PROMPT)
             raw_result = chain.run(
-                columns=columns_str,
+                row_count=row_count,
+                column_count=column_count,
+                columns_list=columns_list,
                 sample_data=sample_data,
                 context=context,
                 question=query
@@ -361,14 +361,28 @@ def create_conversational_chain(db, file_path, model_key):
             
             # If result is empty after cleaning, use a fallback
             if not cleaned_result:
-                return {"answer": "Tidak dapat memproses jawaban. Silakan coba pertanyaan lain."}
+                cleaned_result = "I couldn't process a complete answer to your question. Please try asking in a different way or provide more specific details about what you'd like to know about the data."
+            
+            processing_time = time.time() - start_time
+            
+            # Log performance metrics
+            performance_tracker.log_performance(
+                model_key, 
+                query, 
+                processing_time, 
+                cleaned_result
+            )
+            
+            # Add processing time to the response for comparison purposes
+            result_with_metrics = f"{cleaned_result}\n\n[Processing time: {processing_time:.2f} seconds]"
                 
-            return {"answer": cleaned_result}
+            return {"answer": result_with_metrics}
+            
         except Exception as e:
             import traceback
             print(f"Error in process_query: {str(e)}")
             print(traceback.format_exc())
-            return {"answer": f"Terjadi kesalahan saat memproses pertanyaan: {str(e)}"}
+            return {"answer": f"An error occurred while processing your question: {str(e)}"}
     
     return process_query
 
@@ -387,7 +401,7 @@ class ChatBot:
             self.model_key = model_key
         
         if file is None:
-            return "Mohon upload file CSV terlebih dahulu."
+            return "Please upload a CSV file first."
 
         try:
             print(f"Processing file using model: {self.model_key}")
@@ -410,7 +424,7 @@ class ChatBot:
                 print(f"CSV saved to {user_file_path}")
             except Exception as e:
                 print(f"Error reading CSV: {str(e)}")
-                return f"Error membaca CSV: {str(e)}"
+                return f"Error reading CSV: {str(e)}"
 
             # Load document with reduced chunk size for better memory usage
             try:
@@ -451,20 +465,20 @@ class ChatBot:
                 return f"Error creating chain: {str(e)}"
 
             # Add basic file info to chat history for context
-            file_info = f"CSV berhasil dimuat dengan {df.shape[0]} baris dan {len(df.columns)} kolom menggunakan model {self.model_key}. Kolom: {', '.join(df.columns.tolist())}"
+            file_info = f"CSV successfully loaded with {df.shape[0]} rows and {len(df.columns)} columns using model {self.model_key}. Columns: {', '.join(df.columns.tolist())}"
             self.chat_history.append(("System", file_info))
 
-            return f"File CSV berhasil diproses dengan model {self.model_key}! Anda dapat mulai chat dengan model untuk analisis data."
+            return f"CSV file successfully processed with model {self.model_key}! You can now chat with the model to analyze the data."
         except Exception as e:
             import traceback
             print(traceback.format_exc())
-            return f"Error pemrosesan file: {str(e)}"
+            return f"File processing error: {str(e)}"
 
     def change_model(self, model_key):
         """Change the model being used and recreate the chain if necessary"""
         try:
             if model_key == self.model_key:
-                return f"Model {model_key} sudah digunakan."
+                return f"Model {model_key} is already in use."
             
             print(f"Changing model from {self.model_key} to {model_key}")
             self.model_key = model_key
@@ -475,7 +489,7 @@ class ChatBot:
                     # Load existing database
                     db_path = f"{self.user_dir}/db_faiss"
                     if not os.path.exists(db_path):
-                        return f"Error: Database tidak ditemukan. Silakan upload file CSV kembali."
+                        return f"Error: Database not found. Please upload the CSV file again."
                 
                     print(f"Loading embeddings from {db_path}")
                     embeddings = HuggingFaceEmbeddings(
@@ -483,7 +497,7 @@ class ChatBot:
                         model_kwargs={'device': 'cpu'}
                     )
                 
-                    # Tambahkan flag allow_dangerous_deserialization=True
+                    # Add allow_dangerous_deserialization=True flag
                     db = FAISS.load_local(db_path, embeddings, allow_dangerous_deserialization=True)
                     print(f"FAISS database loaded successfully")
                 
@@ -493,38 +507,38 @@ class ChatBot:
                     print(f"Chain created successfully")
                 
                     # Add notification to chat history
-                    self.chat_history.append(("System", f"Model berhasil diubah ke {model_key}."))
+                    self.chat_history.append(("System", f"Model successfully changed to {model_key}."))
                 
-                    return f"Model berhasil diubah ke {model_key}."
+                    return f"Model successfully changed to {model_key}."
                 except Exception as e:
                     import traceback
                     error_trace = traceback.format_exc()
                     print(f"Detailed error in change_model: {error_trace}")
-                    return f"Error mengubah model: {str(e)}"
+                    return f"Error changing model: {str(e)}"
             else:
                 # Just update the model key if no file is loaded yet
                 print(f"No CSV file loaded yet, just updating model preference to {model_key}")
-                return f"Model diubah ke {model_key}. Silakan upload file CSV untuk memulai."
+                return f"Model changed to {model_key}. Please upload a CSV file to begin."
         except Exception as e:
             import traceback
             error_trace = traceback.format_exc()
             print(f"Unexpected error in change_model: {error_trace}")
-            return f"Error tidak terduga saat mengubah model: {str(e)}"
+            return f"Unexpected error while changing model: {str(e)}"
 
     def chat(self, message, history):
         if self.chain is None:
-            return "Mohon upload file CSV terlebih dahulu."
+            return "Please upload a CSV file first."
 
         try:
             # Process the question with the chain
             result = self.chain(message, self.chat_history)
 
             # Get the answer with fallback
-            answer = result.get("answer", "Maaf, tidak dapat menghasilkan jawaban. Silakan coba pertanyaan lain.")
+            answer = result.get("answer", "Sorry, I couldn't generate an answer. Please try asking a different question.")
 
             # Ensure we never return empty
             if not answer or answer.strip() == "":
-                answer = "Maaf, tidak dapat menghasilkan jawaban yang sesuai. Silakan coba pertanyaan lain."
+                answer = "Sorry, I couldn't generate an appropriate answer. Please try asking the question differently."
             
             # Update internal chat history
             self.chat_history.append((message, answer))
@@ -553,7 +567,7 @@ def create_gradio_interface():
         with gr.Row():
             with gr.Column(scale=1):
                 with gr.Group():
-                    gr.Markdown("### Langkah 1: Pilih Model AI")
+                    gr.Markdown("### Step 1: Choose AI Model")
                     model_dropdown = gr.Dropdown(
                         label="Model",
                         choices=model_choices,
@@ -565,28 +579,28 @@ def create_gradio_interface():
                     )
                 
                 with gr.Group():
-                    gr.Markdown("### Langkah 2: Unggah dan Proses CSV")
+                    gr.Markdown("### Step 2: Upload and Process CSV")
                     file_input = gr.File(
                         label="Upload CSV Anda",
                         file_types=[".csv"]
                     )
-                    process_button = gr.Button("Proses CSV")
+                    process_button = gr.Button("Process CSV")
                 
-                reset_button = gr.Button("Reset Sesi (Untuk Ganti Model)")
+                reset_button = gr.Button("Reset Session (To Change Model)")
 
             with gr.Column(scale=2):
                 chatbot_interface = gr.Chatbot(
-                    label="Riwayat Chat",
+                    label="Chat History",
                     # type="messages",
                     height=400
                 )
                 message_input = gr.Textbox(
-                    label="Ketik pesan Anda",
-                    placeholder="Tanyakan tentang data CSV Anda...",
+                    label="Type your message",
+                    placeholder="Ask questions about your CSV data...",
                     lines=2
                 )
-                submit_button = gr.Button("Kirim")
-                clear_button = gr.Button("Bersihkan Chat")
+                submit_button = gr.Button("Send")
+                clear_button = gr.Button("Clear Chat")
 
         # Update model info when selection changes
         def update_model_info(model_key):
@@ -601,7 +615,7 @@ def create_gradio_interface():
         # Process file handler - disables model selection after file is processed
         def handle_process_file(file, model_key, sess_id):
             if file is None:
-                return None, None, False, "Mohon upload file CSV terlebih dahulu."
+                return None, None, False, "Please upload a CSV file first."
         
             try:
                 chatbot = ChatBot(sess_id, model_key)
@@ -611,6 +625,8 @@ def create_gradio_interface():
                 import traceback
                 print(f"Error processing file with {model_key}: {str(e)}")
                 print(traceback.format_exc())
+                error_msg = f"Error with model {model_key}: {str(e)}\n\nPlease try another model."
+                return None, False, [(None, error_msg)]
 
         process_button.click(
             fn=handle_process_file,
@@ -641,7 +657,7 @@ def create_gradio_interface():
         def bot_response(history, chatbot, sess_id):
             if chatbot is None:
                 chatbot = ChatBot(sess_id)
-                history[-1] = (history[-1][0], "Mohon upload file CSV terlebih dahulu.")
+                history[-1] = (history[-1][0], "Please upload a CSV file first.")
                 return chatbot, history
 
             user_message = history[-1][0]