Update app.py

app.py

@@ -7,71 +7,188 @@ import threading
 import psutil
 import random
 from transformers import pipeline
-from time import gmtime, strftime
+from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score
+import requests
+from datasets import load_dataset
+import os
+from logging.handlers import RotatingFileHandler
+
+
+
+# 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 = RotatingFileHandler(
+    filename=log_file_path, mode='w', maxBytes=5*1024*1024, backupCount=2)
+info_handler.setLevel(logging.INFO)
+info_handler.setFormatter(formatter)
+
+debug_handler = RotatingFileHandler(
+    filename=debug_log_file_path, mode='w', maxBytes=5*1024*1024, backupCount=2)
+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
-ner_pipeline = pipeline("ner", model="Sevixdd/roberta-base-finetuned-ner")
+try:
+    ner_pipeline = pipeline("ner", model="Sevixdd/roberta-base-finetuned-ner")
+    logger.debug("NER pipeline loaded.")
+except Exception as e:
+    logger.debug(f"Error loading NER pipeline: {e}")
 
-# --- Prometheus Metrics Setup ---
-REQUEST_COUNT = Counter('gradio_request_count', 'Total number of requests')
-REQUEST_LATENCY = Histogram('gradio_request_latency_seconds', 'Request latency in seconds')
-ERROR_COUNT = Counter('gradio_error_count', 'Total number of errors')
-RESPONSE_SIZE = Histogram('gradio_response_size_bytes', 'Size of responses in bytes')
-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')
+# Load the dataset
+try:
+    dataset = load_dataset("surrey-nlp/PLOD-filtered")
+    logger.debug("Dataset loaded.")
+except Exception as e:
+    logger.debug(f"Error loading dataset: {e}")
 
-# --- Logging Setup ---
-logging.basicConfig(filename="chat_log.txt", level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S')
+# --- Prometheus Metrics Setup ---
+try:
+    REQUEST_COUNT = Counter('gradio_request_count', 'Total number of requests')
+    REQUEST_LATENCY = Histogram('gradio_request_latency_seconds', 'Request latency in seconds')
+    ERROR_COUNT = Counter('gradio_error_count', 'Total number of errors')
+    RESPONSE_SIZE = Histogram('gradio_response_size_bytes', 'Size of responses in bytes')
+    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')
+    logger.debug("Prometheus metrics setup complete.")
+except Exception as e:
+    logger.debug(f"Error setting up Prometheus metrics: {e}")
 
 # --- Queue and Metrics ---
 chat_queue = Queue()  # Define chat_queue globally
 
-# --- Chat Function with Monitoring ---
-def chat_function(message, history):
-    logging.debug("Starting chat_function")
-    with REQUEST_LATENCY.time():
-        REQUEST_COUNT.inc()
-        try:
-            start_time = time.time()
-            chat_queue.put(message)
-            logging.info(f"Received message from user: {message}")
-            time = "\nGMT: " + time.strftime("%a, %d %b %Y %I:%M:%S %p %Z", time.gmtime())
-            ner_results = ner_pipeline(message)
-            logging.debug(f"NER results: {ner_results}")
+label_mapping = {
+    0: 'B-O',
+    1: 'B-AC',
+    3: 'B-LF',
+    4: 'I-LF'
+}
+
+
+def classification(message):
+    # Predict using the model
+            ner_results = ner_pipeline(" ".join(message))
 
             detailed_response = []
+            model_predicted_labels = []
             for result in ner_results:
                 token = result['word']
                 score = result['score']
                 entity = result['entity']
-                start = result['start']
-                end = result['end']
-                detailed_response.append(f"Token: {token}, Entity: {entity}, Score: {score:.4f}, Start: {start}, End: {end}")
+                label_id = int(entity.split('_')[-1])  # Extract numeric label from entity
+                model_predicted_labels.append(label_mapping[label_id])
+                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
 
+            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 response
+            return full_response
         except Exception as e:
             ERROR_COUNT.inc()
-            logging.error(f"Error in chat processing: {e}")
-            return "An error occurred. Please try again."
+            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, message, delay):
     def send_chat_message():
-        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
-        })
-        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}")
+            logger.debug(f"Response: {response.json()}")
+        except Exception as e:
+            logger.debug(f"Error during stress test request: {e}", exc_info=True)
 
     threads = []
     for _ in range(num_requests):
@@ -86,14 +203,22 @@ def stress_test(num_requests, message, delay):
 # --- Gradio Interface with Background Image and Three Windows ---
 with gr.Blocks(css="""
 body {
-    background-image: url("stag.jpeg");
-    background-size: cover;
+    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.Tab("Sentence input"):
+        gr.Markdown("## Chat with the Bot")
+        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)
+
+    with gr.Tab("Dataset and Index Input"):
         gr.Markdown("## Chat with the Bot")
-        chatbot = gr.ChatInterface(fn=chat_function)
+        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
@@ -111,27 +236,27 @@ body {
 
     with gr.Tab("Stress Testing"):
         num_requests_input = gr.Number(label="Number of Requests", value=10)
-        message_input = gr.Textbox(label="Message", value="Hello bot!")
+        index_input_stress = gr.Textbox(label="Dataset Index", value="2")
         delay_input = gr.Number(label="Delay Between Requests (seconds)", value=0.1)
         stress_test_button = gr.Button("Start Stress Test")
         stress_test_status = gr.Textbox(label="Stress Test Status", lines=5, interactive=False)
 
-        def run_stress_test(num_requests, message, delay):
+        def run_stress_test(num_requests, index, delay):
             stress_test_status.value = "Stress test started..."
             try:
-                stress_test(num_requests, message, delay)
+                stress_test(num_requests, index, delay)
                 stress_test_status.value = "Stress test completed."
             except Exception as e:
                 stress_test_status.value = f"Stress test failed: {e}"
 
-        stress_test_button.click(run_stress_test, [num_requests_input, message_input, delay_input], stress_test_status)
+        stress_test_button.click(run_stress_test, [num_requests_input, index_input_stress, delay_input], stress_test_status)
 
     # --- Update Functions ---
     def update_metrics(request_count_display, avg_latency_display):
         while True:
             request_count = REQUEST_COUNT._value.get()
             latency_samples = REQUEST_LATENCY.collect()[0].samples
-            avg_latency = sum(s.value for s in latency_samples) / len(latency_samples) if latency_samples else 0
+            avg_latency = sum(s.value for s in latency_samples) / len(latency_samples if latency_samples else [1])  # Avoid division by zero
 
             request_count_display.value = request_count
             avg_latency_display.value = round(avg_latency, 2)
@@ -148,9 +273,16 @@ body {
 
     def update_logs(logs_display):
         while True:
-            with open("chat_log.txt", "r") as log_file:
-                logs = log_file.readlines()
-                logs_display.value = "".join(logs[-10:])  # Display last 10 lines
+            info_log_vector = []
+            # with open('debug.log', "r") as log_file_handler:
+            #     for line in log_file_handler:  # Skip empty lines
+            #         info_log_vector.append(line)
+            #         debugger.debug(info_log_vector)
+            #     logs_display.value = info_log_vector  # Display last 10 lines
+            logs = []
+            while not logs_queue.empty():
+                logs.append(logs_queue.get())
+            logs_display.value = "\n".join(logs)
             time.sleep(1)  # Update every 1 second
 
     def display_model_params(model_params_display):
@@ -169,7 +301,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()