Update app.py

app.py

@@ -7,41 +7,82 @@ import threading
 import psutil
 import random
 from transformers import pipeline
-from sklearn.metrics import precision_score, recall_score, f1_score
+from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score
 import requests
 from datasets import load_dataset
 import os
+from logging import FileHandler
+from __future__ import annotations
+from typing import Iterable
+from gradio.themes.base import Base
+from gradio.themes.utils import colors, fonts, sizes
 
-# --- Ensure chat_log.txt exists ---
-log_file = "chat_log.txt"
-try:
-    if not os.path.exists(log_file):
-        with open(log_file, 'w') as f:
-            f.write("Log file created.\n")  # Write a simple message to the log file
-    print(f"{log_file} is ready for logging.")
-except Exception as e:
-    print(f"Error creating log file: {e}")
 
-# --- Logging Setup ---
-try:
-    logging.basicConfig(filename=log_file, level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
-    logging.debug("Logging setup complete.")
-except Exception as e:
-    print(f"Error setting up logging: {e}")
+# Ensure the log files exist
+log_file_path = 'chat_log.log'
+debug_log_file_path = 'debug.log'
+if not os.path.exists(log_file_path):
+    with open(log_file_path, 'w') as f:
+        f.write(" ")
+if not os.path.exists(debug_log_file_path):
+    with open(debug_log_file_path, 'w') as f:
+        f.write(" ")
+
+
+# Create logger instance
+logger = logging.getLogger()
+logger.setLevel(logging.DEBUG)  # Set logger level to the lowest level needed
+
+#Create formatter
+formatter = logging.Formatter(
+    '%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S')
+
+# Create handlers
+info_handler = FileHandler( filename=log_file_path,  mode='w+')
+info_handler.setLevel(logging.INFO)
+info_handler.setFormatter(formatter)
+
+debug_handler = FileHandler(filename=debug_log_file_path, mode='w+')
+debug_handler.setLevel(logging.DEBUG)
+debug_handler.setFormatter(formatter)
+
+
+# Function to capture logs for Gradio display
+class GradioHandler(logging.Handler):
+    def __init__(self, logs_queue):
+        super().__init__()
+        self.logs_queue = logs_queue
+
+    def emit(self, record):
+        log_entry = self.format(record)
+        self.logs_queue.put(log_entry)
+
+# Create a logs queue
+logs_queue = Queue()
+
+# Create and configure Gradio handler
+gradio_handler = GradioHandler(logs_queue)
+gradio_handler.setLevel(logging.INFO)
+gradio_handler.setFormatter(formatter)
+
+# Add handlers to the logger
+logger.addHandler(info_handler)
+logger.addHandler(debug_handler)
+logger.addHandler(gradio_handler)
 
 # Load the model
 try:
     ner_pipeline = pipeline("ner", model="Sevixdd/roberta-base-finetuned-ner")
-    logging.debug("NER pipeline loaded.")
+    logger.debug("NER pipeline loaded.")
 except Exception as e:
-    logging.error(f"Error loading NER pipeline: {e}")
+    logger.debug(f"Error loading NER pipeline: {e}")
 
 # Load the dataset
 try:
     dataset = load_dataset("surrey-nlp/PLOD-filtered")
-    logging.debug("Dataset loaded.")
+    logger.debug("Dataset loaded.")
 except Exception as e:
-    logging.error(f"Error loading dataset: {e}")
+    logger.debug(f"Error loading dataset: {e}")
 
 # --- Prometheus Metrics Setup ---
 try:
@@ -52,14 +93,13 @@ try:
     CPU_USAGE = Gauge('system_cpu_usage_percent', 'System CPU usage in percent')
     MEM_USAGE = Gauge('system_memory_usage_percent', 'System memory usage in percent')
     QUEUE_LENGTH = Gauge('chat_queue_length', 'Length of the chat queue')
-    logging.debug("Prometheus metrics setup complete.")
+    logger.debug("Prometheus metrics setup complete.")
 except Exception as e:
-    logging.error(f"Error setting up Prometheus metrics: {e}")
+    logger.debug(f"Error setting up Prometheus metrics: {e}")
 
 # --- Queue and Metrics ---
 chat_queue = Queue()  # Define chat_queue globally
 
-# Label mapping
 label_mapping = {
     0: 'B-O',
     1: 'B-AC',
@@ -67,26 +107,10 @@ label_mapping = {
     4: 'I-LF'
 }
 
-# --- Chat Function with Monitoring ---
-def chat_function(index):
-    logging.debug("Starting chat_function")
-    with REQUEST_LATENCY.time():
-        REQUEST_COUNT.inc()
-        try:
-            chat_queue.put(index)
-            logging.info(f"Received index from user: {index}")
-
-            # Get the example from the dataset
-            example = dataset['train'][int(index)]
-            tokens = example['tokens']
-            ground_truth_labels = [label_mapping[label] for label in example['ner_tags']]
-
-            logging.info(f"Tokens: {tokens}")
-            logging.info(f"Ground Truth Labels: {ground_truth_labels}")
 
-            # Predict using the model
-            ner_results = ner_pipeline(" ".join(tokens))
-            logging.debug(f"NER results: {ner_results}")
+def classification(message):
+    # Predict using the model
+            ner_results = ner_pipeline(" ".join(message))
 
             detailed_response = []
             model_predicted_labels = []
@@ -99,42 +123,73 @@ def chat_function(index):
                 detailed_response.append(f"Token: {token}, Entity: {label_mapping[label_id]}, Score: {score:.4f}")
 
             response = "\n".join(detailed_response)
-            logging.info(f"Generated response: {response}")
-
             response_size = len(response.encode('utf-8'))
             RESPONSE_SIZE.observe(response_size)
 
             time.sleep(random.uniform(0.5, 2.5))  # Simulate processing time
 
-            # Ensure the model and ground truth labels are the same length for comparison
-            model_predicted_labels = model_predicted_labels[:len(ground_truth_labels)]
-
-            precision = precision_score(ground_truth_labels, model_predicted_labels, average='weighted', zero_division=0)
-            recall = recall_score(ground_truth_labels, model_predicted_labels, average='weighted', zero_division=0)
-            f1 = f1_score(ground_truth_labels, model_predicted_labels, average='weighted', zero_division=0)
-
-            metrics_response = (f"Precision: {precision:.4f}\n"
-                                f"Recall: {recall:.4f}\n"
-                                f"F1 Score: {f1:.4f}")
-
-            full_response = f"**Record**:\nTokens: {tokens}\nGround Truth Labels: {ground_truth_labels}\n\n**Predictions**:\n{response}\n\n**Metrics**:\n{metrics_response}"
+            return response, model_predicted_labels
 
+# --- Chat Function with Monitoring ---
+def chat_function(input, datasets):
+    logger.debug("Starting chat_function")
+    with REQUEST_LATENCY.time():
+        REQUEST_COUNT.inc()
+        try:
+            if input.isnumeric():
+                chat_queue.put(input)
+                # Get the example from the dataset
+                if datasets:
+                  example = datasets[int(input)]
+                else:
+                  example = dataset['train'][int(input)]
+                tokens = example['tokens']
+                ground_truth_labels = [label_mapping[label] for label in example['ner_tags']]
+
+                # Call the classification function
+                response, model_predicted_labels = classification(tokens)
+              
+
+                # Ensure the model and ground truth labels are the same length for comparison
+                model_predicted_labels = model_predicted_labels[:len(ground_truth_labels)]
+
+                precision = precision_score(ground_truth_labels, model_predicted_labels, average='weighted', zero_division=0)
+                recall = recall_score(ground_truth_labels, model_predicted_labels, average='weighted', zero_division=0)
+                f1 = f1_score(ground_truth_labels, model_predicted_labels, average='weighted', zero_division=0)
+                accuracy = accuracy_score(ground_truth_labels, model_predicted_labels)
+
+                metrics_response = (f"Precision: {precision:.4f}\n"
+                                    f"Recall: {recall:.4f}\n"
+                                    f"F1 Score: {f1:.4f}\n"
+                                    f"Accuracy: {accuracy:.4f}")
+
+                full_response = f"**Record**:\nTokens: {tokens}\nGround Truth Labels: {ground_truth_labels}\n\n**Predictions**:\n{response}\n\n**Metrics**:\n{metrics_response}"
+                logger.info(f"\nInput details: \n Received index from user: {input} Sending response to user: {full_response}")
+            else:
+                chat_queue.put(input)
+                response, predicted_labels = classification([input])
+                full_response = f"Input details: \n**Input Sentence:** {input}\n\n**Predictions**:\n{response}\n\n"
+                logger.info(full_response)  
+           
             chat_queue.get()
-            logging.debug("Finished processing message")
             return full_response
         except Exception as e:
             ERROR_COUNT.inc()
-            logging.error(f"Error in chat processing: {e}", exc_info=True)
+            logger.error(f"Error in chat processing: {e}", exc_info=True)
             return f"An error occurred. Please try again. Error: {e}"
 
 # Function to simulate stress test
-def stress_test(num_requests, index, delay):
+def stress_test(num_requests, message, delay):
     def send_chat_message():
-        response = requests.post("http://127.0.0.1:7860/api/predict/", json={
-            "data": [index],
-            "fn_index": 0  # This might need to be updated based on your Gradio app's function index
-        })
-        logging.debug(response.json())
+        try:
+            response = requests.post("http://127.0.0.1:7860/api/predict/", json={
+                "data": [message],
+                "fn_index": 0  # This might need to be updated based on your Gradio app's function index
+            })
+            logger.debug(f"Request payload: {message}",exc_info=True)
+            logger.debug(f"Response: {response.json()}",exc_info=True)
+        except Exception as e:
+            logger.debug(f"Error during stress test request: {e}", exc_info=True)
 
     threads = []
     for _ in range(num_requests):
@@ -146,20 +201,21 @@ def stress_test(num_requests, index, delay):
     for t in threads:
         t.join()
 
+
 # --- Gradio Interface with Background Image and Three Windows ---
-with gr.Blocks(css="""
-body {
-    background-image: url("stag.jpeg"); 
-    background-size: cover; 
-    background-repeat: no-repeat;
-}
-""", title="PLOD Filtered with Monitoring") as demo:  # Load CSS for background image
-    with gr.Tab("Chat"):
+with gr.Blocks(title="PLOD Filtered with Monitoring") as demo:  # Load CSS for background image
+    
+    with gr.Tab("Sentence input"):
         gr.Markdown("## Chat with the Bot")
-        index_input = gr.Textbox(label="Enter dataset index:", lines=1)
+        index_input = gr.Textbox(label="Enter A sentence:", lines=1)
         output = gr.Markdown(label="Response")
         chat_interface = gr.Interface(fn=chat_function, inputs=[index_input], outputs=output)
-        chat_interface.render()
+
+    with gr.Tab("Dataset and Index Input"):
+        gr.Markdown("## Chat with the Bot")
+        interface = gr.Interface(fn = chat_function,
+            inputs=[gr.Textbox(label="Enter dataset index:", lines=1),  gr.UploadButton(label ="Upload Dataset", file_types=[".csv", ".tsv"])],
+        outputs = gr.Markdown(label="Response"))
 
     with gr.Tab("Model Parameters"):
         model_params_display = gr.Textbox(label="Model Parameters", lines=20, interactive=False)  # Display model parameters
@@ -191,7 +247,9 @@ body {
                 stress_test_status.value = f"Stress test failed: {e}"
 
         stress_test_button.click(run_stress_test, [num_requests_input, index_input_stress, delay_input], stress_test_status)
-
+    img = gr.Image(
+                "stag.jpeg", label="Image"
+            )
     # --- Update Functions ---
     def update_metrics(request_count_display, avg_latency_display):
         while True:
@@ -214,9 +272,11 @@ body {
 
     def update_logs(logs_display):
         while True:
-            with open(log_file, "r") as log_file_handler:
-                logs = log_file_handler.readlines()
-                logs_display.value = "".join(logs[-10:])  # Display last 10 lines
+            info_log_vector = []
+            logs = []
+            while not logs_queue.empty():
+                logs.append(logs_queue.get())
+            logs_display.value = "\n".join(logs[-10:])
             time.sleep(1)  # Update every 1 second
 
     def display_model_params(model_params_display):
@@ -235,7 +295,7 @@ body {
     threading.Thread(target=start_http_server, args=(8000,), daemon=True).start()
     threading.Thread(target=update_metrics, args=(request_count_display, avg_latency_display), daemon=True).start()
     threading.Thread(target=update_usage, args=(cpu_usage_display, mem_usage_display), daemon=True).start()
-    threading.Thread(target=update_logs, args=(logs_display,), daemon=True).start()
+    threading.Thread(target=update_logs, args=(logs_display), daemon=True).start()
     threading.Thread(target=display_model_params, args=(model_params_display,), daemon=True).start()
     threading.Thread(target=update_queue_length, daemon=True).start()