Spaces:

LampOfSocrates
/

hf_gradio_plodcw_group27

Sleeping

App Files Files Community

Lamp Socrates commited on May 23

Commit

4ad296d

•

1 Parent(s): c6d6e27

Latest commit

Browse files

Files changed (4) hide show

app.py +97 -17
locust_stress.py +7 -0
requirements.txt +2 -1
stresstest_ner_service.ipynb +301 -0

app.py CHANGED Viewed

@@ -1,51 +1,131 @@
 import gradio as gr
 from transformers import pipeline
 from fastapi import FastAPI
 from pydantic import BaseModel
 from typing import List, Dict
-# Initialize the NER pipeline
-ner_model = pipeline("ner", grouped_entities=True)
 # Define the FastAPI app
 app = FastAPI()
-# Define the request and response models for the API
-class NERRequest(BaseModel):
-    text: str
 class Entity(BaseModel):
-    entity_group: str
     start: int
     end: int
-    score: float
     word: str
 class NERResponse(BaseModel):
     entities: List[Entity]
 @app.post("/ner", response_model=NERResponse)
 def get_entities(request: NERRequest):
     # Use the NER model to detect entities
-    entities = ner_model(request.text)
     # Convert entities to the response model
     response_entities = [Entity(**entity) for entity in entities]
     return NERResponse(entities=response_entities)
 # Define the Gradio interface function
 def ner_demo(text):
-    entities = ner_model(text)
-    return {"entities": entities}
 # Create the Gradio interface
-iface = gr.Interface(
     fn=ner_demo,
     inputs=gr.Textbox(lines=10, placeholder="Enter text here..."),
-    outputs=gr.JSON(),
-    title="Named Entity Recognition",
-    description="Enter text to extract named entities using a NER model."
 )
-# Launch the Gradio interface
-iface.launch(share=True)

+import uvicorn
+import threading
+from typing import Optional
+from transformers import pipeline
+from transformers import AutoTokenizer, AutoModelForTokenClassification
+import pandas as pd
+#import datasets
+from pprint import pprint
 import gradio as gr
 from transformers import pipeline
 from fastapi import FastAPI
 from pydantic import BaseModel
 from typing import List, Dict
 # Define the FastAPI app
 app = FastAPI()
+model_cache: Optional[object] = None
+def load_model():
+    tokenizer = AutoTokenizer.from_pretrained("LampOfSocrates/bert-cased-plodcw-sourav")
+    model = AutoModelForTokenClassification.from_pretrained("LampOfSocrates/bert-cased-plodcw-sourav")
+    # Mapping labels
+    id2label = model.config.id2label
+    # Print the label mapping
+    print(f"Can recognise the following labels {id2label}")
+    # Load the NER model and tokenizer from Hugging Face
+    #ner_pipeline = pipeline("ner", model="dbmdz/bert-large-cased-finetuned-conll03-english")
+    model = pipeline("ner", model=model, tokenizer = tokenizer)
+    return model
+def load_plod_cw_dataset():
+    from datasets import load_dataset
+    dataset = load_dataset("surrey-nlp/PLOD-CW")
+    return dataset
+def get_cached_model():
+    global model_cache
+    if model_cache is None:
+        model_cache = load_model()
+    return model_cache
+# Cache the model when the server starts
+model = get_cached_model()
 class Entity(BaseModel):
+    entity: str
+    score: float
     start: int
     end: int
     word: str
 class NERResponse(BaseModel):
     entities: List[Entity]
+class NERRequest(BaseModel):
+    text: str
+@app.get("/hello")
+def read_root():
+    return {"message": "Hello, World!"}
 @app.post("/ner", response_model=NERResponse)
 def get_entities(request: NERRequest):
+    print(request)
+    model = get_cached_model()
     # Use the NER model to detect entities
+    entities = model(request.text)
+    print(entities[0].keys())
     # Convert entities to the response model
     response_entities = [Entity(**entity) for entity in entities]
+    print(response_entities[0])
     return NERResponse(entities=response_entities)
+def get_color_for_label(label: str) -> str:
+    # Define a mapping of labels to colors
+    color_mapping = {
+        "I-LF": "red",
+        "B-AC": "blue",
+        "LOC": "green",
+        # Add more labels and colors as needed
+    }
+    return color_mapping.get(label, "black")  # Default to black if label not found
 # Define the Gradio interface function
 def ner_demo(text):
