first commit

app.py

@@ -1,7 +1,7 @@
+import re
+
 import gradio as gr
 import pandas as pd
-from transformers import pipeline
-from openai import OpenAI
 
 from chatgpt import MessageChatCompletion
 
@@ -32,29 +32,34 @@ def build_context(row):
     return context
 
 
-def click_button(model, abstract):
+def click_button(model, api_key, abstract):
 
-    classifier = pipeline("zero-shot-classification", model="sileod/deberta-v3-base-tasksource-nli")
     labels = df['Subsector'].tolist()
-    result = classifier(abstract, labels, multi_label=True)
-    # best_x_labels = [label for label in result["labels"]][0:5]
-    # df_best = df[df.Subsector.isin(best_x_labels)]
-    # contexts = [build_context(row) for _, row in df_best.iterrows()]
-
     contexts = [build_context(row) for _, row in df.iterrows()]
-
-    my_chatgpt = MessageChatCompletion(model='gpt-4')
-
-    system_message = ('You are a system that will receive an patent abstract and needs to classify in one or more patent subsectors.'
-                      'You need to consider that each subsector has an name, definition, keywords, Does include and Does not included.'
-                      'Definition describe the subsector. '
-                      'The Keywords are important words for that subsector. '
-                      'Does include are words that can be included.'
-                      'Does not include are words that can not be in the patent abstract that is been classifying.'
-                      'nan will be consider as empty.'
-                      'Your answer will be subsector: the subsector result name and reasoning: The conclusion why you classify in that subsector specifying if has keywords and does include.'
-                      'Folow the subsectors:'
-                      f'{contexts}')
+    my_chatgpt = MessageChatCompletion(model=model, api_key=api_key)
+
+    system_message = (
+        "You are a system designed to classify patent abstracts into one or more subsectors based on their content. "
+        "Each subsector is defined by a unique set of characteristics: "
+        "\n- Name: The name of the subsector."
+        "\n- Definition: A brief description of the subsector."
+        "\n- Keywords: Important words associated with the subsector."
+        "\n- Does include: Elements typically found within the subsector."
+        "\n- Does not include: Elements typically not found within the subsector."
+        "\nConsider 'nan' values as 'not available' or 'not applicable'. "
+        "When classifying an abstract, provide the following: "
+        "\n1. Subsector(s): Name(s) of the subsector(s) you believe the abstract belongs to."
+        "\n2. Reasoning: "
+        "\n\t- Conclusion: Explain why the abstract was classified in this subsector(s), based on its alignment with the subsector's definition, keywords, and includes/excludes criteria."
+        "\n\t- Keywords found: Specify any 'Keywords' from the subsector that are present in the abstract."
+        "\n\t- Does include found: Specify any 'Includes' criteria from the subsector that are present in the abstract."
+        "\n\t- If no specific 'Keywords' or 'Includes' are found, state that none were directly identified, but the classification was made based on the overall relevance to the subsector."
+        "\n3. Non-selected Subsectors: "
+        "\n\t- If a subsector had a high probability of being a match but was ultimately not chosen because the abstract contained terms from the 'Does not include' list, provide a brief explanation. Highlight the specific 'Does not include' terms found and why this led to the subsector's exclusion."
+        f"\n4. Probability: Provide a dictionary containing the subsectors ({labels}) and their corresponding probabilities of being a match. Each probability should be formatted to show two decimal places."
+        "\nYour task is to classify the following patent abstract into the appropriate subsector(s), taking into account the details of each subsector as described above. Here are the subsectors and their definitions for your reference:\n"
+        f"{contexts}"
+    )
 
     user_message = f'Classify this patent abstract: {abstract}'
 
@@ -64,8 +69,15 @@ def click_button(model, abstract):
 
     reasoning = my_chatgpt.get_last_message()
 
-    return {label: round(prob, 4) for label, prob in zip(result["labels"], result["scores"])}, reasoning
+    dict_pattern = r'\{.*?\}'
+    probabilities_match = re.search(dict_pattern, reasoning, re.DOTALL)
+
+    if probabilities_match and my_chatgpt.error is False:
+        probabilities_dict = eval(probabilities_match.group(0))
+    else:
+        probabilities_dict = {}
 
+    return probabilities_dict, reasoning
 
 
 def on_select(evt: gr.SelectData):  # SelectData is a subclass of EventData
@@ -82,7 +94,10 @@ with gr.Blocks() as startup_genome_demo:
 
     with gr.Tab("Patent Discovery"):
         with gr.Row():
