Add strans models and adaptations for conditions

.gitattributes

@@ -40,3 +40,6 @@ config/words.txt filter=lfs diff=lfs merge=lfs -text
 config/words.gz filter=lfs diff=lfs merge=lfs -text
 config/w2v_models/words.gz filter=lfs diff=lfs merge=lfs -text
 config/possible_words.json filter=lfs diff=lfs merge=lfs -text
+config/strans_models/. filter=lfs diff=lfs merge=lfs -text
+config/strans_models/esp_strans_model filter=lfs diff=lfs merge=lfs -text
+config/strans_models/esp_strans_model.vectors.npy filter=lfs diff=lfs merge=lfs -text

app.py

@@ -65,6 +65,17 @@ from game import Semantrix
 config_file_path = "config/lang.json"
 logo_path = "config/images/logo.png"
 logo_win_path = "config/images/logo_win.gif"
+condition_config_path = "config/condition.json"
+
+condition_name = "condition_1"
+
+lang = "Español"  # Default language
+
+with open(condition_config_path, "r") as file:
+    condition_config = json.load(file)
+
+model = condition_config[condition_name]["model"]
+hints_enabled = condition_config[condition_name]["hints"]
 
 # Loading the configuration file
 with open(config_file_path, "r") as file:
@@ -132,7 +143,7 @@ with gr.Blocks() as demo:
     hint = gr.State(False)  # State variable to track if the hint is provided
 
     # Initializing the game using the Semantrix class with default parameters
-    game = Semantrix(lang=0, model_type="SentenceTransformer")
+    game = Semantrix(lang=0, model_type=model)
 
     # Creating a Markdown component to display the header
     header = gr.Markdown(
@@ -144,30 +155,30 @@ with gr.Blocks() as demo:
     )
 
     # Function to reset the game
-    def reset(difficulty, lang, model):
-        global Config, game, Menu  # Declare global variables to modify them within the function
+    def reset(difficulty):
+        global Config, game, Menu, model, lang  # Declare global variables to modify them within the function
 
         # Determine the language based on the input parameter
-        language = 1 if lang == "English" else 0
-
-        # Initialize the game object based on the selected model
-        if model == "Word2Vec":
-            game = Semantrix(language, "word2vec")  # Use Word2Vec model
-        else:
-            game = Semantrix(
-                language, "SentenceTransformer"
-            )  # Use Sentence Transformers model
-
-        # Set the configuration and menu based on the selected language
-        if language == 1:
-            Config = Config_full["ENG"]["Game"]
-            Menu = Config_full["ENG"]["Menu"]
-        else:
-            Config = Config_full["SPA"]["Game"]
-            Menu = Config_full["SPA"]["Menu"]
+        # language = 2 if lang == "English" else 0
+
+        # # # Initialize the game object based on the selected model
+        # # if model == "Word2Vec":
+        # #     game = Semantrix(language, "word2vec")  # Use Word2Vec model
+        # # else:
+        # #     game = Semantrix(
+        # #         language, "SentenceTransformer"
+        # #     )  # Use Sentence Transformers model
+
+        # # Set the configuration and menu based on the selected language
+        # if language == 1:
+        #     Config = Config_full["ENG"]["Game"]
+        #     Menu = Config_full["ENG"]["Menu"]
+        # else:
+        #     Config = Config_full["SPA"]["Game"]
+        #     Menu = Config_full["SPA"]["Menu"]
 
         # Prepare the game with the selected difficulty level
