Update app.py

app.py

@@ -7,65 +7,41 @@ import threading
 import psutil
 import random
 from transformers import pipeline
-from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score
+from sklearn.metrics import precision_score, recall_score, f1_score
 import requests
 from datasets import load_dataset
 import os
 
-
-
-# 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("")
-
-
+# --- 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 ---
-logger = logging.getLogger('info')
-logger.setLevel(logging.INFO)
-formatter = logging.Formatter(fmt='%(asctime)s - %(levelname)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S')
-file_handler = logging.FileHandler(log_file_path,  mode='w')
-file_handler.setFormatter(formatter)
-logger.addHandler(file_handler)
-
-
-debugger = logging.getLogger('debug')
-debugger.setLevel(logging.DEBUG)
-formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
-file_handler = logging.FileHandler(debug_log_file_path)
-file_handler.setFormatter(formatter)
-
-stream_handler = logging.StreamHandler()
-stream_handler.setFormatter(formatter)
-
-debugger.addHandler(file_handler)
-debugger.addHandler(stream_handler)
-
-# try:
-#     logging.basicConfig(filename=debug_log_file_path, 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}")
+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}")
 
 # Load the model
 try:
     ner_pipeline = pipeline("ner", model="Sevixdd/roberta-base-finetuned-ner")
-    debugger.debug("NER pipeline loaded.")
+    logging.debug("NER pipeline loaded.")
 except Exception as e:
-    debugger.error(f"Error loading NER pipeline: {e}")
+    logging.error(f"Error loading NER pipeline: {e}")
 
 # Load the dataset
 try:
     dataset = load_dataset("surrey-nlp/PLOD-filtered")
-    debugger.debug("Dataset loaded.")
+    logging.debug("Dataset loaded.")
 except Exception as e:
-    debugger.error(f"Error loading dataset: {e}")
+    logging.error(f"Error loading dataset: {e}")
 
 # --- Prometheus Metrics Setup ---
 try:
@@ -76,16 +52,41 @@ 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')
-    debugger.debug("Prometheus metrics setup complete.")
+    logging.debug("Prometheus metrics setup complete.")
 except Exception as e:
-    debugger.error(f"Error setting up Prometheus metrics: {e}")
+    logging.error(f"Error setting up Prometheus metrics: {e}")
 
 # --- Queue and Metrics ---
 chat_queue = Queue()  # Define chat_queue globally
 
-def classification(message):
-    # Predict using the model
-            ner_results = ner_pipeline(" ".join(message))
+# Label mapping
+label_mapping = {
+    0: 'B-O',
+    1: 'B-AC',
+    3: 'B-LF',
+    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}")
 
             detailed_response = []
             model_predicted_labels = []
@@ -94,76 +95,46 @@ def classification(message):
                 score = result['score']
                 entity = result['entity']
                 label_id = int(entity.split('_')[-1])  # Extract numeric label from entity
-                model_predicted_labels.append(label_id)
-                detailed_response.append(f"Token: {token}, Entity: {entity}, Score: {score:.4f}")
+                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
+            # 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}"
 
-# --- Chat Function with Monitoring ---
-def chat_function(input):
-    debugger.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
-                example = dataset['train'][int(input)]
-                tokens = example['tokens']
-                ground_truth_labels = 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"Input details: \n Received index from user: {input} Sending response to user: {full_response}")
-            else:
-                chat_queue.put(input)
-                full_response = classification([input])
-                debugger.debug(f"Full response: {full_response}")
-                logger.info(f"Input details: \nInput Sentence: {input}\n\n**Predictions**:\n{full_response}\n\n")  
-           
             chat_queue.get()
-            logger.info("Finished processing message")
+            logging.debug("Finished processing message")
             return full_response
         except Exception as e:
             ERROR_COUNT.inc()
-            debugger.error(f"Error in chat processing: {e}", exc_info=True)
+            logging.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 stress_test(num_requests, index, delay):
     def send_chat_message():
-        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
-            })
-            debugger.debug(f"Request payload: {message}")
-            debugger.debug(f"Response: {response.json()}")
-        except Exception as e:
-            debugger.error(f"Error during stress test request: {e}", exc_info=True)
+        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())
 
     threads = []
     for _ in range(num_requests):
@@ -243,12 +214,9 @@ body {
 
     def update_logs(logs_display):
         while True:
-            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
+            with open(log_file, "r") as log_file_handler:
+                logs = log_file_handler.readlines()
+                logs_display.value = "".join(logs[-10:])  # Display last 10 lines
             time.sleep(1)  # Update every 1 second
 
     def display_model_params(model_params_display):
@@ -267,9 +235,9 @@ 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()
 
 # Launch the app
-demo.launch(share=True)
+demo.launch(share=True)