refactors

app.py

@@ -1,141 +1,31 @@
-import streamlit as st
-from src.story_gen import StoryGenerator
-from src.probability_emote import run_pe
-import plotly.express as px
 import random
+
 import numpy as np
+import plotly.express as px
+import streamlit as st
+
+from src import (StoryGenerator, run_create_statistics, run_play_storytelling,
+                 run_probability_emote)
 
 st.set_page_config(page_title='Storytelling ' +
-                   u'\U0001F5BC', page_icon=u'\U0001F5BC', layout="wide")
+                   u'\U0001F5BC', page_icon=u'\U0001F5BC', layout="wide",
+                   )
 gen = StoryGenerator()
 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)
 
 
-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)
-    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(
-        label='Number of tests', min_value=1, max_value=1000, value=3, step=1)
-    reaction_weight_mode = container_param.select_slider(
-        "Reaction Weight w:", ["Random", "Fixed"])
-    if reaction_weight_mode == "Fixed":
-        reaction_weight = container_param.slider(
-            label='Reaction Weight w', min_value=0.0, max_value=1.0, value=0.5, step=0.01)
-    elif reaction_weight_mode == "Random":
-        reaction_weight = -1
-    if container_button.button('Analyse'):
-        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):
-        #         st.markdown(f'### Story no. {si}:', unsafe_allow_html=False)
-        #         st.markdown(story, unsafe_allow_html=False)
-        #     data=gen.stats_df[gen.stats_df.sentence_no==3]
-        #     fig = px.violin(data_frame=data, x="reaction_weight", y="num_reactions", hover_data=data.columns)
-        #     st.plotly_chart(fig, use_container_width=True)
-        #     fig2 = px.box(data_frame=data, x="reaction_weight", y="num_reactions", hover_data=data.columns)
-        #     st.plotly_chart(fig2, use_container_width=True)
-        if len(gen.data) > 0:
-            for si, story in enumerate(gen.data):
-                st.markdown(f'### Story {si}:', unsafe_allow_html=False)
-                for i, sentence in enumerate(story):
-                    col_turn, col_sentence, col_emo = st.columns([1, 8, 2])
-                    col_turn.markdown(
-                        sentence['turn'], unsafe_allow_html=False)
-                    col_sentence.markdown(
-                        sentence['sentence'], unsafe_allow_html=False)
-                    col_emo.markdown(
-                        f'{sentence["emotion"]} {np.round(sentence["confidence_score"], 3)}', unsafe_allow_html=False)
-            st.table(data=gen.stats_df, )
-            data = gen.stats_df[gen.stats_df.sentence_no == 3]
-            fig = px.violin(data_frame=data, x="reaction_weight",
-                            y="num_reactions", hover_data=data.columns)
-            st.plotly_chart(fig, use_container_width=True)
-            fig2 = px.box(data_frame=data, x="reaction_weight",
-                          y="num_reactions", hover_data=data.columns)
-            st.plotly_chart(fig2, use_container_width=True)
-    else:
-        container_guide.markdown(
-            '### You selected statistics. Now set your parameters and click the `Analyse` button.')
+    run_create_statistics(gen, container_guide,
+                          container_param, container_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 = 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])
-    if container_button[0].button('Run'):
-        heading_container.markdown(f'### Story')
-
-        # st.text(story_till_now)
-        full_story, emotion, new_sentence = gen.next_sentence(
-            st.session_state.full_story, length)
-        st.session_state.full_story = full_story
-        st.session_state.sentence_list.append({
-            'sentence': new_sentence,
-            'emotion': emotion["label"],
-            'score': emotion["score"]})
-        # col_sentence.markdown(st.session_state.sentence_list)
-        for step in st.session_state.sentence_list:
-            col_turn, col_sentence, col_emo = st.columns([1, 8, 2])
-            col_sentence.markdown(step['sentence'])
-            col_emo.markdown(
-                f'{step["emotion"]} {np.round(step["score"], 3)}', unsafe_allow_html=False)
-
-    else:
-        step = st.session_state.sentence_list[0]
-        # col_sentence.markdown(step['sentence'])
-        # col_emo.markdown(
-        #     f'{step["emotion"]} {np.round(step["score"], 3)}', unsafe_allow_html=False)
-        container_guide.markdown(
-            '### Write the first sentence and then hit the `Run` button')
-
-    if container_button[2].button('Clear'):
-
-        st.session_state.full_story = first_sentence
-        st.session_state.sentence_list = [{'sentence': first_sentence,
-                                           'emotion': first_emotion['label'],
-                                           'score': first_emotion['score']}]
+    run_play_storytelling(gen, container_guide,
+                          container_param, container_button)
 elif mode == 'Probability Emote':
