add euc 100 200 to chat loop, fix dialog model

README.md

@@ -11,3 +11,14 @@ license: gpl-3.0
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+For more information about this product, please visit this notion [page](https://www.notion.so/AI-Consulting-Design-Scheme-0a9c5288820d4fec98ecc7cc1e84be51)) (you need to have permission to access this page)
+
+# Notes
+
+### 2022/12/20
+
+- Chat flow will trigger euc 200 when detect a negative emotion with prob > threshold. Thus, only euc 100 and free chat consist of chat loop, while euc 200 will pop up sometimes. I set the trigger to NOT be regularly (currently one trigger once during the conversation), because trigger to much will bother users
+- Already fix the problem with dialog model. Now it's configured as the same as what it should be. Of course, that does not guarantee of good response
+- TODO is written in the main file already
+- Successfully convert plain euc 100 and 200 to chat flow

app.py

@@ -1,3 +1,25 @@
+'''
+Dialog System of PsyPlus (dvq)
+
+reference:
+  https://huggingface.co/spaces/bentrevett/emotion-prediction
+  https://huggingface.co/spaces/tareknaous/Empathetic-DialoGPT
+  https://huggingface.co/benjaminbeilharz/t5-empatheticdialogues
+
+gradio vs streamlit 
+  https://trojrobert.github.io/a-guide-for-deploying-and-serving-machine-learning-with-model-streamlit-vs-gradio/
+  https://gradio.app/interface_state/
+
+TODO
+  Add diagram in Gradio Interface showing sentimate analysis
+  Gradio input timeout: cannot find a tutorial in Google -> don't know how to implement
+  Personalize: create database, load and save data
+
+Run command
+  python app.py --run_on_own_server 1 --initial_chat_state free_chat
+'''
+
+
 import argparse
 import re, time
 import matplotlib.pyplot as plt
@@ -5,228 +27,275 @@ from threading import Timer
 import gradio as gr
 
 import torch
-from transformers import (
-  GPT2LMHeadModel, GPT2Tokenizer,
-  AutoModelForSequenceClassification, AutoTokenizer,
-  pipeline
-)
-# reference: https://huggingface.co/spaces/bentrevett/emotion-prediction
-# and https://huggingface.co/spaces/tareknaous/Empathetic-DialoGPT
-# gradio vs streamlit https://trojrobert.github.io/a-guide-for-deploying-and-serving-machine-learning-with-model-streamlit-vs-gradio/
-# https://gradio.app/interface_state/
-
-def euc_100():
-  # 1,2,3. asks about the user's emotions and store data
-  print('How was your day?')
-  print('On the scale 1 to 10, how would you judge your emotion through the following categories:') # ~ Baymax :)
-  emotion_types = ['overall'] #, 'happiness', 'surprise', 'sadness', 'depression', 'anger', 'fear', 'anxiety']
-  emotion_degree = []
-  input_time = []
-
-  for e in emotion_types:
-    while True:
-      x = input(f'{e}: ')
-      if x.isnumeric() and (0 < int(x) < 11):
-        emotion_degree.append(int(x))
-        input_time.append(time.gmtime())
-        break
-      else:
-        print('invalid input, my friend :) plz input again')
+from transformers import GPT2LMHeadModel, GPT2Tokenizer, pipeline
 
-  # 4. if good mood
-  if emotion_degree[0] >= 6:
-    print('You seem to be in a good mood today. Is there anything you could notice that makes you happy?')
-    while True:
-      # timer = Timer(10, ValueError)
-      # timer.start()
-      x = input('Your answer: ')
-      if x == '': # need to change this part to waiting 10 seconds
-        print('Whether your good mood is over?')
-        print('Any other details that you would like to recall?')
-        y = input('Your answer (Yes or No): ')
-        if y == 'No':
-          break
-      else:
-        break
-    print('I am glad that you are willing to share the experience with me. Thanks for letting me know.')
-  
-  # 5. bad mood
-  else:
-    questions = [
-      'What specific thing is bothering you the most right now?',
-      'Oh, I see. So when it is happening, what feelings or emotions have you got?',
+
+def option():
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--run_on_own_server', type=int, default=0, help='if test on own server, need to use share mode')
+  parser.add_argument('--dialog_model', type=str, default='tareknaous/dialogpt-empathetic-dialogues')
+  parser.add_argument('--emotion_model', type=str, default='joeddav/distilbert-base-uncased-go-emotions-student')
+  parser.add_argument('--account', type=str, default=None)
+  parser.add_argument('--initial_chat_state', type=str, default='euc_100', choices=['euc_100', 'euc_200', 'free_chat'])
+  args = parser.parse_args()
+  return args
+
+
+class ChatHelper: # store the list of messages that are showed in therapies
+  invalid_input = 'Invalid input, my friend :) Plz input again'
+  good_mood_over = 'Whether your good mood is over? Any other details that you would like to recall?'
+  good_case = 'Nice to hear that!'
+  bad_mood_over = 'Whether your bad mood is over? (Yes or No)'
+  not_answer = "It's okay, maybe you don't want to answer this question."
+  fill_form = ('It has come to our attention that you may suffer from {}.\n'
+              'If you want to know more about yourself, some professional scales are provided to quantify your current status.\n'
+              'After a period of time (maybe a week/two months/a month) trying to follow the solutions we suggested, '
+              'you can fill out these scales again to see if you have improved.\n'
+              'Do you want to fill in the form now? (Okay or Later)')
+  display_form = '<Display the form>.\n'
+  reference = 'Here are some reference articles about bad emotions. You can take a look :) <Display references>\n'
+
+  emotion_types = ['Overall', 'Happiness', 'Anxiety'] # 'Surprise', 'Sadness', 'Depression', 'Anger', 'Fear',
+  euc_100 = {
+    'q': emotion_types,
+    'good_mood': [
+      'You seem to be in a good mood today. Is there anything you could notice that makes you happy?',
+      'I am glad that you are willing to share the experience with me. Thanks for letting me know.',
+    ],
+    'bad_mood': [
+      'You seem not to be in a good mood. What specific thing is bothering you the most right now?',
+      'I see. So when it is happening, what feelings or emotions have you got?',
       'And what do you think about those feelings or emotions at that time?',
       'Could you think of any evidence for your above-mentioned thought?',
-    ]
-    for q in questions:
-      print(q)
-      y = 'No' # bad mood
-      while True:
-        x = input('Your answer (example of answer here): ')
-        if x == '': # need to change this part to waiting 10 seconds
-          print('Whether your bad mood is over?')
-          y = input('Your answer (Yes or No): ')
-          if y == 'Yes':
-            break
-        else:
-          break
-      if y == 'Yes':
-        print('Nice to hear that.')
-        break
+      'Here are some reference articles about bad emotions. You can take a look :)',
+    ],
+  }
 
-    # reading interface here
-    print('Here are some reference articles about bad emotions. You can take a look :)')
-    pass
-
-
-def load_neural_emotion_detector():
-  model_name = 'joeddav/distilbert-base-uncased-go-emotions-student'
-  model = AutoModelForSequenceClassification.from_pretrained(model_name)
-  model.eval()
-  tokenizer = AutoTokenizer.from_pretrained(model_name)
-  pipe = pipeline('text-classification', model=model, tokenizer=tokenizer, 
-                  return_all_scores=True, truncation=True)
-  return pipe
-
-def plot_emotion_distribution(predictions):
-  fig, ax = plt.subplots()
-  ax.bar(x=[i for i, _ in enumerate(prediction)],
-         height=[p['score'] for p in prediction],
-         tick_label=[p['label'] for p in prediction])
-  ax.tick_params(rotation=90)
-  ax.set_ylim(0, 1)
-  plt.show()
-
-def rulebase(text):
-  keywords = {
-    'life_safety': ['death', 'suicide', 'murder', 'to perish together', 'jump off the building'],
-    'immediacy': ['now', 'immediately', 'tomorrow', 'today'],
-    'manifestation': ['never stop', 'every moment', 'strong', 'very']
+  negative_emotions = ['remorse', 'nervousness', 'annoyance', 'anger', 'grief', 'fear', 'disapproval',
+                       'confusion', 'embarrassment', 'disgust', 'sadness', 'disappointment']
+  euc_200 = 'Now go back to the last chat. You said that "{}".\n'
+
+  greeting_template = {
+    'euc_100': 'How was your day? On the scale 1 to 10, '
+      'how would you judge your emotion through the following categories:\nOverall',
+    # euc_200 is only trigger when you say smt more negative than a certain threshol
+    # thus the greeting here is only for debuging euc_200
+    'euc_200': fill_form.format('anxiety'),
+    'free_chat': 'Hi you! How is it going?',
   }
 
-  # if found dangerous kw/topics
-  if re.search(rf"{'|'.join(keywords['life_safety'])}", text)!=None and \
-      sum([re.search(rf"{'|'.join(keywords[k])}", text)!=None for k in ['immediacy','manifestation']]) >= 1:
-    print('We noticed that you may need immediate professional assistance, would you like to make a phone call? '
-      'The Hong Kong Lifeline number is (852) 2382 0000')
-    x = input('Choose 1. "Dial to the number" or 2. "No dangerous emotion la": ')
-    if x == '1':
-      print('Let you connect to the office')
-    else:
-      print('Sorry for our misdetection. We just want to make sure that you could get immediate help when needed. '
-        'Would you mind if we send this conversation to the cloud to finetune the model.')
-      y = input('Yes or No: ')
-      if y == 'Yes':
-        pass # do smt here
-
-
-def euc_200(text, testing=True):
-  # 2. using rule to judge user's emotion
-  rulebase(text)
-
-  # 3. using ML
-  if not testing:
-    pipe = load_neural_emotion_detector()
-    prediction = pipe(text)[0]
-    prediction = sorted(predictions, key=lambda x: x['score'], reverse=True)
-    plot_emotion_distribution(prediction)
-  
-  # get the most probable emotion. TODO: modify this part, may take sum of prob. over all negative emotion
-  threshold = 0.3
-  emotion = {'label': 'sadness', 'score': 0.4} if testing else prediction[0]
-  # then judge
-  if emotion['label'] in ['surprise', 'sadness', 'anger', 'fear'] and emotion['score'] > threshold:
-    print(f'It has come to our attention that you may suffer from {emotion["label"]}')
-    print('If you want to know more about yourself, '
-      'some professional scales are provided to quantify your current status. '
-      'After a period of time (maybe a week/two months/a month) trying to follow the solutions we suggested, '
-      'you can fill out these scales again to see if you have improved.')
-    x = input('Fill in the form now (Okay or Later): ')
-    if x == 'Okay':
-      print('Display the form')
-    else:
-      print('Here are some reference articles about bad emotions. You can take a look :)')
-
-  # 4. If both of the above are not satisfied. What do u mean by 'satisfied' here?
-  questions = [
-    'What specific thing is bothering you the most right now?',
-    'Oh, I see. So when it is happening, what feelings or emotions have you got?',
-    'And what do you think about those feelings or emotions at that time?',
-    'Could you think of any evidence for your above-mentioned thought? #',
-  ]
-  for q in questions:
-    print(q)
-    y = 'No' # bad mood
-    while True:
-      x = input('Your answer (example of answer here): ')
-      if x == '': # need to change this part to waiting 10 seconds
-        print('Whether your bad mood is over?')
-        y = input('Your answer (Yes or No): ')
+  def plot_emotion_distribution(predictions):
+    fig, ax = plt.subplots()
+    ax.bar(x=[i for i, _ in enumerate(prediction)],
+           height=[p['score'] for p in prediction],
+           tick_label=[p['label'] for p in prediction])
+    ax.tick_params(rotation=90)
+    ax.set_ylim(0, 1)
+    plt.show()
+
+  def ed_rulebase(text):
+    keywords = {
+      'life_safety': ['death', 'suicide', 'murder', 'to perish together', 'jump off the building'],
+      'immediacy': ['now', 'immediately', 'tomorrow', 'today'],
+      'manifestation': ['never stop', 'every moment', 'strong', 'very']
+    }
+
+    # if found dangerous kw/topics
+    if re.search(rf"{'|'.join(keywords['life_safety'])}", text) != None and \
+        sum([re.search(rf"{'|'.join(keywords[k])}", text) != None for k in ['immediacy','manifestation']]) >= 1:
+      print('We noticed that you may need immediate professional assistance, would you like to make a phone call? '
+        'The Hong Kong Lifeline number is (852) 2382 0000')
+      x = input('Choose 1. "Dial to the number" or 2. "No dangerous emotion la": ')
+      if x == '1':
+        print('Let you connect to the office')
+      else:
+        print('Sorry for our misdetection. We just want to make sure that you could get immediate help when needed. '
+          'Would you mind if we send this conversation to the cloud to finetune the model.')
+        y = input('Yes or No: ')
         if y == 'Yes':
-          break
+          pass # do smt here
+
+
+class TherapyChatBot:
+  def __init__(self, args):
+    # check state to control the dialog
+    self.chat_state = args.initial_chat_state # name of the chat function/therapy segment the model is in
+    self.message_prev = None
+    self.chat_state_prev = None
+    self.run_on_own_server = args.run_on_own_server
+    self.account = args.account
+
+    # additional attribute for euc_100
+    self.euc_100_input_time = []
+    self.euc_100_emotion_degree = []
+    self.already_trigger_euc_200 = False
+
+    # chat and emotion-detection models
+    self.ed_pipe = pipeline('text-classification', model=args.emotion_model, top_k=5, truncation=True)
+    self.ed_threshold = 0.3
+    self.dialog_model = GPT2LMHeadModel.from_pretrained(args.dialog_model)
+    self.dialog_tokenizer = GPT2Tokenizer.from_pretrained(args.dialog_model)
+    self.eos = self.dialog_tokenizer.eos_token
+    # tokenizer.__call__ -> input_ids, attention_mask
+    # tokenizer.encode -> only inputs_ids, which is required by model.generate function
+
+    # chat history.
+    # TODO: if we want to personalize and save the conversation,
+    # we can load data from database
+    self.greeting = ChatHelper.greeting_template[self.chat_state]
+    self.history = {'input_ids': torch.tensor([[self.dialog_tokenizer.bos_token_id]]),
+                    'text': [('', self.greeting)]} if not self.account else open(f'database/{hash(self.account)}', 'rb')
+    if 'euc_100' in self.chat_state:
+      self.chat_state = 'euc_100.q.0'
+
+  def __call__(self, message, prefix=''):
+    # if prefix != None, which means this function is called from euc_200, thus already detected the negative emotion
+    if (not prefix) and self.chat_state != 'euc_200' and not self.already_trigger_euc_200:
+      prediction = self.ed_pipe(message)[0]
+      prediction = sorted(prediction, key=lambda x: x['score'], reverse=True)
+      if self.run_on_own_server:
+        print(prediction)
+      # plot_emotion_distribution(prediction)
+      emotion = prediction[0]
+
+    # if message is negative, change state immediately
+    if ((not prefix) and self.chat_state != 'euc_200' and not self.already_trigger_euc_200) and \
+      (emotion['label'] in ChatHelper.negative_emotions and emotion['score'] > self.ed_threshold):
+      self.chat_state_prev = self.chat_state
+      self.chat_state = 'euc_200'
+      self.message_prev = message
+      self.already_trigger_euc_200 = True
+      response = ChatHelper.fill_form.format(emotion['label'])
+
+    # set up rule to update state inside each dialog function
+    elif self.chat_state.startswith('euc_100'):
+      response = self.euc_100(message)
+      if self.chat_state == 'free_chat':
+        last_two_turns_ids = self.dialog_tokenizer.encode(message + self.eos, return_tensors='pt')
+        self.history['input_ids'] = torch.cat([self.history['input_ids'], last_two_turns_ids], dim=-1)
+
+    elif self.chat_state.startswith('euc_200'):
+      return self.euc_200(message)
+
+    else: # free_chat
+      response = self.free_chat(message)
+
+    if prefix:
+      response = prefix + response
+      self.history['text'].append((self.message_prev, response))
+    else:
+      self.history['text'].append((message, response))
+    return self.history['text']
+
+  def euc_100(self, x):
+    _, subsection, entry = self.chat_state.split('.')
+    entry = int(entry)
+
+    if subsection == 'q':
+      if x.isnumeric() and (0 < int(x) < 11):
+        self.euc_100_emotion_degree.append(int(x))
+        self.euc_100_input_time.append(time.gmtime())
+        if entry == len(ChatHelper.euc_100['q']) - 1:
+          if self.run_on_own_server:
+            print(self.euc_100_emotion_degree)
+          mood = 'good_mood' if self.euc_100_emotion_degree[0] > 5 else 'bad_mood'
+          self.chat_state = f'euc_100.{mood}.0'
+          response = ChatHelper.euc_100[mood][0]
+        else:
+          self.chat_state = f'euc_100.q.{entry+1}'
+          response = ChatHelper.euc_100['q'][entry+1]
       else:
-        break
-    if y == 'Yes':
-      print('Nice to hear that.')
-      break
+        response = ChatHelper.invalid_input
 
-  # reading interface here
-  print('Here are some reference articles about bad emotions. You can take a look :)')
-  pass
+    elif subsection == 'good_mood':
+      if x == '':
+        response = ChatHelper.good_mood_over
+      else:
+        response = ChatHelper.good_case
+      response += '\n' + ChatHelper.euc_100['good_mood'][1]
+      self.chat_state = 'free_chat'
 
+    elif subsection == 'bad_mood':
+      if entry == -1:
+        if 'yes' in x.lower() or 'better' in x.lower():
+          response = ChatHelper.good_case
+        else:
+          entry = int(self.chat_state_prev.rsplit('.', 1))
+          response = ChatHelper.not_answer + '\n' + ChatHelper.euc_100['bad_mood'][entry+1]
+          if entry == len(ChatHelper.euc_100['bad_mood']) - 2:
+            self.chat_state = 'free_chat'
+          else:
+            self.chat_state = f'euc_100.bad_mood.{entry+1}'
 
-def _chat(message, history, model, tokenizer, args):
-  eos = tokenizer.eos_token
-  history = history or {
-    'text': args.greeting, 
-    'input_ids': tokenizer.encode(args.greeting[-1][1] + eos, return_tensors='pt'), 
-  }
-  # TODO: only take the latest X turns, otherwise the text becomes longer and takes more time to process
+      if x == '':
+        response = ChatHelper.bad_mood_over
+        self.chat_state_prev = self.chat_state
+        self.chat_state = 'euc_100.bad_mood.-1'
+      else:
+        response = ChatHelper.euc_100['bad_mood'][entry+1]
+        if entry == len(ChatHelper.euc_100['bad_mood']) - 2:
+          self.chat_state = 'free_chat'
+        else:
+          self.chat_state = f'euc_100.bad_mood.{entry+1}'
 
-  message_ids = tokenizer.encode(message + eos, return_tensors='pt')
-  history['input_ids'] = torch.cat([history['input_ids'], message_ids], dim=-1)
+    return response
 
-  bot_output_ids = model.generate(history['input_ids'],
-                                  max_length=1000,
-                                  do_sample=True, top_p=0.9, temperature=0.8,
-                                  pad_token_id=tokenizer.eos_token_id)
-  response = tokenizer.decode(bot_output_ids[:, history['input_ids'].shape[-1]:][0], 
-                             skip_special_tokens=True)
-  if args.run_on_own_server == 1: 
-    print((message, response), bot_output_ids[0][-10:])
+  def euc_200(self, x):
+    # don't ask question in euc_200, because they're similar to question in euc_100
+    if x.lower() == 'okay':
+      response = ChatHelper.display_form
+    else:
+      response = ChatHelper.reference
+    response += ChatHelper.euc_200.format(self.message_prev)
 
-  history['input_ids'] = bot_output_ids
-  history['text'].append((message, response))
-  return history['text'], history
+    message = self.message_prev
+    self.message_prev = x
+    self.chat_state = self.chat_state_prev
+    return self.__call__(message, response)
 
+  def free_chat(self, message):
+    message_ids = self.dialog_tokenizer.encode(message + self.eos, return_tensors='pt')
+    self.history['input_ids'] = torch.cat([self.history['input_ids'], message_ids], dim=-1)
+    input_ids = self.history['input_ids'].clone()
 
-if __name__ == '__main__':
-  # euc_100()
-  # euc_200('I am happy about my academic record.')
-  parser = argparse.ArgumentParser()
-  parser.add_argument('--run_on_own_server', type=int, default=0, help='if test on own server, need to use share mode')
-  args = parser.parse_args()
-  args.greeting = [('','Hi you!')]
+    while True:
+      bot_output_ids = self.dialog_model.generate(input_ids, max_length=1000,
+                                          do_sample=True, top_p=0.9, temperature=0.8, num_beams=2,
+                                          pad_token_id=self.dialog_tokenizer.eos_token_id)
+      response = self.dialog_tokenizer.decode(bot_output_ids[0][input_ids.shape[-1]:],
+                                       skip_special_tokens=True)
+      if response.strip() != '':
+        break
+      elif input_ids[0].tolist().count(self.dialog_tokenizer.eos_token_id) > 0:
+        idx = input_ids[0].tolist().index(self.dialog_tokenizer.eos_token_id)
+        input_ids = input_ids[:, (idx+1):]
+      else:
+        input_ids = message_ids
+
+      if self.run_on_own_server:
+        print(input_ids)
+
+    self.history['input_ids'] = torch.cat([self.history['input_ids'], bot_output_ids[0:1, input_ids.shape[-1]:]], dim=-1)
+    if self.run_on_own_server == 1:
+      print((message, response), '\n', self.history['input_ids'])
 
-  tokenizer = GPT2Tokenizer.from_pretrained('tareknaous/dialogpt-empathetic-dialogues')
-  model = GPT2LMHeadModel.from_pretrained('tareknaous/dialogpt-empathetic-dialogues')
-  model.eval()
-  def chat(message, history):
-    return _chat(message, history, model, tokenizer, args)
+    return response
+
+
+if __name__ == '__main__':
+  args = option()
+  chat = TherapyChatBot(args)
 
   title = 'PsyPlus Empathetic Chatbot'
   description = 'Gradio demo for product of PsyPlus. Based on rule-based CBT and conversational AI model DialoGPT'
-  chatbot = gr.Chatbot(value=args.greeting)
+  chatbot = gr.Chatbot(value=chat.history['text'])
   iface = gr.Interface(
-    chat,
-    ['text', 'state'],
-    [chatbot, 'state'],
-    # css=".gradio-container {background-color: white}",
-    allow_flagging='never',
-    title=title,
-    description=description,
+    chat, 'text', chatbot,
+    allow_flagging='never', title=title, description=description,
   )
+
+  # iface.queue(concurrency_count=5)
   if args.run_on_own_server == 0:
     iface.launch(debug=True)
   else:
-    iface.launch(debug=True, server_name='0.0.0.0', server_port=2022, share=True)
+    iface.launch(debug=True, share=True) # server_name='0.0.0.0', server_port=2022