Update app.py

app.py

@@ -9,209 +9,194 @@ import random
 from transformers import pipeline
 from sklearn.metrics import precision_score, recall_score, f1_score
 import json
-import requests
-
-# Set up logging
-logging.basicConfig(level=logging.DEBUG)
-
-# Initialize monitoring metrics
-REQUEST_COUNT = Counter('request_count', 'Number of requests')
-REQUEST_LATENCY = Histogram('request_latency_seconds', 'Request latency')
-RESPONSE_SIZE = Histogram('response_size_bytes', 'Response size in bytes')
-ERROR_COUNT = Counter('error_count', 'Number of errors')
-CPU_USAGE = Gauge('cpu_usage_percent', 'CPU usage percentage')
-MEM_USAGE = Gauge('mem_usage_percent', 'Memory usage percentage')
-QUEUE_LENGTH = Gauge('queue_length', 'Queue length')
-
-# Initialize NER pipeline (assuming a pre-trained model is used)
-ner_pipeline = pipeline("ner")
-
-# Initialize queue
-chat_queue = Queue()
-
-def chat_function(message, user_ner_tags, ground_truth, history=[]):
-    logging.debug("Starting chat_function")
-    with REQUEST_LATENCY.time():
-        REQUEST_COUNT.inc()
-        try:
-            chat_queue.put(message)
-            logging.info(f"Received message from user: {message}")
-
-            ner_results = ner_pipeline(message)
-
-            table_data = []
-            model_predicted_labels = []
-            user_predicted_labels = []  # List to store user-provided labels
-
-            try:
-                user_ner_results = json.loads(user_ner_tags)  # Load user's NER results
-                if not isinstance(user_ner_results, list):
-                    raise ValueError("Invalid format for user NER tags. Please provide a JSON list of dictionaries.")
-            except json.JSONDecodeError:
-                user_ner_results = []  # If invalid JSON, set user results to empty list
-
-            for i, result in enumerate(ner_results):
-                token = result['word']
-                entity = result['entity']
-                model_score = round(result['score'], 4)
-                start = result['start']
-                end = result['end']
-                label_id = int(entity.split('_')[-1])  
-                model_predicted_labels.append(label_id)
-                
-                # Try to get the user's label for this token
-                user_score = 0.0  # Default score if user didn't tag the token
-                user_entity = "-"
-                if i < len(user_ner_results) and user_ner_results[i]['word'] == token:
-                    user_entity = user_ner_results[i]['entity']
-                    user_label_id = int(user_entity.split('_')[-1])
-                    user_predicted_labels.append(user_label_id)
-
-                    # Here, you would typically have a user-provided confidence score, but for this example, let's just use 1.0
-                    user_score = 1.0
-
-                table_data.append([token, entity, model_score, user_entity, user_score])
-
-            response_size = len(str(table_data).encode('utf-8'))
-            RESPONSE_SIZE.observe(response_size)
-
-            time.sleep(random.uniform(0.5, 2.5))  
-
-            # --- Compute Metrics (Model & User) ---
-            metrics_response = ""
-            if ground_truth:
-                try:
-                    ground_truth_labels = json.loads(ground_truth)
-                except json.JSONDecodeError:
-                    return history + [[message, (table_data, "Invalid JSON format for ground truth labels.")]]
-
-                model_precision = precision_score(ground_truth_labels, model_predicted_labels, average='weighted', zero_division=0)
-                model_recall = recall_score(ground_truth_labels, model_predicted_labels, average='weighted', zero_division=0)
-                model_f1 = f1_score(ground_truth_labels, model_predicted_labels, average='weighted', zero_division=0)
-
-                metrics_response += "\nModel Metrics:\n"
-                metrics_response += (f"Precision: {model_precision:.4f}\n"
-                                    f"Recall: {model_recall:.4f}\n"
-                                    f"F1 Score: {model_f1:.4f}")
-
-                if user_ner_results:  # Only calculate user metrics if user provided tags
-                    user_precision = precision_score(ground_truth_labels, user_predicted_labels, average='weighted', zero_division=0)
-                    user_recall = recall_score(ground_truth_labels, user_predicted_labels, average='weighted', zero_division=0)
-                    user_f1 = f1_score(ground_truth_labels, user_predicted_labels, average='weighted', zero_division=0)
-
-                    metrics_response += "\nUser Metrics:\n"
-                    metrics_response += (f"Precision: {user_precision:.4f}\n"
-                                        f"Recall: {user_recall:.4f}\n"
-                                        f"F1 Score: {user_f1:.4f}")
-            else:
-                metrics_response = "Ground truth labels not provided."
-
-            chat_queue.get()
-            logging.debug("Finished processing message")
-            return history + [[message, (table_data, metrics_response)]]
-
-        except Exception as e:
-            ERROR_COUNT.inc()
-            logging.error(f"Error in chat processing: {e}")
-            return history + [[message, f"An error occurred. Please try again. Error: {e}"]]
-
-# --- Gradio Interface ---
+
+# Load the model
+ner_pipeline = pipeline("ner", model="Sevixdd/roberta-base-finetuned-ner")
+
+# --- 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')
+
+# --- Logging Setup ---
+logging.basicConfig(filename="chat_log.txt", level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# --- Queue and Metrics ---
+chat_queue = Queue() # Define chat_queue globally
+
+# --- Chat Function with Monitoring ---
+def chat_function(message, ground_truth):
+  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}")
+
+      ner_results = ner_pipeline(message)
+      logging.debug(f"NER results: {ner_results}")
+
+      detailed_response = []
+      predicted_labels = []
+      for result in ner_results:
+        token = result['word']
+        score = result['score']
+        entity = result['entity']
+        start = result['start']
+        end = result['end']
+        label_id = int(entity.split('_')[-1]) # Extract numeric label from entity
+        predicted_labels.append(label_id)
+        detailed_response.append(f"Token: {token}, Entity: {entity}, Score: {score:.4f}, Start: {start}, End: {end}")
+
+      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
+
+      # Compute metrics
+      try:
+        ground_truth_labels = json.loads(ground_truth) # Assuming ground_truth is input as a JSON string
+      except json.JSONDecodeError:
+        return "Invalid JSON format for ground truth labels. Please provide a valid JSON array."
+
+      precision = precision_score(ground_truth_labels, predicted_labels, average='weighted')
+      recall = recall_score(ground_truth_labels, predicted_labels, average='weighted')
+      f1 = f1_score(ground_truth_labels, predicted_labels, average='weighted')
+
+      metrics_response = (f"Precision: {precision:.4f}\n"
+                f"Recall: {recall:.4f}\n"
+                f"F1 Score: {f1:.4f}")
+
+      full_response = f"{response}\n\nMetrics:\n{metrics_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}")
+      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())
+
+  threads = []
+  for _ in range(num_requests):
+    t = threading.Thread(target=send_chat_message)
+    t.start()
+    threads.append(t)
+    time.sleep(delay) # Delay between requests
+
+  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;
+  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"):
-        gr.Markdown("## Chat with the Bot")
-        message_input = gr.Textbox(label="Enter your sentence:", lines=2)
-        user_ner_tags_input = gr.Textbox(label="Enter your NER tags (JSON format):", lines=5)
-        ground_truth_input = gr.Textbox(label="Enter ground truth labels (JSON format):", lines=2)
-
-        chat_output = gr.Chatbot()
-        chat_interface = gr.Interface(fn=chat_function, 
-                                    inputs=[message_input, user_ner_tags_input, ground_truth_input], 
-                                    outputs=chat_output)
-        chat_interface.render()
-
-    with gr.Tab("Model Parameters"):
-        model_params_display = gr.Textbox(label="Model Parameters", lines=20, interactive=False)  # Display model parameters
-
-    with gr.Tab("Performance Metrics"):
-        request_count_display = gr.Number(label="Request Count", value=0)
-        avg_latency_display = gr.Number(label="Avg. Response Time (s)", value=0)
-
-    with gr.Tab("Infrastructure"):
-        cpu_usage_display = gr.Number(label="CPU Usage (%)", value=0)
-        mem_usage_display = gr.Number(label="Memory Usage (%)", value=0)
-
-    with gr.Tab("Logs"):
-        logs_display = gr.Textbox(label="Logs", lines=10)  # Increased lines for better visibility
-
-    with gr.Tab("Stress Testing"):
-        num_requests_input = gr.Number(label="Number of Requests", value=10)
-        stress_message_input = gr.Textbox(label="Message", value="Hello bot!")
-        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):
-            stress_test_status.value = "Stress test started..."
-            try:
-                stress_test(num_requests, message, 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, stress_message_input, 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
-
-            request_count_display.value = request_count
-            avg_latency_display.value = round(avg_latency, 2)
-
-            time.sleep(5)  # Update every 5 seconds
-
-    def update_usage(cpu_usage_display, mem_usage_display):
-        while True:
-            cpu_usage_display.value = psutil.cpu_percent()
-            mem_usage_display.value = psutil.virtual_memory().percent
-            CPU_USAGE.set(psutil.cpu_percent())
-            MEM_USAGE.set(psutil.virtual_memory().percent)
-            time.sleep(5)
-
-    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
-            time.sleep(1)  # Update every 1 second
-
-    def display_model_params(model_params_display):
-        while True:
-            model_params = ner_pipeline.model.config.to_dict()
-            model_params_str = "\n".join(f"{key}: {value}" for key, value in model_params.items())
-            model_params_display.value = model_params_str
-            time.sleep(10)  # Update every 10 seconds
-
-    def update_queue_length():
-        while True:
-            QUEUE_LENGTH.set(chat_queue.qsize())
-            time.sleep(1)  # Update every second
-
-    # --- Start Threads ---
-    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=display_model_params, args=(model_params_display,), daemon=True).start()
-    threading.Thread(target=update_queue_length, daemon=True).start()
+""", title="PLOD Filtered with Monitoring") as demo: # Load CSS for background image
+  with gr.Tab("Chat"):
+    gr.Markdown("## Chat with the Bot")
+    message_input = gr.Textbox(label="Enter your sentence:", lines=2)
+    ground_truth_input = gr.Textbox(label="Enter ground truth labels (JSON format):", lines=2)
+    output = gr.Textbox(label="Response", lines=10)
+    chat_interface = gr.Interface(fn=chat_function, inputs=[message_input, ground_truth_input], outputs=output)
+    chat_interface.render()
+
+  with gr.Tab("Model Parameters"):
+    model_params_display = gr.Textbox(label="Model Parameters", lines=20, interactive=False) # Display model parameters
+
+  with gr.Tab("Performance Metrics"):
+    request_count_display = gr.Number(label="Request Count", value=0)
+    avg_latency_display = gr.Number(label="Avg. Response Time (s)", value=0)
+
+  with gr.Tab("Infrastructure"):
+    cpu_usage_display = gr.Number(label="CPU Usage (%)", value=0)
+    mem_usage_display = gr.Number(label="Memory Usage (%)", value=0)
+
+  with gr.Tab("Logs"):
+    logs_display = gr.Textbox(label="Logs", lines=10) # Increased lines for better visibility
+
+  with gr.Tab("Stress Testing"):
+    num_requests_input = gr.Number(label="Number of Requests", value=10)
+    message_input_stress = gr.Textbox(label="Message", value="Hello bot!")
+    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):
+      stress_test_status.value = "Stress test started..."
+      try:
+        stress_test(num_requests, message, 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_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 [1]) # Avoid division by zero
+
+      request_count_display.value = request_count
+      avg_latency_display.value = round(avg_latency, 2)
+
+      time.sleep(5) # Update every 5 seconds
+
+  def update_usage(cpu_usage_display, mem_usage_display):
+    while True:
+      cpu_usage_display.value = psutil.cpu_percent()
+      mem_usage_display.value = psutil.virtual_memory().percent
+      CPU_USAGE.set(psutil.cpu_percent())
+      MEM_USAGE.set(psutil.virtual_memory().percent)
+      time.sleep(5)
+
+  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
+      time.sleep(1) # Update every 1 second
+
+  def display_model_params(model_params_display):
+    while True:
+      model_params = ner_pipeline.model.config.to_dict()
+      model_params_str = "\n".join(f"{key}: {value}" for key, value in model_params.items())
+      model_params_display.value = model_params_str
+      time.sleep(10) # Update every 10 seconds
+
+  def update_queue_length():
+    while True:
+      QUEUE_LENGTH.set(chat_queue.qsize())
+      time.sleep(1) # Update every second
+
+  # --- Start Threads ---
+  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=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).