+    model = get_cached_model()
+    entities = model(text)
+    #return {"entities": entities}
+    # Color code the entities
+    color_coded_text = text
+    for entity in entities:
+        #print(entity)
+        start, end, label = entity["start"], entity["end"], entity["entity"]
+        color = get_color_for_label(label)  # You need to define this function
+        entity_text = text[start:end]
+        colored_entity = f'<span style="color: {color}; font-weight: bold;">{entity_text}</span>'
+        color_coded_text = color_coded_text[:start] + colored_entity + color_coded_text[end:]
+    return color_coded_text
+PROJECT_INTRO = "This is a HF Spaces hosted Gradio App built by NLP Group 27 . The model has been trained on surrey-nlp/PLOD-CW dataset"
 # Create the Gradio interface
+demo = gr.Interface(
     fn=ner_demo,
     inputs=gr.Textbox(lines=10, placeholder="Enter text here..."),
+    outputs="html",
+    #outputs=gr.JSON(),
+    title="Named Entity Recognition on PLOD-CW ",
+    description=f"{PROJECT_INTRO}\n\nEnter text to extract named entities using a NER model."
 )
+# Function to run FastAPI
+def run_fastapi():
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+# Function to run Gradio
+def run_gradio():
+    demo.launch(server_name="0.0.0.0", server_port=7860)
+# Run both servers in separate threads
+threading.Thread(target=run_fastapi).start()
+threading.Thread(target=run_gradio).start()

locust_stress.py ADDED Viewed

	@@ -0,0 +1,7 @@

+from locust import HttpUser, task
+class HelloWorldUser(HttpUser):
+    @task
+    def hello_world(self):
+        self.client.get("/hello")
+        self.client.get("/world")

requirements.txt CHANGED Viewed

@@ -4,4 +4,5 @@ fastapi
 gradio
 transformers
 pydantic
-uvicorn

 gradio
 transformers
 pydantic
+uvicorn
+urllib3~=2.0

stresstest_ner_service.ipynb ADDED Viewed

	@@ -0,0 +1,301 @@

