Make game replayable

src/handlers.py

@@ -3,8 +3,10 @@ import logging
 from transformers import PreTrainedTokenizer
 
 from src.constants import MAX_ATTEMPTS
+from src.constants import STARTING_INDEX
 from src.params import ReducerParams
 from src.shared import all_tokens
+from src.shared import tokenizer
 from src.utils import get_current_prompt_text
 
 logger = logging.getLogger(__name__)
@@ -33,7 +35,7 @@ def handle_lm_win(params: ReducerParams) -> ReducerParams:
 
 def handle_out_of_attempts(params: ReducerParams) -> ReducerParams:
     params.button_label = "Next word"
-    params.bottom_html = "Out of attempts. No one gets points!"
+    params.bottom_html = f"Out of attempts. No one gets points! The correct word was: {tokenizer.decode(all_tokens[STARTING_INDEX + params.word_number])}"
     return params
 
 

src/interface.py

@@ -1,9 +1,8 @@
 import gradio as gr
 
 from src import reducer
-from src import shared
 from src.constants import MAX_ATTEMPTS
-from src.constants import STARTING_INDEX
+from src.shared import INITIAL_STATE
 from src.utils import get_current_lm_guess_str
 
 
@@ -24,24 +23,24 @@ def build_demo():
             )
         with gr.Row():
             prompt_text = gr.Textbox(
-                value=shared.tokenizer.decode(shared.all_tokens[:STARTING_INDEX]),
+                value=INITIAL_STATE.prompt_text,
                 label="Context",
                 interactive=False,
             )
         with gr.Row():
             with gr.Column():
-                player_points = gr.Number(label="your points", interactive=False)
+                player_points = gr.Number(label="your points", interactive=False, value=INITIAL_STATE.player_points)
             with gr.Column():
-                lm_points = gr.Number(label="LM points", interactive=False)
+                lm_points = gr.Number(label="LM points", interactive=False, value=INITIAL_STATE.lm_points)
         with gr.Row():
             with gr.Column():
                 remaining_attempts = gr.Number(
-                    value=MAX_ATTEMPTS,
+                    value=INITIAL_STATE.remaining_attempts,
                     label="Remaining attempts",
                     precision=0,
                     interactive=False,
                 )