-        game.prepare_game(difficulty)
+        # game.prepare_game(1 if hints_enabled else 4)
 
         # Define the initial output components for the UI
         output = [
@@ -201,10 +212,10 @@ with gr.Blocks() as demo:
 
     # Function to update the game state based on the current state of the game
     def update(state, radio, inp, hint):
-        global difficulty
+        global difficulty, hints_enabled
 
         # Define the difficulty state
-        dif_state = 4
+        dif_state = 3
 
         # Initialize the output component list with the current state
         output = [state]
@@ -234,7 +245,9 @@ with gr.Blocks() as demo:
             output.extend(
                 [
                     gr.Button(visible=False),
-                    gr.Radio([Menu["Yes"], Menu["No"]], label="", visible=True),
+                    gr.Radio(
+                        [Menu["Yes"], Menu["No"]], value=None, label="", visible=True
+                    ),
                     gr.Textbox(
                         Config[list(Config.keys())[state_int]], visible=True, label=""
                     ),
@@ -286,36 +299,6 @@ with gr.Blocks() as demo:
 
         # Define UI components for the difficulty state, ask the user to select the difficulty level
         elif state_int == dif_state:
-            output.extend(
-                [
-                    gr.Button(Menu["Next"], visible=False),
-                    gr.Radio(
-                        [Menu["Easy"], Menu["Normal"], Menu["Hard"], Menu["Expert"]],
-                        visible=True,
-                    ),
-                    gr.Textbox(
-                        Config[list(Config.keys())[state_int]], visible=True, label=""
-                    ),
-                    gr.Button(Menu["Give_up"], visible=False),
-                    gr.Textbox(visible=False),
-                    gr.Image(interactive=False, visible=False),
-                    gr.Textbox(visible=False),
-                    gr.Button(visible=False),
-                    gr.Markdown(visible=False),
-                ]
-            )
-
-        # Define UI components for the difficulty state + 1, prepare the game based on the selected difficulty level, and start the game
-        elif state_int == dif_state + 1:
-            if radio == Menu["Easy"]:
-                difficulty = 1
-            elif radio == Menu["Normal"]:
-                difficulty = 2
-            elif radio == Menu["Hard"]:
-                difficulty = 3
-            else:
-                difficulty = 4
-
             output.extend(
                 [
                     gr.Button(Menu["Start"], visible=True, variant="primary"),
@@ -333,9 +316,9 @@ with gr.Blocks() as demo:
             )
 
         # Define UI components for the difficulty state + 2, play the game based on the selected difficulty level and prepare the game for the word guessing
-        elif state_int == dif_state + 2:
+        elif state_int == dif_state + 1:
 
-            game.prepare_game(difficulty)
+            game.prepare_game(2 if hints_enabled else 4)
 
             output.extend(
                 [
@@ -357,7 +340,7 @@ with gr.Blocks() as demo:
             )
 
         # Define UI components for the state greater than the difficulty state + 2, play the game and provide feedback based on the user input
-        elif state_int > dif_state + 2:
+        elif state_int > dif_state + 1:
 
             # Send the user input to the game and get the feedback from the game
             feed = game.play_game(inp)
@@ -470,26 +453,6 @@ with gr.Blocks() as demo:
         give_up = gr.Button("Pista", visible=False)
         reload = gr.Button(Menu["Play_again"], visible=False)
 
-    # Define the settings components for the game
-    with gr.Accordion("Configuración/Settings", open=False):
-        with gr.Row():
-
-            # Dropdown to select the model engine for the game
-            model = (
-                gr.Dropdown(
-                    ["Sentence Transformers", "Word2Vec"],
-                    value="Sentence Transformers",
-                    label="Embedding Model",
-                ),
-            )
-
-            # Dropdown to select the language for the game
-            lang = (
-                gr.Dropdown(
-                    ["Español", "English"], value="Español", label="Idioma/Language"
-                ),
-            )
-
     # Define the UI events for the game
 
     # Define events that trigger the game state change
@@ -508,22 +471,12 @@ with gr.Blocks() as demo:
     # Define events that trigger the game reset
     reload.click(
         reset,
-        inputs=[difficulty, lang[0], model[0]],
+        inputs=[difficulty],
         outputs=[state, out, inp, img, but, radio, hint_out, reload, header],
     )
     demo.load(
         reset,
-        inputs=[difficulty, lang[0], model[0]],
-        outputs=[state, out, inp, img, but, radio, hint_out, reload, header],
-    )
-    lang[0].select(
-        reset,
-        inputs=[difficulty, lang[0], model[0]],
-        outputs=[state, out, inp, img, but, radio, hint_out, reload, header],
-    )
-    model[0].select(
-        reset,
-        inputs=[difficulty, lang[0], model[0]],
+        inputs=[difficulty],
         outputs=[state, out, inp, img, but, radio, hint_out, reload, header],
     )
 

config/condition.json

@@ -0,0 +1,19 @@
+{
+    "condition_0" : {
+        "model" : "SentenceTransformer",
+        "hints" : true
+        },
+    "condition_1" : {
+        "model" : "SentenceTransformer",
+        "hints" : false
+        },
+    "condition_2" : {
+        "model" : "word2vec",
+        "hints" : true
+        },
+    "condition_3" : {
+        "model" : "word2vec",
+        "hints" : false
+        }
+    }
+    

config/lang.json

@@ -3,10 +3,8 @@
         "Game": {
             "Introduction_0": "Bienvenido a Semantrix, el emocionante Juego de la adivinanza semántica. \n\nTu misión es adivinar una palabra secreta que yo he escogido, pero no te preocupes, te ayudaré en el camino. \n\nLanza al aire la primera palabra que se te ocurra. Te daré pistas diciéndote si estás caliente, es decir muy cerca de adivinarla o frío, es decir, muy lejos de la palabra.",
             "Introduction_1": "¿Quieres saber cómo se juega?",
-            "Rules": "Cada palabra que propongas recibirá una puntuación semántica entre 0 y 10, un puntaje alto significa que estás muy cerca de adivinar la palabra secreta\n\nSi veo que estás un poco perdido, estaré aquí para darte pistas que te ayudarán a acercarte a la palabra secreta.\n\nComo ayuda extra, mostraré un ranking de todas las palabras que has propuesto, ordenadas según su puntuación. Así podrás tener una idea mejor de qué tan cerca están y qué palabras funcionan mejor.\n\nSerás el ganador cuando adivines correctamente la palabra secreta. ¡No desistas, lo tienes al alcance!",
-            "Difficulty_presentation_Full": "En este emocionante desafío de adivinanza semántica, puedes elegir cuán grande quieres que sea el reto. Aquí te presento los niveles de dificultad:\n\n- Fácil: Pistas evidentes para una rápida adivinanza. Ideal para principiantes.\n\n- Normal: Pistas solo cuando estés muy perdido. Un reto intermedio.\n\n- Difícil: Ayuda mínima y palabras complejas. Para pensadores agudos.\n\n- Experto: Sin pistas y palabras difíciles. Para campeones de la semántica.\n\nRecuerda, ganes o pierdas, cada nivel está diseñado para hacerte disfrutar y mejorar tus habilidades de adivinanza y comprensión de las palabras. ¡Escoge tu nivel y empieza a jugar!",
-            "Difficulty": "Elige tu nivel de dificultad",
-            "Begin": "¡Enciende tu mente, confía en tus ideas y por sobre todo, pasa un buen rato! Este es un juego en el que cada palabra, cada puntuación y cada pista te acerca a tu victoria. ¡Mucha suerte!",
+            "Rules": "Cada palabra que propongas recibirá una puntuación semántica entre 0 y 10, un puntaje alto significa que estás muy cerca de adivinar la palabra secreta\n\nSi veo que estás un poco perdido, estaré aquí para darte pistas que te ayudarán a acercarte a la palabra secreta.\n\nComo ayuda extra, mostraré un ranking de todas las palabras que has propuesto, ordenadas según su puntuación. Así podrás tener una idea mejor de qué tan cerca están y qué palabras funcionan mejor.\n\nGanarás cuando adivines correctamente la palabra secreta. ¡No desistas, lo tienes al alcance!",
+            "Begin": "¡Enciende tu mente, confía en tus ideas y sobre todo, pasa un buen rato! Este es un juego en el que cada palabra, cada puntuación y cada pista te acerca a tu victoria. ¡Mucha suerte!",
             "New_word": "Nueva palabra: ",
             "Feedback_0": "Helado, puntuación: ",
             "Feedback_1": "Frío, puntuación: ",
@@ -82,8 +80,6 @@
             "Introduction_0": "Welcome to Semantrix, the exciting semantic guessing game.\n\nYour mission is to guess a secret word I've chosen, but don't worry, I'll help you along the way.\n\nThrow out the first word that comes to your mind. I'll give you clues by telling you if you're hot, meaning very close to guessing it, or cold, meaning far from the word.",
             "Introduction_1": "Do you want to know how to play?",
             "Rules": "Each word you propose will receive a semantic score between 0 and 10. A high score means you're very close to guessing the secret word.\n\nIf I see you're a bit lost, I'll be here to give you hints to help you get closer to the secret word.\n\nAs extra help, I'll show a ranking of all the words you've suggested, ordered by their score. This way, you can have a better idea of how close they are and which words work best.\n\nYou'll be the winner when you correctly guess the secret word. Don't give up, it's within your reach!",
-            "Difficulty_presentation_Full": "In this exciting semantic guessing challenge, you can choose how big you want the challenge to be. Here are the difficulty levels:\n\n- Easy: Obvious clues for quick guessing. Ideal for beginners.\n\n- Normal: Clues only when you're very lost. An intermediate challenge.\n\n- Hard: Minimal help and complex words. For sharp thinkers.\n\n- Expert: No clues and difficult words. For semantic champions.\n\nRemember, whether you win or lose, each level is designed to make you enjoy and improve your guessing and word comprehension skills. Choose your level and start playing!",
-            "Difficulty": "Choose your difficulty level",
             "Begin": "Turn on your mind, trust your ideas, and above all, have a good time! This is a game where each word, each score, and each clue brings you closer to your victory. Good luck!",
             "New_word": "New word: ",
             "Feedback_0": "Ice-cold, score: ",

config/secret.json

@@ -1,8 +1,6 @@
 {
     "ENG": {
         "basic": [
-            "joy",
-            "cricket",
             "ant",
             "tree",
             "glass",
@@ -522,12 +520,7 @@
     },
     "SPA": {
         "basic": [
-            "alegría",
-            "cricket",
-            "hormiga",
             "árbol",
-            "vaso",
-            "montañas",
             "vestido",
             "lluvia",
             "jabón",
@@ -549,7 +542,7 @@
             "planeta",
             "fiesta",
             "hijo",
-            "teléfono celular",
+            "teléfono",
             "visita",
             "pestaña",
             "elegancia",

config/{w2v_models/esp_w2v_model → strans_models/esp_strans_model}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f2c899f437b124b4bd75d84999255558bac434f518f6f18d355926873cf1e51c
-size 37219500
+oid sha256:b563a5788817d9cc01a0e2e0f626a6ea0814f9f6ad43a96bee396c91fc705d89
+size 29214117

config/{w2v_models/eng_w2v_model → strans_models/esp_strans_model.vectors.npy}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:03600c8abbd931c8246824fa899127771b831cd79ce044c4dc3b1768ab78ee57
-size 128150500
+oid sha256:4e585fc39a5a629ca8d4b8fe9bdbc2885b1357c934c39648b7e9bb7b52a2711f
+size 3074006144

config/w2v_models/eng_w2v_model.vectors.npy

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:61ddfe7841ca1c326e3b023e8f96a807dbd61f0bb3d711a99cd7c8920dc87d24
-size 3600000128

config/w2v_models/esp_w2v_model.vectors.npy

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e36596ce82587daf0dc04174e86c73148657782e7e2b507745a9056eab3cab5e
-size 1200783728

game.py

@@ -39,6 +39,7 @@
 import json
 import random
 from datetime import datetime
+from tqdm import tqdm
 import numpy as np
 from gensim.models import KeyedVectors
 from hints import curiosity, hint
@@ -83,18 +84,29 @@ class Semantrix:
         self.model_type = model_type
 
         if self.lang == 1:
-            self.model = KeyedVectors.load("config/w2v_models/eng_w2v_model", mmap="r")
+            if self.model_type == "word2vec":
+                self.model = KeyedVectors.load(
+                    "config/w2v_models/eng_w2v_model", mmap="r"
+                )
+            elif self.model_type == "SentenceTransformer":
+                self.model = KeyedVectors.load(
+                    "config/strans_models/eng_strans_model", mmap="r"
+                )
             self.Config = self.DictWrapper(self.Config_full["ENG"]["Game"])
             self.secret_dict = self.secret["ENG"]
         else:
-            self.model = KeyedVectors.load("config/w2v_models/esp_w2v_model", mmap="r")
+            if self.model_type == "word2vec":
+                self.model = KeyedVectors.load(
+                    "config/w2v_models/esp_w2v_model", mmap="r"
+                )
+            elif self.model_type == "SentenceTransformer":
+                self.model = KeyedVectors.load(
+                    "config/strans_models/esp_strans_model", mmap="r"
+                )
+
             self.Config = self.DictWrapper(self.Config_full["SPA"]["Game"])
             self.secret_dict = self.secret["SPA"]
 
-        # Create empty KeyedVectors model with predefined size where the embeddings will be stored if Sentence Transformer used
-        if self.model_type == "SentenceTransformer":
-            self.model_trans = KeyedVectors(768)
-
         self.model_st = SentenceTransformer(
             "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
         )
@@ -107,15 +119,18 @@ class Semantrix:
     def prepare_game(self, difficulty):
 
         # Set the secret list depending on the difficulty
-        self.secret_list = (
-            self.secret_dict["basic"]
-            if difficulty <= 2
-            else self.secret_dict["advanced"]
-        )
+        # self.secret_list = (
+        #     self.secret_dict["basic"]
+        #     if difficulty <= 2
+        #     else self.secret_dict["advanced"]
+        # )
+        self.secret_list = self.secret_dict["basic"]
 
         # Select a random secret word from the secret list
-        self.secret = self.secret_list.pop(random.randint(0, len(self.secret_list) - 1))
+        # self.secret = self.secret_list.pop(random.randint(0, len(self.secret_list) - 1))
+        self.secret = self.secret_list.pop(0)
         self.secret = self.secret.lower()
+        print(self.secret)
 
         # Store the secret word in the words list
         self.words = [self.Config.secret_word]
@@ -123,16 +138,6 @@ class Semantrix:
         # Store the score in the scores list
         self.scores = [10]
 
-        # Store the embedding of the secret word in the embeddings dictionary
-        if self.model_type == "SentenceTransformer":
-            # Add the secret word to the KeyedVectors model if the model type is SentenceTransformer
-            # If the model type is word2vec, the secret word is already in the model
-            if self.secret not in self.model_trans.key_to_index.keys():
-                self.model_trans.add_vector(
-                    self.secret,
-                    self.model_st.encode(self.secret, convert_to_tensor=True).tolist(),
-                )
-
         # Initialize the game variables
         self.win = False
         self.n = 0
@@ -206,20 +211,7 @@ class Semantrix:
             )
             return feedback
 
-        # Add the word to the KeyedVectors model if the model type is SentenceTransformer and the word is not already in the model
-        if (
-            self.model_type == "SentenceTransformer"
-            and word not in self.model_trans.key_to_index.keys()
-        ):
-            self.model_trans.add_vector(
-                word, self.model_st.encode(word, convert_to_tensor=True).tolist()
-            )
-
-        # Calculate the score of the word, apply logarithmic scaling, interpolate the score to a range from 0 to 10, and round it to two decimal places
-        if self.model_type == "word2vec":
-            similarity = self.model.similarity(self.secret, word)
-        else:
-            similarity = self.model_trans.similarity(self.secret, word)
+        similarity = self.model.similarity(self.secret, word)
 
         log_similarity = np.log10(similarity * 10) if similarity > 0 else 0
         score = round(