-    # container_mode.write('Let\'s play storytelling.')
-    run_pe(container_param)
+    run_probability_emote(container_param)

src/__init__.py

@@ -0,0 +1,4 @@
+from .story_gen import StoryGenerator
+from .probability_emote import run_probability_emote
+from .create_statistics import run_create_statistics
+from .play_storytelling import run_play_storytelling

src/create_statistics.py

@@ -0,0 +1,59 @@
+import random
+
+import numpy as np
+import plotly.express as px
+import streamlit as st
+
+from .lib import initialise_storytelling
+
+
+def run_create_statistics(gen, container_guide, container_param, container_button):
+
+    first_sentence, first_emotion, length = initialise_storytelling(
+        gen, container_guide, container_param, container_button)
+    # 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(
+        label='Number of tests', min_value=1, max_value=1000, value=3, step=1)
+    reaction_weight_mode = container_param.select_slider(
+        "Reaction Weight w:", ["Random", "Fixed"])
+    if reaction_weight_mode == "Fixed":
+        reaction_weight = container_param.slider(
+            label='Reaction Weight w', min_value=0.0, max_value=1.0, value=0.5, step=0.01)
+    elif reaction_weight_mode == "Random":
+        reaction_weight = -1
+    if container_button.button('Analyse'):
+        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):
+        #         st.markdown(f'### Story no. {si}:', unsafe_allow_html=False)
+        #         st.markdown(story, unsafe_allow_html=False)
+        #     data=gen.stats_df[gen.stats_df.sentence_no==3]
+        #     fig = px.violin(data_frame=data, x="reaction_weight", y="num_reactions", hover_data=data.columns)
+        #     st.plotly_chart(fig, use_container_width=True)
+        #     fig2 = px.box(data_frame=data, x="reaction_weight", y="num_reactions", hover_data=data.columns)
+        #     st.plotly_chart(fig2, use_container_width=True)
+        if len(gen.data) > 0:
+            for si, story in enumerate(gen.data):
+                st.markdown(f'### Story {si}:', unsafe_allow_html=False)
+                for i, sentence in enumerate(story):
+                    col_turn, col_sentence, col_emo = st.columns([1, 8, 2])
+                    col_turn.markdown(
+                        sentence['turn'], unsafe_allow_html=False)
+                    col_sentence.markdown(
+                        sentence['sentence'], unsafe_allow_html=False)
+                    col_emo.markdown(
+                        f'{sentence["emotion"]} {np.round(sentence["confidence_score"], 3)}', unsafe_allow_html=False)
+            st.table(data=gen.stats_df, )
+            data = gen.stats_df[gen.stats_df.sentence_no == 3]
+            fig = px.violin(data_frame=data, x="reaction_weight",
+                            y="num_reactions", hover_data=data.columns)
+            st.plotly_chart(fig, use_container_width=True)
+            fig2 = px.box(data_frame=data, x="reaction_weight",
+                          y="num_reactions", hover_data=data.columns)
+            st.plotly_chart(fig2, use_container_width=True)
+    else:
+        container_guide.markdown(
+            '### You selected statistics. Now set your parameters and click the `Analyse` button.')

src/lib.py

@@ -0,0 +1,32 @@
+import random
+
+import streamlit as st
+
+from src import StoryGenerator
+
+
+def initialise_storytelling(gen, container_guide, container_param, container_button):
+    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)
+    return first_sentence, first_emotion, length

