adds probability_emote page

app.py

@@ -1,5 +1,6 @@
 import streamlit as st
-from lib.story_gen import StoryGenerator
+from src.story_gen import StoryGenerator
+from src.probability_emote import run_pe
 import plotly.express as px
 import random
 import numpy as np
@@ -11,36 +12,41 @@ container_mode = st.sidebar.container()
 container_guide = st.container()
 container_param = st.sidebar.container()
 container_button = st.sidebar.container()
-
 mode = container_mode.radio(
     "Select a mode",
     ('Probability Emote', 'Create Statistics', 'Play Storytelling'), index=0)
 
-choices_first_sentence = [
-    'Custom',
-    'Hello, I\'m a language model,',
-    'So I suppose you want to ask me how I did it.',
-    'I always wanted to be a giraffe - until that night.',
-    'My first tutor was a dragon with a terrible sense of humor.',
-    'Doctors told her she could never diet again.',
-    'Memory is all around us, as well as within.',
 
+def initialise_storytelling():
+    choices_first_sentence = [
+        'Custom',
+        'Hello, I\'m a language model,',
+        'So I suppose you want to ask me how I did it.',
+        'I always wanted to be a giraffe - until that night.',
+        'My first tutor was a dragon with a terrible sense of humor.',
+        'Doctors told her she could never diet again.',
+        'Memory is all around us, as well as within.',
 
-]
-cfs = st.selectbox('Choose First Sentence', choices_first_sentence)
-if cfs == 'Custom':
-    story_till_now = st.text_input(
-        label='First Sentence', key='first_sentence')
-else:
-    st.session_state.first_sentence = cfs
-    story_till_now = cfs
-first_sentence = story_till_now
-first_emotion = gen.get_emotion(first_sentence)
 
-length = container_param.slider(label='Length of the generated sentence',
-                                min_value=1, max_value=100, value=10, step=1)
-if mode == 'Create Statistics':
+    ]
+    cfs = st.selectbox('Choose First Sentence', choices_first_sentence)
+    if cfs == 'Custom':
+        story_till_now = st.text_input(
+            label='First Sentence', key='first_sentence')
+    else:
+        st.session_state.first_sentence = cfs
+        story_till_now = cfs
+    first_sentence = story_till_now
+    first_emotion = gen.get_emotion(first_sentence)
+
+    length = container_param.slider(label='Length of the generated sentence',
+                                    min_value=1, max_value=100, value=10, step=1)
+    return first_sentence, first_emotion, length
 
