Update app.py

app.py

@@ -1,86 +1,126 @@
+import transformers
 import gradio as gr
 import pandas as pd
-import text_gen as gen
+from text_gen import generate_text
 
 
-NUM_QUESTIONS = 10
-answers = {}
-separator = '<[._.]>'
-
-df = pd.read_csv('lines_2.txt', sep='*')
-df = pd.concat([df[df.Part == 'Start'].sample(1),
-                df[df.Part == 'Middle_1'].sample(1),
-                df[df.Part == 'Middle_2'].sample(1),
-                df[df.Part == 'Middle_3'].sample(1),
-                df[df.Part == 'Middle_4'].sample(NUM_QUESTIONS-5),
-                df[df.Part == 'End'].sample(1)]
-                ).fillna('')
+def get_answer(question, answer, options):
+    '''File given answer'''
+    
+    global questions
+    global SEPARATOR
+    answer = options.split(SEPARATOR)[answer]
+    questions['Choice'][questions.Question == question] = answer
 
-questions = dict(zip(df.Question, df.Answer))
-context = dict(zip(df.Question, df.Context))
 
-def get_answer(question, answer, options):
-    global answers
-    global separator
-    answer = options.split(separator)[answer]
-    answers.update({question:int(answer == questions[question])})
+def find_score(column_name, questions):
+    '''Count chosen answers in a given column'''
+    
+    actual = questions[column_name].to_list()
+    chosen = questions.Choice.to_list()
+    return sum(a == c for a, c in zip(actual, chosen))
 
 
 def set_score():
-    global answers
+    '''Return the score (for the human and for the models)'''
+    
     global NUM_QUESTIONS
-    score = sum(answers.values())
+    score = find_score(answers[0], questions)
+    ai_score = {name:find_score(name, questions) for name in answers[1:]}
+
     start = '## <p style="text-align: center;">'
     end = '</p>'
-    if score == 0: return f'{start}Not a single right answer. Are you doing this on purpose?{end}'
-    elif score <= NUM_QUESTIONS / 2 + 1: return f'{start}Only {score} right answers out of {NUM_QUESTIONS}. You ought to pay more attention.{end}'
-    elif score == NUM_QUESTIONS: return f'{start}Perfect score!{end}'
-    else: return f'{start}{score} right answers out of {NUM_QUESTIONS}. It\'s probably alright.{end}'
 
+    if       score == NUM_QUESTIONS:         text = f'Perfect score!'
+    else:
+        if   score == 0:                     text = 'Not a single right answer. Are you doing this on purpose?'
+        elif score <= NUM_QUESTIONS / 2 + 1: text = f'Only {score} right answers out of {NUM_QUESTIONS}. You ought to pay more attention.'
+        else:                                text = f'{score} right answers out of {NUM_QUESTIONS}. It\'s probably alright.'
+        for name in ai_score.keys():
+            text += f'\n{name} got {ai_score[name]}.'
+
+    return start + text + end
+
+if __name__ == "__main__":
+
+    NUM_QUESTIONS = 10
+    SEPARATOR = '<[._.]>'
+
+
+    # Adding/replacing models may require adjustments to text_gen.py
+    model_names = ['microsoft/GODEL-v1_1-large-seq2seq',
+                   'facebook/blenderbot-1B-distill',
+                   'facebook/blenderbot_small-90M']
+
+    tokenizers = [transformers.AutoTokenizer.from_pretrained(model_names[0]),
+                  transformers.BlenderbotTokenizer.from_pretrained(model_names[1]),
+                  transformers.BlenderbotSmallTokenizer.from_pretrained(model_names[2])]
+
+    model = [transformers.AutoModelForSeq2SeqLM.from_pretrained(model_names[0]),
+             transformers.BlenderbotForConditionalGeneration.from_pretrained(model_names[1]),
+             transformers.BlenderbotSmallForConditionalGeneration.from_pretrained(model_names[2])]
+
+
+    # Semi-randomly choose questions
+    questions = pd.read_csv('lines_2.txt', sep='*')
+    questions = pd.concat([questions[questions.Part == 'Start'].sample(1),
+                           questions[questions.Part == 'Middle_1'].sample(1),
+                           questions[questions.Part == 'Middle_2'].sample(1),
+                           questions[questions.Part == 'Middle_3'].sample(1),
+                           questions[questions.Part == 'Middle_4'].sample(NUM_QUESTIONS-5),
+                           questions[questions.Part == 'End'].sample(1)]
+                           ).fillna('')
+
+
+# Generate answers
 
-wrong_answers = {q:[gen.generate_text(
-                    q,
-                    context[q],
-                    gen.model_names[i],
-                    gen.model[i],
-                    gen.tokenizers[i],
-                    minimum=len(questions[q].split())+8)
-                    for i in range(3)]
-                for q in questions.keys()}
+    for i in range(len(model_names)):
+        questions[model_names[i]] = questions.Question.apply(
+                                    lambda x: generate_text(
+                                              x,
+                                              questions.Context[questions.Question == x].iat[0],
+                                              model_names[i],
+                                              model[i],
+                                              tokenizers[i],
+                                              minimum=len(questions.Answer[questions.Question == x].iat[0].split())+8))
 
 
-with gr.Blocks(theme='glass') as demo:
-    with gr.Row():
+    questions['Choice'] = ''
+    answers = ['Answer'] + model_names
 
-        with gr.Column(scale=1):
-            pass
 
-        with gr.Column(scale=2):
+    # App
+    with gr.Blocks() as test_gen:
+        with gr.Row():
 
-            gr.Markdown(f'## <p style="text-align: center;">IMITATION GAME</p>\n' +
-                        f'### <p style="text-align: center;">Choose answers NOT given by an AI model.')
+            with gr.Column(scale=1):
+                pass
 
-            for ind, question in enumerate(list(questions.keys()), start=1):
-                letters = list('ABCD')
-                options = list(set(wrong_answers[question] + [questions[question]]))
+            with gr.Column(scale=2):
 
-                gr.Markdown(f'### <p>{ind}. {question}</p>')
+                gr.Markdown(f'## <p style="text-align: center;">IMITATION GAME</p>\n' +
+                            f'### <p style="text-align: center;">Choose answers NOT given by an AI model.')
 
-                for letter, option in zip(letters, options):
-                    gr.Markdown(f'{letter}. {option}')
+                for ind, question in enumerate(questions.Question.to_list(), start=1):
+                    letters = list('ABCD')
+                    options = list(set([questions[col][questions.Question == question].iat[0] for col in answers]))
 
-                options = gr.State(separator.join(options))
+                    gr.Markdown(f'### <p>{ind}. {question}</p>')
 
-                radio = gr.Radio(letters, type='index', show_label=False)
-                question = gr.State(question)
-                radio.change(fn=get_answer, inputs=[question, radio, options])
+                    for letter, option in zip(letters, options):
+                        gr.Markdown(f'{letter}. {option}')
 
-            button = gr.Button(value='Get score')
-            score = gr.Markdown()
-            button.click(fn=set_score, outputs=score)
+                    options = gr.State(SEPARATOR.join(options))
 
-        with gr.Column(scale=1):
-            pass
+                    radio = gr.Radio(letters, type='index', show_label=False)
+                    question = gr.State(question)
+                    radio.change(fn=get_answer, inputs=[question, radio, options])
 
+                button = gr.Button(value='Get score')
+                score = gr.Markdown()
+                button.click(fn=set_score, outputs=score)
 
-demo.launch()
+            with gr.Column(scale=1):
+                pass
+            
+    test_gen.launch()