src/play_storytelling.py

@@ -0,0 +1,53 @@
+import random
+
+import numpy as np
+import streamlit as st
+
+from .lib import initialise_storytelling
+
+
+def run_play_storytelling(gen, container_guide, container_param, container_button):
+    first_sentence, first_emotion, length = initialise_storytelling(
+        gen, container_guide, container_param, container_button)
+    # 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 = 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])
+    if container_button[0].button('Run'):
+        heading_container.markdown(f'### Story')
+
+        # st.text(story_till_now)
+        full_story, emotion, new_sentence = gen.next_sentence(
+            st.session_state.full_story, length)
+        st.session_state.full_story = full_story
+        st.session_state.sentence_list.append({
+            'sentence': new_sentence,
+            'emotion': emotion["label"],
+            'score': emotion["score"]})
+        # col_sentence.markdown(st.session_state.sentence_list)
+        for step in st.session_state.sentence_list:
+            col_turn, col_sentence, col_emo = st.columns([1, 8, 2])
+            col_sentence.markdown(step['sentence'])
+            col_emo.markdown(
+                f'{step["emotion"]} {np.round(step["score"], 3)}', unsafe_allow_html=False)
+
+    else:
+        step = st.session_state.sentence_list[0]
+        # col_sentence.markdown(step['sentence'])
+        # col_emo.markdown(
+        #     f'{step["emotion"]} {np.round(step["score"], 3)}', unsafe_allow_html=False)
+        container_guide.markdown(
+            '### Write the first sentence and then hit the `Run` button')
+
+    if container_button[2].button('Clear'):
+
+        st.session_state.full_story = first_sentence
+        st.session_state.sentence_list = [{'sentence': first_sentence,
+                                           'emotion': first_emotion['label'],
+                                           'score': first_emotion['score']}]

src/probability_emote.py

@@ -1,10 +1,7 @@
-import streamlit as st
-
-import plotly.express as px
+import numpy as np
 import plotly.graph_objects as go
+import streamlit as st
 
-import numpy as np
-import numpy as np
 
 @st.cache
 def get_w(f, ec=0.86, rv=0.50):
@@ -13,6 +10,7 @@ def get_w(f, ec=0.86, rv=0.50):
     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)
@@ -20,6 +18,7 @@ def get_f(w, ec=0.86, rv=0.50):
     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)
@@ -27,44 +26,48 @@ def get_pe(w, ec=0.86, f=0.50):
     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  '''  
+    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
+    ## 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''' 
+    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)
+        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} 
@@ -76,75 +79,79 @@ def get_equation_text(w=0.5, ec=0.7, rand=None, emotion_frequency=None):
     * 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 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])
+    container_param = container_param.columns([1.1, 1])
     slider_input = container_param[1].slider(
-        label=label, 
+        label=label,
         min_value=min_value,
         max_value=max_value,
         value=value,
         step=step,
-        key = key_slider,
+        key=key_slider,
         on_change=slider2input)
-    number_input= container_param[0].number_input(
-        label='', 
+    number_input = container_param[0].number_input(
+        label='',
         min_value=min_value,
         max_value=max_value,
         value=value,
         step=step,
-        key = key_input,
+        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,)
+
+
+def run_probability_emote(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', 
+    #     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,)
+        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))
+        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',
@@ -152,25 +159,27 @@ def run_pe(container_param):
     #                       ))
     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_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)
+            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)
+            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',
@@ -181,4 +190,4 @@ def run_pe(container_param):
         showlegend=False
     )
     st.plotly_chart(fig, use_container_width=True)
-    st.markdown(get_text())
+    st.markdown(get_text())

src/story_gen.py

@@ -1,14 +1,14 @@
 
+# import nltk
+import re
 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 printj
 import streamlit as st
+from transformers import pipeline  # , set_seed
 
 
 class StoryGenerator:
@@ -83,18 +83,17 @@ class StoryGenerator:
             # 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):
+                      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)
+                                                 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,",