+
+if mode == 'Create Statistics':
+    first_sentence, first_emotion, length = initialise_storytelling()
+    # story_till_now = first_sentence
     num_generation = container_param.slider(
         label='Number of generation', min_value=1, max_value=100, value=5, step=1)
     num_tests = container_param.slider(
@@ -53,7 +59,7 @@ if mode == 'Create Statistics':
     elif reaction_weight_mode == "Random":
         reaction_weight = -1
     if container_button.button('Analyse'):
-        gen.get_stats(story_till_now=story_till_now,
+        gen.get_stats(story_till_now=first_sentence,
                       num_generation=num_generation, length=length, reaction_weight=reaction_weight, num_tests=num_tests)
         # if len(gen.stories) > 0:
         #     for si, story in enumerate(gen.stories):
@@ -87,13 +93,14 @@ if mode == 'Create Statistics':
         container_guide.markdown(
             '### You selected statistics. Now set your parameters and click the `Analyse` button.')
 elif mode == 'Play Storytelling':
-
+    first_sentence, first_emotion, length = initialise_storytelling()
+    # story_till_now = first_sentence
     if 'sentence_list' not in st.session_state:
         st.session_state.sentence_list = [{'sentence': first_sentence,
                                            'emotion': first_emotion['label'],
                                            'score': first_emotion['score']}]
     if 'full_story' not in st.session_state:
-        st.session_state.full_story = story_till_now
+        st.session_state.full_story = first_sentence
     container_button = container_button.columns([1, 1, 1])
     heading_container = st.container()
     col_turn, col_sentence, col_emo = st.columns([1, 8, 2])
@@ -129,5 +136,6 @@ elif mode == 'Play Storytelling':
         st.session_state.sentence_list = [{'sentence': first_sentence,
                                            'emotion': first_emotion['label'],
                                            'score': first_emotion['score']}]
-# elif mode == 'Analyse Emotions':
-#     container_mode.write('Let\'s play storytelling.')
+elif mode == 'Probability Emote':
+    # container_mode.write('Let\'s play storytelling.')
+    run_pe(container_param)

src/probability_emote.py

@@ -0,0 +1,184 @@
+import streamlit as st
+
+import plotly.express as px
+import plotly.graph_objects as go
+
+import numpy as np
+import numpy as np
+
+@st.cache
+def get_w(f, ec=0.86, rv=0.50):
+    result = (rv + f-1)/(ec + f-1)
+    result = np.clip(result, 0, 1)
+    print(f'w = {result}')
+    return result
+
+@st.cache
+def get_f(w, ec=0.86, rv=0.50):
+    result = 1+(ec*w-rv)/(1-w)
+    result = np.clip(result, 0, 1)
+    print(f'f = {result}')
+    return result
+
+@st.cache
+def get_pe(w, ec=0.86, f=0.50):
+    result = ec*w+(1-w)*(1-f)
+    result = np.clip(result, 0, 1)
+    print(f'f = {result}')
+    return result
+
+xdata1 = np.arange(0, 1.1, step=0.01)
+# rand = np.random.random_sample()
+
+@st.cache
+def proper_float(i):
+    return np.round(i, 2)
+
+@st.cache
+def get_text():
+    return  '''  
+                 
+## Description
+### Eric's proposal
+> I would propose a scoring metric something like this:
+> * `probability_emote = w * emotion_confidence + (1 - w) * frequency_penalty`
+> 
+> Where:
+> * emotion_confidence: a score from 0.0 to 1.0 representing the emotion model’s confidence in it’s classification results
+> * frequency_penalty: a score from 0.0 to 1.0 where a high score penalizes frequent emotes
+> * `frequency_penalty = 1 - emotion_frequency`
+> * w: a weight from 0.0 to 1.0 that controls the balance between emotion_confidence and frequency_penalty
+> * Then you generate a random number between 0.0 and 1.0 and emote if it is greater than probability_emote
+> * You will have to set frequency_penalty and w through trial and error, but you can start with setting w=0.5 and giving the emotion classifier and frequency penalty equal weight.
+> * Setting w=1.0 would disable the frequency penalty altogether
+    '''
+
+@st.cache
+def get_equation_text(w=0.5, ec=0.7, rand=None, emotion_frequency=None):
+    text =  f''' 
+    #### Equation
+    * frequency_penalty = 1 - emotion_frequency 
+    * probability_emote = w * emotion_confidence + (1 - w) * frequency_penalty
+    * **probability_emote** = {proper_float(w)} * {proper_float(ec)} + {proper_float(1-w)} * frequency_penalty
+
+    '''  
+    if rand is not None:
+        frequency_penalty=proper_float(1-emotion_frequency)
+        probability_emote=proper_float((w)*(ec)+(1-w)*frequency_penalty)
+        text = f''' 
+    #### Equation
+    * frequency_penalty = 1 - emotion_frequency = 1 - {emotion_frequency}  = {frequency_penalty} 
+    * probability_emote = w * emotion_confidence + (1 - w) * frequency_penalty
+    * probability_emote = {proper_float(w)} * {proper_float(ec)} + {proper_float(1-w)} * {frequency_penalty}
+    * **probability_emote** = {probability_emote}
+    * Show_Emotion 
+      = probability_emote > (Random value between 0 and 1)
+    * Random value = {rand}
+    * Show_Emotion = {probability_emote} > {rand}
+    * **Show_Emotion** = {probability_emote > rand}
+    '''  
+    return text
+
+def set_input(container_param, 
+    label, key_slider, key_input,
+    min_value=0.,
+    max_value=1.,
+    value=.5,
+    step=.01,):
+    def slider2input():
+        st.session_state[key_input] = st.session_state[key_slider]
+    def input2slider():
+        st.session_state[key_slider] = st.session_state[key_input]
+    container_param=container_param.columns([1.1, 1])
+    slider_input = container_param[1].slider(
+        label=label, 
+        min_value=min_value,
+        max_value=max_value,
+        value=value,
+        step=step,
+        key = key_slider,
+        on_change=slider2input)
+    number_input= container_param[0].number_input(
+        label='', 
+        min_value=min_value,
+        max_value=max_value,
+        value=value,
+        step=step,
+        key = key_input,
+        on_change=input2slider)
+    return slider_input, number_input
+    
+def run_pe(container_param):
+    w_slider, w=set_input(container_param, 
+    label='Weight w', key_slider='w_slider', key_input='w_input',
+    min_value=0.,
+    max_value=1.,
+    value=.5,
+    step=.01,)
+    score_slider, score=set_input(container_param, 
+    label='Confidence Score', key_slider='score_slider', key_input='score_input',
+    min_value=0.,
+    max_value=1.,
+    value=.5,
+    step=.01,)
+    # score = container_param.slider(
+    #     label='Confidence Score', 
+    #     min_value=0.,
+    #     max_value=1.,
+    #     value=.5,
+    #     step=.01)
+    calculate_check = container_param.checkbox(label='Calculate', value=False)
+    if calculate_check:
+        emotion_frequency_slider, emotion_frequency=set_input(container_param, 
+        label='Emotion Frequency', key_slider='emotion_frequency_slider_slider', key_input='emotion_frequency_slider_input',
+        min_value=0.,
+        max_value=1.,
+        value=.5,
+        step=.01,)
+        rand_slider, rand=set_input(container_param, 
+        label='Weight w', key_slider='rand_slider', key_input='rand_input',
+        min_value=0.,
+        max_value=1.,
+        value=.5,
+        step=.01,)
+    else:
+        emotion_frequency='emotion_frequency'
+        rand=None
+    st.markdown(get_equation_text(w=w, ec=score, rand=rand, emotion_frequency=emotion_frequency))
+    fig = go.Figure()
+    # fig.add_trace(go.Scatter(x=xdata1, y=np.ones_like(xdata1)*rand,
+    #                       mode='markers', name='Random',
+    #     line=dict(color='#ff8300', width=2)
+    #                       ))
+    if calculate_check:
+        dd = 0.01
+        fig.add_hline(y=rand, line_width=3, line_dash="dash", line_color="#ff8300")
+        fig.add_vline(x=emotion_frequency, line_width=3, line_dash="dash", line_color="green")
+        fig.add_trace(go.Scatter(
+        x=[emotion_frequency-dd, emotion_frequency+dd], y=[rand-dd, rand+dd],
+        mode='lines',
+        line=dict(color='#ee00ee', width=8)
+        ),)
+        fig.add_trace(go.Scatter(
+        x=[emotion_frequency+dd, emotion_frequency-dd], y=[rand-dd, rand+dd],
+        mode='lines',
+        line=dict(color='#ee00ee', width=8)
+        ),)
+    fig.add_trace(go.Scatter(
+        x=xdata1, y=get_pe(w=w, f=xdata1, ec=score),
+        mode='lines',
+        name='Probability-Emote',
+        line=dict(color='#00eeee', width=4)
+        ),
+        )
+
+    fig.update_layout(
+        template='plotly_dark',
+        xaxis_range=[0., 1.],
+        yaxis_range=[0., 1.],
+        xaxis_title="Emotion Frequency",
+        yaxis_title="Probability Emote",
+        showlegend=False
+    )
+    st.plotly_chart(fig, use_container_width=True)
+    st.markdown(get_text())

src/story_gen.py

@@ -0,0 +1,221 @@
+
+import sys
+import time
+
+import printj
+from transformers import pipeline  # , set_seed
+import numpy as np
+import pandas as pd
+# import nltk
+import re
+import streamlit as st
+
+
+class StoryGenerator:
+    def __init__(self):
+        self.initialise_models()
+        self.stats_df = pd.DataFrame(data=[], columns=[])
+        self.stories = []
+        self.data = []
+
+    @staticmethod
+    @st.cache(allow_output_mutation=True)
+    def get_generator():
+        return pipeline('text-generation', model='gpt2')
+
+    @staticmethod
+    @st.cache(allow_output_mutation=True)
+    def get_classifier():
+        return pipeline("text-classification",
+                        model="j-hartmann/emotion-english-distilroberta-base", return_all_scores=True)
+
+    def initialise_models(self):
+        # start = time.time()
+        self.generator = self.get_generator()
+        self.classifier = self.get_classifier()
+        # initialising_time = time.time()-start
+        # print(f'Initialising Time: {initialising_time}')
+        # set_seed(42)
+        # sys.exit()
+
+    def reset():
+        self.clear_stories()
+        self.clear_stats()
+
+    def clear_stories(self):
+        self.data = []
+        self.stories = []
+
+    def clear_stats(self):
+        self.stats_df = pd.DataFrame(data=[], columns=[])
+
+    def get_emotion(self, text):
+        emotions = self.classifier(text)
+        emotion = max(emotions[0], key=lambda x: x['score'])
+        return emotion
+
+    @staticmethod
+    def get_num_token(text):
+        # return len(nltk.word_tokenize(text))
+        return len(re.findall(r'\w+', text))
+
+    @staticmethod
+    def check_show_emotion(confidence_score, frequency, w):
+        frequency_penalty = 1 - frequency
+        probability_emote = w * confidence_score + (1-w) * frequency_penalty
+        return probability_emote > np.random.random_sample()
+
+    def story(self,
+              story_till_now="Hello, I'm a language model,",
+              num_generation=4,
+              length=10):
+        # last_length = 0
+
+        for i in range(num_generation):
+            last_length = len(story_till_now)
+            genreate_robot_sentence = self.generator(story_till_now, max_length=self.get_num_token(story_till_now) +
+                                                     length, num_return_sequences=1)
+            story_till_now = genreate_robot_sentence[0]['generated_text']
+            new_sentence = story_till_now[last_length:]
+            emotion = self.get_emotion(new_sentence)
+            # printj.yellow(f'Sentence {i}:')
+            # story_to_print = f'{printj.ColorText.cyan(story_till_now[:last_length])}{printj.ColorText.green(story_till_now[last_length:])}\n'
+            # print(story_to_print)
+            # printj.purple(f'Emotion: {emotion}')
+        return story_till_now, emotion
+    
+    def next_sentence(self,
+            story_till_now="Hello, I'm a language model,",
+            length=10):
+        last_length = len(story_till_now)
+        genreate_robot_sentence = self.generator(story_till_now, max_length=self.get_num_token(story_till_now) +
+                                                    length, num_return_sequences=1)
+        story_till_now = genreate_robot_sentence[0]['generated_text']
+        new_sentence = story_till_now[last_length:]
+        emotion = self.get_emotion(new_sentence)
+        return story_till_now, emotion, new_sentence
+        
+
+    def auto_ist(self,
+                 story_till_now="Hello, I'm a language model,",
+                 num_generation=4,
+                 length=20, reaction_weight=0.5):
+        stats_df = pd.DataFrame(data=[], columns=[])
+        stats_dict = dict()
+        num_reactions = 0
+        reaction_frequency = 0
+        emotion = self.get_emotion(story_till_now)  # first line emotion
+        story_data = [{
+            'sentence': story_till_now,
+            'turn': 'first',
+            'emotion': emotion['label'],
+            'confidence_score': emotion['score'],
+        }]
+        for i in range(num_generation):
+            # Text generation for User
+            last_length = len(story_till_now)
+            printj.cyan(story_till_now)
+            printj.red.bold_on_white(
+                f'loop: {i}; generate user text; length: {last_length}')
+            genreate_user_sentence = self.generator(story_till_now, max_length=self.get_num_token(
+                story_till_now)+length, num_return_sequences=1)
+            story_till_now = genreate_user_sentence[0]['generated_text']
+            new_sentence_user = story_till_now[last_length:]
+
+            printj.red.bold_on_white(f'loop: {i}; check emotion')
+            # Emotion self.classifier for User
+            emotion_user = self.get_emotion(new_sentence_user)
+            if emotion_user['label'] == 'neutral':
+                show_emotion_user = False
+            else:
+                reaction_frequency = num_reactions/(i+1)
+                show_emotion_user = self.check_show_emotion(
+                    confidence_score=emotion_user['score'], frequency=reaction_frequency, w=reaction_weight)
+            if show_emotion_user:
+                num_reactions += 1
+
+            story_data.append({
+                'sentence': new_sentence_user,
+                'turn': 'user',
+                'emotion': emotion_user['label'],
+                'confidence_score': emotion_user['score'],
+            })
+            stats_dict['sentence_no'] = i
+            stats_dict['turn'] = 'user'
+            stats_dict['sentence'] = new_sentence_user
+            stats_dict['show_emotion'] = show_emotion_user
+            stats_dict['emotion_label'] = emotion_user['label']
+            stats_dict['emotion_score'] = emotion_user['score']
+            stats_dict['num_reactions'] = num_reactions
+            stats_dict['reaction_frequency'] = reaction_frequency
+            stats_dict['reaction_weight'] = reaction_weight
+            stats_df = pd.concat(
+                [stats_df, pd.DataFrame(stats_dict, index=[f'idx_{i}'])])
+            # Text generation for Robot
+            last_length = len(story_till_now)
+            printj.cyan(story_till_now)
+            printj.red.bold_on_white(
+                f'loop: {i}; generate robot text; length: {last_length}')
+            genreate_robot_sentence = self.generator(story_till_now, max_length=self.get_num_token(
+                story_till_now)+length, num_return_sequences=1)
+            story_till_now = genreate_robot_sentence[0]['generated_text']
+            new_sentence_robot = story_till_now[last_length:]
+            emotion_robot = self.get_emotion(new_sentence_robot)
+
+            story_data.append({
+                'sentence': new_sentence_robot,
+                'turn': 'robot',
+                'emotion': emotion_robot['label'],
+                'confidence_score': emotion_robot['score'],
+            })
+            stats_dict['sentence_no'] = i
+            stats_dict['turn'] = 'robot'
+            stats_dict['sentence'] = new_sentence_robot
+            stats_dict['show_emotion'] = None
+            stats_dict['emotion_label'] = emotion_robot['label']
+            stats_dict['emotion_score'] = emotion_robot['score']
+            stats_dict['num_reactions'] = None
+            stats_dict['reaction_frequency'] = None
+            stats_dict['reaction_weight'] = None
+            stats_df = pd.concat(
+                [stats_df, pd.DataFrame(stats_dict, index=[f'idx_{i}'])])
+
+        return stats_df, story_till_now, story_data
+
+    def get_stats(self,
+                  story_till_now="Hello, I'm a language model,",
+                  num_generation=4,
+                  length=20, reaction_weight=-1, num_tests=2):
+        use_random_w = reaction_weight == -1
+        # self.stories = []
+        try:
+            num_rows = max(self.stats_df.story_id)+1
+        except Exception:
+            num_rows = 0
+        for story_id in range(num_tests):
+            if use_random_w:
+                # reaction_weight = np.random.random_sample()
+                reaction_weight = np.round(np.random.random_sample(), 1)
+            stats_df0, _story_till_now, story_data = self.auto_ist(
+                story_till_now=story_till_now,
+                num_generation=num_generation,
+                length=length, reaction_weight=reaction_weight)
+            stats_df0.insert(loc=0, column='story_id', value=story_id+num_rows)
+
+            # stats_df0['story_id'] = story_id
+            self.stats_df = pd.concat([self.stats_df, stats_df0])
+            printj.yellow(f'story_id: {story_id}')
+            printj.green(stats_df0)
+            self.stories.append(_story_till_now)
+            self.data.append(story_data)
+        self.stats_df = self.stats_df.reset_index(drop=True)
+        print(self.stats_df)
+
+    def save_stats(self, path='pandas_simple.xlsx'):
+        writer = pd.ExcelWriter(path, engine='xlsxwriter')
+
+        # Convert the dataframe to an XlsxWriter Excel object.
+        self.stats_df.to_excel(writer, sheet_name='IST')
+
+        # Close the Pandas Excel writer and output the Excel file.
+        writer.save()

src/story_gen_test.py

@@ -0,0 +1,34 @@
+# %%
+import printj
+from story_gen import StoryGenerator
+
+gen = StoryGenerator()
+# # %%
+# story_till_now, emotion = gen.story(story_till_now='Hello, I\'m a language model,', num_generation=3, length=10)
+# printj.purple(story_till_now)
+# printj.yellow(emotion)
+
+
+# %%
+gen.get_stats(story_till_now="For myriad of eons i’ve forgotten who I really was, harvesting the essence of all existence.",
+             length=10, num_generation=3, num_tests=50)
+
+# %%
+gen.save_stats('/home/jitesh/haru/ist/results/a.xlsx')
+
+
+
+
+# %%
+data=gen.stats_df[gen.stats_df.sentence_no==3]
+import seaborn as sns
+sns.set_theme(style="whitegrid")
+# ax = sns.violinplot(x="day", y="total_bill", data=tips)
+ax = sns.violinplot(x="reaction_weight", y="num_reactions", data=data).set_title('Analysing ProbabilityEmote (Max reactions=3)')
+# %%
+
+gen.stats_df[gen.stats_df.sentence_no==3]
+# %%
+import re
+len(re.findall(r'\w+', 'line ive '))
+# %%