+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pydantic import BaseModel\n",
+    "from typing import List\n",
+    "import requests\n",
+    "\n",
+    "class NERRequest(BaseModel):\n",
+    "    text: str\n",
+    "\n",
+    "class Entity(BaseModel):\n",
+    "    entity: str\n",
+    "    score: float\n",
+    "    start: int\n",
+    "    end: int\n",
+    "    word: str\n",
+    "\n",
+    "class NERResponse(BaseModel):\n",
+    "    entities: List[Entity]\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Single Request"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "entities=[Entity(entity='B-O', score=0.7138232588768005, start=0, end=5, word='Hello'), Entity(entity='B-O', score=0.8602567911148071, start=5, end=6, word=','), Entity(entity='B-O', score=0.7045656442642212, start=7, end=12, word='world'), Entity(entity='B-O', score=0.9600160717964172, start=12, end=13, word='!')]\n"
+     ]
+    }
+   ],
+   "source": [
+    "NER_API_URL = \"http://127.0.0.1:8000\"\n",
+    "\n",
+    "# URL of the FastAPI server\n",
+    "url = f\"{NER_API_URL}/ner\"\n",
+    "\n",
+    "# Create an instance of NERRequest\n",
+    "request_data = NERRequest(text=\"Hello, world!\") # Pick from PLOD-CW\n",
+    "\n",
+    "# Convert the request data to a JSON string\n",
+    "request_json = request_data.json()\n",
+    "\n",
+    "# Make the POST request\n",
+    "response = requests.post(url, data=request_json, headers={\"Content-Type\": \"application/json\"})\n",
+    "\n",
+    "\n",
+    "# Check if the request was successful\n",
+    "if response.status_code == 200:\n",
+    "    # Parse the response JSON to the NERResponse model\n",
+    "    ner_response = NERResponse(**response.json())\n",
+    "    print(ner_response)\n",
+    "else:\n",
+    "    print(f\"Request failed with status code {response.status_code}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Single Request to /hello Endpoint"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'message': 'Hello, World!'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import requests\n",
+    "\n",
+    "# URL of the FastAPI server\n",
+    "url = f\"{NER_API_URL}/hello\"\n",
+    "\n",
+    "# Make the GET request\n",
+    "response = requests.get(url)\n",
+    "\n",
+    "# Check if the request was successful\n",
+    "if response.status_code == 200:\n",
+    "    # Print the response JSON\n",
+    "    print(response.json())\n",
+    "else:\n",
+    "    print(f\"Request failed with status code {response.status_code}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Multiple request to /ner endpoint"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "       Time Taken\n",
+      "count  100.000000\n",
+      "mean     0.017934\n",
+      "std      0.008877\n",
+      "min      0.000000\n",
+      "25%      0.012228\n",
+      "50%      0.017015\n",
+      "75%      0.021086\n",
+      "max      0.047817\n"
+     ]
+    }
+   ],
+   "source": [
+    "import threading\n",
+    "import time\n",
+    "import pandas as pd\n",
+    "from gradio_client import Client\n",
+    "\n",
+    "# List to store the time taken for each request\n",
+    "times = []\n",
+    "\n",
+    "# Lock to ensure thread-safe operations on the times list\n",
+    "lock = threading.Lock()\n",
+    "\n",
+    "# Function to send a request to the API and measure time taken\n",
+    "def send_request():\n",
+    "    start_time = time.time()\n",
+    "\n",
+    "    # Create an instance of NERRequest\n",
+    "    request_data = NERRequest(text=\"Hello, world!\")\n",
+    "\n",
+    "    # Convert the request data to a JSON string\n",
+    "    request_json = request_data.json()\n",
+    "\n",
+    "    # Make the POST request\n",
+    "    response = requests.post(url, data=request_json, headers={\"Content-Type\": \"application/json\"})\n",
+    "\n",
+    "    end_time = time.time()\n",
+    "    time_taken = end_time - start_time\n",
+    "\n",
+    "    # Append the time taken to the list in a thread-safe manner\n",
+    "    with lock:\n",
+    "        times.append(time_taken)\n",
+    "\n",
+    "# Number of concurrent requests\n",
+    "num_requests = 100\n",
+    "\n",
+    "# Create threads\n",
+    "threads = []\n",
+    "for _ in range(num_requests):\n",
+    "    thread = threading.Thread(target=send_request)\n",
+    "    threads.append(thread)\n",
+    "\n",
+    "# Start threads\n",
+    "for thread in threads:\n",
+    "    thread.start()\n",
+    "\n",
+    "# Wait for all threads to complete\n",
+    "for thread in threads:\n",
+    "    thread.join()\n",
+    "\n",
+    "# Create a pandas DataFrame with the times\n",
+    "df = pd.DataFrame(times, columns=[\"Time Taken\"])\n",
+    "\n",
+    "# Print the describe of the time distribution\n",
+    "print(df.describe())\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plot the distribution of times"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0     0.020945\n",
+       "1     0.015174\n",
+       "2     0.008024\n",
+       "3     0.006214\n",
+       "4     0.012195\n",
+       "        ...   \n",
+       "95    0.011356\n",
+       "96    0.012191\n",
+       "97    0.013172\n",
+       "98    0.014342\n",
+       "99    0.016271\n",
+       "Name: Time Taken, Length: 100, dtype: float64"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df[\"Time Taken\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "# Plot the times taken\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.hist(times, bins=30, edgecolor='black')\n",
+    "plt.title(\"Distribution of Times Taken for NER API Requests on PLOD-CW Tuned BERT Model\")\n",
+    "plt.xlabel(\"Time Taken (seconds)\")\n",
+    "plt.ylabel(\"Frequency\")\n",
+    "plt.show()\n",
+    "\n",
+    "# Plot the KDE distribution and histogram of the times taken\n",
+    "# Plot the histogram and KDE distribution of the times taken\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "sns.histplot(df[\"Time Taken\"], kde=True, bins=30, color='skyblue', stat='density', edgecolor='black')\n",
+    "plt.title(\"Distribution of Times Taken for API Requests on PLOD-CW Tuned BERT Model\")\n",
+    "plt.xlabel(\"Time Taken (seconds)\")\n",
+    "plt.ylabel(\"Density\")\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}