-            dropdown_model = gr.Dropdown(label="Model", choices=['model_1', 'model_2', 'model_3'], interactive=True)
+            with gr.Column(scale=5):
+                dropdown_model = gr.Dropdown(label="Model", choices=["gpt-4", "gpt-4-turbo-preview", "gpt-3.5-turbo", "gpt-3.5-turbo-0125"], value="gpt-3.5-turbo", multiselect=False, interactive=True)
+            with gr.Column(scale=5):
+                api_key = gr.Textbox(label="API KEY", interactive=True, lines=1, max_lines=1)
         with gr.Row(equal_height=True):
             abstract_description = gr.Textbox(label="Abstract description", lines=10, max_lines=10000, interactive=True, value="A holographic optical accessing system includes a light source for emitting a light beam; an optical assembly module for receiving the light beam and generating a signal beam and a reference beam that are parallel to each other rather than overlap with each other, and have the same first polarization state; a lens module for focusing the signal beam and the reference beam on a focal point at the same time; and a storage medium for recording the focal point. The optical assembly module includes at least a data plane for displaying image information so that the signal beam contains the image information.")
         with gr.Row():
@@ -91,7 +106,7 @@ with gr.Blocks() as startup_genome_demo:
             with gr.Column(scale=4):
                 label_result = gr.Label(num_top_classes=None)
             with gr.Column(scale=6):
-                reasoning = gr.Textbox(label="Reasoning", lines=5)
+                reasoning = gr.Textbox(label="Reasoning", lines=34)
     with gr.Tab("Sector definitions"):
         with gr.Row():
             with gr.Column(scale=4):
@@ -104,10 +119,7 @@ with gr.Blocks() as startup_genome_demo:
                     does_include = gr.Textbox(label="Does include", lines=4)
                     does_not_include = gr.Textbox(label="Does not include", lines=3)
 
-    with gr.Tab("Logs"):
-        pass
-
-    btn_get_result.click(fn=click_button, inputs=[dropdown_model, abstract_description], outputs=[label_result, reasoning])
+    btn_get_result.click(fn=click_button, inputs=[dropdown_model, api_key, abstract_description], outputs=[label_result, reasoning])
     df_subsectors.select(fn=on_select, outputs=[subsector_name, s1_definition, s1_keywords, does_include, does_not_include])
 
 if __name__ == "__main__":

chatgpt.py

@@ -11,23 +11,23 @@ class MessageChatCompletion:
                  n: int = 1,
                  stream: bool = False,
                  stop: str = "\n",
-                 max_tokens: int = 256,
+                 max_tokens: int = 4096,
                  presence_penalty: float = 0.0,
                  frequency_penalty: float = 0.0,
                  logit_bias: int = None,
                  user: str = ''):
 
-        openai.api_key = ''
-        openai.organization = ""
+        self.api_key = api_key
+        openai.api_key = self.api_key
 
-        if model in ["gpt-4", "gpt-4-turbo-preview", "gpt-3.5-turbo"]:
+        if model in ["gpt-4", "gpt-4-turbo-preview", "gpt-3.5-turbo", "gpt-3.5-turbo-0125"]:
             self.endpoint = "https://api.openai.com/v1/chat/completions"
         else:
             self.endpoint = "https://api.openai.com/v1/completions"
 
         self.headers = {
             "Content-Type": "application/json",
-            "Authorization": f"Bearer {api_key}",
+            "Authorization": f"Bearer {self.api_key}",
         }
 
         self.prompt = {
@@ -56,6 +56,8 @@ class MessageChatCompletion:
 
         self.response = ''
 
+        self.error = False
+
     def new_message(self, role: str = 'user', content: str = '', name: str = ''):
         new_message = {"role": role, "content": f"{content}"}
         if name != '':
@@ -77,23 +79,38 @@ class MessageChatCompletion:
 
     def send_message(self):
 
-        response = openai.chat.completions.create(
-            model=self.prompt['model'],
-            messages=self.prompt['messages'],
-            frequency_penalty=self.prompt['frequency_penalty'],
-            temperature=self.prompt['temperature'],
-            max_tokens=self.prompt['max_tokens'],
-            top_p=self.prompt['top_p'],
-            presence_penalty=self.prompt['presence_penalty'],
-            stream=True
-        )
-
-        full_response = ""
-        for chunk in response:
-            chunk_message = chunk.choices[0].delta.content
-            if chunk_message is not None:
-                full_response += chunk_message
-
-        self.new_system_message(content=full_response)
-
-        return self.response
+        try:
+            self.error = False
+
+            response = openai.chat.completions.create(
+                model=self.prompt['model'],
+                messages=self.prompt['messages'],
+                frequency_penalty=self.prompt['frequency_penalty'],
+                temperature=self.prompt['temperature'],
+                max_tokens=self.prompt['max_tokens'],
+                top_p=self.prompt['top_p'],
+                presence_penalty=self.prompt['presence_penalty'],
+                stream=self.prompt['stream']
+            )
+
+            full_response = response.choices[0].message.content
+
+            # if stream = True
+            # full_response = ""
+            # for chunk in response:
+            #     chunk_message = chunk.choices[0].delta.content
+            #     if chunk_message != '':
+            #         full_response += chunk_message
+
+            self.new_system_message(content=full_response)
+
+            return self.response
+
+        except Exception as e:
+            self.error = True
+
+            if self.api_key == '' or self.api_key is None:
+                self.new_system_message(content="API key is missing")
+            else:
+                self.new_system_message(content=f"Unable to generate ChatCompletion response\nException: {e}")
+            return e