Update app.py

app.py

@@ -11,7 +11,9 @@ import json
 from transformers import pipeline
 import matplotlib.pyplot as plt
 import plotly.express as px
-import pandas as pd 
+import pandas as pd
+import json
+import plotly.graph_objects as go
 
 client = OpenAI()
 
@@ -23,21 +25,24 @@ class SentimentAnalyzer:
         # Create a conversation for the OpenAI chat API
         conversation = [
             {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": f""" Your task is find the top 3 emotion for this converstion {text}: <Sadness, Happiness, Fear, Disgust, Anger> and it's emotion score for the Mental Healthcare Doctor Chatbot and patient conversation text.\
-        you are analyze the text and provide the output in the following list format heigher to lower order: ["emotion1","emotion2","emotion3"][score1,score2,score3]''' [with top 3 result having the highest score]
-        The scores should be in the range of 0.0 to 1.0, where 1.0 represents the highest intensity of the emotion.
+            {"role": "user", "content": f""" Your task is find the emotions for this converstion.
+            Conversation: {text}
+            lables : [Sadness, Happiness, Fear, Anger]     
+            provide emotion score for each label for given conversation. 
+            Return answer should be in valid JSON format only. 
         """}
         ]
         
         # Call OpenAI GPT-3.5-turbo
         chat_completion = client.chat.completions.create(
-            model = "gpt-3.5-turbo-1106",
+            model = "gpt-3.5-turbo",
             messages = conversation,
             max_tokens=500,
             temperature=0
         )
         
         response = chat_completion.choices[0].message.content
+        print("emotion_analysis", response)
         return response
 
 
@@ -46,57 +51,25 @@ class SentimentAnalyzer:
         # Create a conversation for the OpenAI chat API
         conversation = [
             {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": f""" Your task is find the setiments for this converstion {text} : <labels = positive, negative, neutral> and it's sentiment score for the Mental Healthcare Doctor Chatbot and patient conversation text.\
-        you are analyze the text and provide the output in the following json format heigher to lower order: '''["label1","label2","label3"][score1,score2,score3]'''
+            {"role": "user", "content": f""" Your task is analyse the conversarion to provide the sentiment analysis. 
+            ```converstion: {text}``` 
+            ```labels :[ positive, negative, neutral]```
+           provide sentiment score for each label for given conversation. Return answer should be in valid JSON format only.
         """}
         ]
         
         # Call OpenAI GPT-3.5-turbo
         chat_completion = client.chat.completions.create(
-            model = "gpt-3.5-turbo-1106",
+            model = "gpt-3.5-turbo",
             messages = conversation,
             max_tokens=500,
             temperature=0
         )
         
         response = chat_completion.choices[0].message.content
-        return response
+        print("analyze_sentiment_for_graph", response)
+        return response 
         
-        # prompt = f""" Your task is find the setiments for this converstion {text} : <labels = positive, negative, neutral> and it's sentiment score for the Mental Healthcare Doctor Chatbot and patient conversation text.\
-        # you are analyze the text and provide the output in the following json format heigher to lower order: '''["label1","label2","label3"][score1,score2,score3]'''
-        # """
-        # response = client.completions.create(
-        # model="text-davinci-003",
-        # prompt=prompt,
-        # temperature=0,
-        # max_tokens=60,
-        # top_p=1,
-        # frequency_penalty=0,
-        # presence_penalty=0
-        # )
-
-        # Extract the generated text
-        sentiment_scores = response
-        start_index = sentiment_scores.find("[")
-        end_index = sentiment_scores.find("]")
-        list1_text = sentiment_scores[start_index + 1: end_index]
-        list2_text = sentiment_scores[end_index + 2:-1]
-        sentiment = list(map(str.strip, list1_text.split(",")))
-        scores = list(map(float, list2_text.split(",")))
-        score_dict={"Sentiment": sentiment, "Score": scores}
-        print(score_dict)
-        return score_dict
-
-    def emotion_analysis_for_graph(self,text):
-        start_index = text.find("[")
-        end_index = text.find("]")
-        list1_text = text[start_index + 1: end_index]
-        list2_text = text[end_index + 2:-1]
-        emotions = list(map(str.strip, list1_text.split(",")))
-        scores = list(map(float, list2_text.split(",")))
-        score_dict={"Emotion": emotions, "Score": scores}
-        print(score_dict)
-        return score_dict
 
 
 class Summarizer:
@@ -108,7 +81,7 @@ class Summarizer:
         # Create a conversation for the OpenAI chat API
         conversation = [
             {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": f"""summarize the following conversation delimited by triple backticks. write within 30 words.```{text}``` """}
+            {"role": "user", "content": f"""summarize the following conversation delimited by triple backticks. write within 60 words.```{text}``` """}
         ]
         
         # Call OpenAI GPT-3.5-turbo
@@ -133,61 +106,49 @@ class LangChain_Document_QA:
         # openai.api_key=os.getenv("OPENAI_API_KEY")
         pass
 
-    def _add_text(self,history, text):
-        history = history + [(text, None)]
-        history_state.value = history
-        return history,gr.update(value="", interactive=False)
-
-    def _agent_text(self,history, text):
-        response = text
-        history[-1][1] = response
-        history_state.value = history
-        return history
-
-    def _chat_history(self):
-        history = history_state.value
-        formatted_history = " "
-        for entry in history:
-            customer_text, agent_text = entry
-            formatted_history += f"Patient: {customer_text}\n"
-            if agent_text:
-                formatted_history += f"Mental Healthcare Doctor Chatbot: {agent_text}\n"
-        return formatted_history
-
     def _display_history(self):
         formatted_history=self._chat_history()
+        # formatted_history = _suggested_answer()
         summary=summarizer.generate_summary(formatted_history)
         return summary
 
-    def _display_graph(self,sentiment_scores):
-        df = pd.DataFrame(sentiment_scores)
-        fig = px.bar(df, x='Score', y='Sentiment', orientation='h', labels={'Score': 'Score', 'Labels': 'Sentiment'})
-        fig.update_layout(height=500, width=200)
+    def _display_graph(self,json_string):
+        # Parse the JSON string into a dictionary
+        json_data = json.loads(json_string)
+
+        sentiments = list(json_data.keys())
+        scores = list(json_data.values())
+
+        fig = go.Figure(data=[go.Bar(x=sentiments, y=scores, marker_color=['green', 'red', 'blue'])])
+
+        fig.update_layout(
+            title='Sentiment Analysis Scores',
+            xaxis=dict(title='Sentiment'),
+            yaxis=dict(title='Score'),
+        )
+
         return fig
-    def _display_graph_emotion(self,customer_emotion_score):
-        
-        fig = px.pie(customer_emotion_score, values='Score', names='Emotion', title='Emotion Distribution', hover_data=['Score'])
-        #fig.update_traces(texttemplate='Emotion', textposition='outside')
-        fig.update_layout(height=500, width=200)
+
+    def _display_graph_emotion(self,json_string):
+        # Parse the JSON string into a dictionary
+        json_data = json.loads(json_string)
+
+        sentiments = list(json_data.keys())
+        scores = list(json_data.values())
+
+        fig = go.Figure(data=[go.Bar(x=sentiments, y=scores, marker_color=['green', 'red', 'blue'])])
+
+        fig.update_layout(
+            title='Emotion Analysis Scores',
+            xaxis=dict(title='Emotions'),
+            yaxis=dict(title='Score'),
+        )
+
         return fig
-    def _history_of_chat(self):
-        history = history_state.value
-        formatted_history = ""
-        client=""
-        agent=""
-        for entry in history:
-            customer_text, agent_text = entry
-            client+=customer_text
-            formatted_history += f"Patient: {customer_text}\n"
-            if agent_text:
-                agent+=agent_text
-                formatted_history += f"Mental Healthcare Doctor Chatbot: {agent_text}\n"
-        return client,agent
-
-
-    def _suggested_answer(self,history, text):
-      # try:
-        history_list = self._chat_history()
+
+
+    def _suggested_answer(self, text, chat_history):
+
         try:
           file_path = "patient_details.json"
           with open(file_path) as file:
@@ -197,65 +158,48 @@ class LangChain_Document_QA:
             
         # Create a conversation for the OpenAI chat API
         conversation = [
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": f"""Analyse the patient json If asked for information take it from {patient_details} \
-            you first get patient details : <get name,age,gender,contact,address from patient> if not match patient json information start new chat else match patient \
-            json information ask previous: <description,symptoms,diagnosis,treatment talk about patient> As an empathic AI Mental Healthcare Doctor Chatbot, provide effective solutions to patients' mental health concerns. \
-            first start the conversation ask existing patient or new patient. if new patient get name,age,gender,contact,address from the patient and start. \
-            if existing customer get name,age,gender,contact,address details and start the chat about existing issues and current issues. \
-            if patient say thanking tone message to end the conversation with a thanking greeting when the patient expresses gratitude. \
-            Chat History:['''{history_list}'''] 
-            Patient: ['''{text}''']
-            Perform as Mental Healthcare Doctor Chatbot
-                 """}
+            {"role": "system", "content": "You are a Mental Healthcare Chatbot."},
+            {"role": "user", "content": f"""You are a Mental Healthcare Chatbot. 
+            Ask more about the patient's problem as step by step.
+            Then give the short mental healthcare solution for patient's problems.
+
+            ```Chat History:{chat_history}```
+
+            Patient Query:{text}.
+            Mental Healthcare Chatbot:
+
+            
+            """}
         ]
         
         # Call OpenAI GPT-3.5-turbo
         chat_completion = client.chat.completions.create(
-            model = "gpt-3.5-turbo-1106",
+            model = "gpt-3.5-turbo",
             messages = conversation,
-            max_tokens=500,
+            max_tokens=300,
             temperature=0
         )
         
         response = chat_completion.choices[0].message.content
         
-        if  ":" in response:
-          response = re.sub(r'^.*:', '', response)
-        history[-1][1] = response.strip()
-        history_state.value = history
-        return history
-      # except:
-      #   history[-1][1] = "How can I help you?"
-      #   history_state.value = history
-      #   return history
-
-
-    def _text_box(self,customer_emotion,customer_sentiment_score):  
-        sentiment_str = ', '.join([f'{label}: {score}' for label, score in zip(customer_sentiment_score['Sentiment'], customer_sentiment_score['Score'])])
-        #emotion_str = ', '.join([f'{emotion}: {score}' for emotion, score in zip(customer_emotion['Emotion'], customer_emotion['Score'])])
-        return f"Sentiment: {sentiment_str},\nEmotion: {customer_emotion}"
-
-    def _on_sentiment_btn_click(self):
-        client=self._history_of_chat()
-
-        customer_emotion=sentiment.emotion_analysis(client)
-        customer_sentiment_score = sentiment.analyze_sentiment_for_graph(client)
-
-        scores=self._text_box(customer_emotion,customer_sentiment_score)
+        chat_history.append((text, response))
+        
+        return "", chat_history
 
-        customer_fig=self._display_graph(customer_sentiment_score)
-        customer_fig.update_layout(title="Sentiment Analysis",width=800)
 
-        customer_emotion_score = sentiment.emotion_analysis_for_graph(customer_emotion)
+    def _on_sentiment_btn_click(self, history):
+        # client=self._history_of_chat()
 
-        customer_emotion_fig=self._display_graph_emotion(customer_emotion_score)
-        customer_emotion_fig.update_layout(title="Emotion Analysis",width=800)
-        return scores,customer_fig,customer_emotion_fig
+        customer_emotion=sentiment.emotion_analysis(history)
+        
+        customer_sentiment_score = sentiment.analyze_sentiment_for_graph(history)
 
+        sentiment_graph = self._display_graph(customer_sentiment_score)
+ 
+        emotion_graph = self._display_graph_emotion(customer_emotion)
+        
+        return sentiment_graph, emotion_graph
 
-    def clear_func(self):
-      history_state.clear()
 
     def gradio_interface(self):
       with gr.Blocks(css="style.css",theme='JohnSmith9982/small_and_pretty') as demo:
@@ -267,25 +211,22 @@ class LangChain_Document_QA:
           with gr.Row():
               with gr.Column(scale=1):
                   with gr.Row():
-                      chatbot = gr.Chatbot([], elem_id="chatbot")
+                      chatbot = gr.Chatbot()
                   with gr.Row():
                       with gr.Column(scale=0.90):
                           txt = gr.Textbox(show_label=False,placeholder="Patient")
                       with gr.Column(scale=0.10):
-                          emptyBtn = gr.Button("🧹 Clear")
+                          emptyBtn = gr.ClearButton([txt, chatbot])
+                          # emptyBtn = gr.Button()
 
           with gr.Accordion("Conversational AI Analytics", open = False):
               with gr.Row():
-                  with gr.Column(scale=0.50):
+                  with gr.Column(scale=1.0):
                       txt4 =gr.Textbox(
                           show_label=False,
                           lines=4,
                           placeholder="Summary")
-                  with gr.Column(scale=0.50):
-                      txt5 =gr.Textbox(
-                          show_label=False,
-                          lines=4,
-                          placeholder="Sentiment")
+
               with gr.Row():
                   with gr.Column(scale=0.50, min_width=0):
                       end_btn=gr.Button(value="End")
@@ -301,16 +242,20 @@ class LangChain_Document_QA:
                       plot_3 =gr.Plot(label="Patient_Emotion")
 
 
-          txt_msg = txt.submit(self._add_text, [chatbot, txt], [chatbot, txt]).then(
-        self._suggested_answer, [chatbot,txt],chatbot)
-          txt_msg.then(lambda: gr.update(interactive=True), None, [txt])
+        #   txt_msg = txt.submit(self._add_text, [chatbot, txt], [chatbot, txt]).then(
+        # self._suggested_answer, [chatbot,txt],chatbot)
+        #   txt_msg.then(lambda: gr.update(interactive=True), None, [txt])
           # txt.submit(self._suggested_answer, [chatbot,txt],chatbot)
           # button.click(self._agent_text, [chatbot,txt3], chatbot)
-          end_btn.click(self._display_history, [], txt4)
-          emptyBtn.click(self.clear_func,[],[])
-          emptyBtn.click(lambda: None, None, chatbot, queue=False)
+ 
+          txt.submit(self._suggested_answer, [txt,chatbot],[txt,chatbot])
+          print("chatbot", chatbot)
+
+          end_btn.click(summarizer.generate_summary,chatbot, txt4)
+          # emptyBtn.click(self.clear_func,[],[])
+          # emptyBtn.click(lambda: None, None, chatbot, queue=False)
 
-          Sentiment_btn.click(self._on_sentiment_btn_click,[],[txt5,plot,plot_3])
+          Sentiment_btn.click(self._on_sentiment_btn_click,chatbot,[plot,plot_3])
  
       demo.title = "AI Mental Healthcare ChatBot"
       demo.launch(debug = True)