-                current_guesses = gr.Textbox(label="Your guesses")
+                current_guesses = gr.Textbox(label="Your guesses", value=INITIAL_STATE.current_guesses)
             with gr.Column():
                 lm_guesses = gr.Textbox(
                     label="LM guesses", value=get_current_lm_guess_str(0, remaining_attempts=MAX_ATTEMPTS)
@@ -49,13 +48,13 @@ def build_demo():
 
         with gr.Row():
             with gr.Column():
-                guess_field = gr.Textbox(label="")
-                guess_button = gr.Button(value="Guess!")
+                guess_field = gr.Textbox(label="", value=INITIAL_STATE.guess_field)
+                guess_button = gr.Button(value=INITIAL_STATE.button_label)
 
         with gr.Row():
-            bottom_html = gr.HTML()
+            bottom_html = gr.HTML(value=INITIAL_STATE.bottom_html)
         with gr.Row():
-            word_number = gr.Number(label="Word no.", interactive=False, precision=0)
+            word_number = gr.Number(label="Word no.", interactive=False, precision=0, value=INITIAL_STATE.word_number)
 
         guess_button.click(
             reducer.handle_guess,

src/reducer.py

@@ -1,6 +1,7 @@
 import logging
 
 from src.constants import END_WORD_NUMBER
+from src.constants import MAX_ATTEMPTS
 from src.constants import STARTING_INDEX
 from src.handlers import handle_both_wrong
 from src.handlers import handle_lm_win
@@ -10,6 +11,7 @@ from src.handlers import handle_out_of_attempts
 from src.handlers import handle_player_win
 from src.handlers import handle_tie
 from src.params import ReducerParams
+from src.shared import INITIAL_STATE
 from src.shared import token_predictions
 from src.shared import tokenizer
 from src.utils import get_current_lm_guess_str
@@ -29,6 +31,9 @@ def handle_guess(*args) -> ReducerParams:
 
 
 def _handle_guess(params: ReducerParams) -> ReducerParams:
+    if params.button_label == "Restart":
+        return INITIAL_STATE
+
     if params.word_number >= END_WORD_NUMBER:
         # FIXME: BAD PRACTICE
         if params.player_points > params.lm_points:
@@ -38,42 +43,33 @@ def _handle_guess(params: ReducerParams) -> ReducerParams:
         else:
             s = "CAN YOU BELIEVE IT!? A TIE"
 
-        return ReducerParams(
-            "",
-            params.player_points,
-            params.lm_points,
-            "",
-            "",
-            None,
-            "",
-            "Restart",
-            s,
-            0,
-        )
+        params.button_label = "Restart"
+        params.bottom_html = s
+        return params
 
     logger.debug(params)
     logger.debug(token_predictions[STARTING_INDEX + params.word_number])
+
     if params.button_label == "Next word":
         params = handle_next_word(params)
     elif not params.guess_field:
         params = handle_no_input(params)
     else:
-
-        params.current_guesses += params.guess_field + "\n"
+        params.current_guesses += (
+            params.guess_field if params.remaining_attempts == MAX_ATTEMPTS else "\n" + params.guess_field
+        )
         player_correct = guess_is_correct(params, tokenizer)
         lm_correct = lm_is_correct(params)
 
-        if params.remaining_attempts > 0:
-            params.remaining_attempts -= 1
-            if player_correct and lm_correct:
-                params = handle_tie(params)
-            elif player_correct and not lm_correct:
-                params = handle_player_win(params)
-            elif lm_correct and not player_correct:
-                params = handle_lm_win(params)
-            else:
-                params = handle_both_wrong(params)
-
+        params.remaining_attempts -= 1
+        if player_correct and lm_correct:
+            params = handle_tie(params)
+        elif player_correct and not lm_correct:
+            params = handle_player_win(params)
+        elif lm_correct and not player_correct:
+            params = handle_lm_win(params)
+        elif params.remaining_attempts > 0:
+            params = handle_both_wrong(params)
         else:
             params = handle_out_of_attempts(params)
 

src/shared.py

@@ -1,5 +1,8 @@
 from transformers import AutoTokenizer
 
+from src.constants import MAX_ATTEMPTS
+from src.constants import STARTING_INDEX
+from src.params import ReducerParams
 from src.predictions import make_predictions
 from src.text import get_text
 
@@ -7,3 +10,16 @@ tokenizer = AutoTokenizer.from_pretrained("gpt2")
 token_id_predictions, token_predictions = make_predictions(tokenizer)
 text = get_text()
 all_tokens = tokenizer.encode(text)
+
+INITIAL_STATE = ReducerParams(
+    prompt_text=tokenizer.decode(all_tokens[:STARTING_INDEX]),
+    player_points=0,
+    lm_points=0,
+    current_guesses="",
+    lm_guesses="",
+    remaining_attempts=MAX_ATTEMPTS,
+    guess_field="",
+    button_label="Guess!",
+    bottom_html="",
+    word_number=0,
+)

src/text.py

@@ -21,10 +21,19 @@
 # While this shell is said to be as hard as steel, a sudden, powerful impact could cause its liquid innards to pop out, leaving it completely exposed. Metapod generally remains motionless, rebuilding its cells for evolution.
 # If an enemy discovers Metapod, it is unable to do anything other than harden its outer shell. Metapod lives in temperate forests and jungles, often in groups. Pikipek is a natural predator of Metapod.
 # """
-target_text = """
-The Icelandic horse (Icelandic: íslenski hesturinn [ˈistlɛnscɪ ˈhɛstʏrɪn]) is a breed of horse developed in Iceland. Although the horses are small, at times pony-sized, most registries for the Icelandic refer to it as a horse. Icelandic horses are long-lived and hardy. In their native country they have few diseases; Icelandic law prevents horses from being imported into the country and exported animals are not allowed to return. The Icelandic displays two gaits in addition to the typical walk, trot, and canter/gallop commonly displayed by other breeds. The only breed of horse in Iceland, they are also popular internationally, and sizable populations exist in Europe and North America. The breed is still used for traditional sheepherding work in its native country, as well as for leisure, showing, and racing.
+# target_text = """
+# The Icelandic horse (Icelandic: íslenski hesturinn [ˈistlɛnscɪ ˈhɛstʏrɪn]) is a breed of horse developed in Iceland. Although the horses are small, at times pony-sized, most registries for the Icelandic refer to it as a horse. Icelandic horses are long-lived and hardy. In their native country they have few diseases; Icelandic law prevents horses from being imported into the country and exported animals are not allowed to return. The Icelandic displays two gaits in addition to the typical walk, trot, and canter/gallop commonly displayed by other breeds. The only breed of horse in Iceland, they are also popular internationally, and sizable populations exist in Europe and North America. The breed is still used for traditional sheepherding work in its native country, as well as for leisure, showing, and racing.
 
-Developed from ponies taken to Iceland by Norse settlers in the 9th and 10th centuries, the breed is mentioned in literature and historical records throughout Icelandic history; the first reference to a named horse appears in the 12th century. Horses were venerated in Norse mythology, a custom brought to Iceland by the country's earliest settlers. Selective breeding over the centuries has developed the breed into its current form. Natural selection has also played a role, as the harsh Icelandic climate eliminated many horses through exposure and malnourishment. In the 1780s, much of the breed was wiped out in the aftermath of a volcanic eruption at Laki. The first breed society for the Icelandic horse was created in Iceland in 1904, and today the breed is represented by organizations in 19 different nations, organized under a parent association, the International Federation of Icelandic Horse Associations.
+# Developed from ponies taken to Iceland by Norse settlers in the 9th and 10th centuries, the breed is mentioned in literature and historical records throughout Icelandic history; the first reference to a named horse appears in the 12th century. Horses were venerated in Norse mythology, a custom brought to Iceland by the country's earliest settlers. Selective breeding over the centuries has developed the breed into its current form. Natural selection has also played a role, as the harsh Icelandic climate eliminated many horses through exposure and malnourishment. In the 1780s, much of the breed was wiped out in the aftermath of a volcanic eruption at Laki. The first breed society for the Icelandic horse was created in Iceland in 1904, and today the breed is represented by organizations in 19 different nations, organized under a parent association, the International Federation of Icelandic Horse Associations.
+# """
+target_text = """
+The dominant sequence transduction models are based on complex recurrent or convolutional neural networks in an encoder-decoder configuration.
+The best performing models also connect the encoder and decoder through an attention mechanism.
+We propose a new simple network architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence and convolutions entirely.
+Experiments on two machine translation tasks show these models to be superior in quality while being more parallelizable and requiring significantly less time to train.
+Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task, improving over the existing best results, including ensembles by over 2 BLEU.
+On the WMT 2014 English-to-French translation task, our model establishes a new single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training costs of the best models from the literature.
+We show that the Transformer generalizes well to other tasks by applying it successfully to English constituency parsing both with large and limited training data.
 """