Clone old repo

.gitattributes

@@ -33,3 +33,14 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+# *.gif filter=lfs diff=lfs merge=lfs -text
+config/w2v_models/esp_w2v_model filter=lfs diff=lfs merge=lfs -text
+config/w2v_models/eng_w2v_model filter=lfs diff=lfs merge=lfs -text
+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
+config/images/logo_win.gif filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+data/plays/*.txt
+data/plays/*.json
+data/plays/data/*.json
+__pycache__/*
+data/rankings/*.txt
+config/*_models

README.md

@@ -1,12 +1,114 @@
 ---
-title: Semantrix Cond3 Temp
-emoji: 📊
-colorFrom: red
-colorTo: green
+title: Semantrix
+emoji: 🔠
+colorFrom: indigo
+colorTo: pink
 sdk: gradio
 sdk_version: 5.22.0
+python_version: 3.11.5
 app_file: app.py
 pinned: false
+license: other
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Semantrix Game
+
+This repository contains the implementation of the Semantrix game, a word guessing game using word embeddings. The game supports multiple languages (Spanish and English) and can be configured to use either a Word2Vec model or a SentenceTransformer model for word embeddings.
+
+## Modules
+
+
+
+### app.py
+
+This module defines a Gradio-based web application for the Semantrix game. The application allows users to play the game in either Spanish or English, using different embedding models for word similarity.
+
+#### Functions
+
+- `convert_to_markdown_centered(text)`: Converts text to a centered markdown format for displaying game history and last attempt.
+    - **Parameters**:
+        - `text (str)`: The text to be converted.
+    - **Returns**: `str`: The centered markdown formatted text.
+
+- `reset(difficulty, lang, model)`: Resets the game state based on the selected difficulty, language, and model.
+    - **Parameters**:
+        - `difficulty`: The selected difficulty level.
+        - `lang`: The selected language.
+        - `model`: The selected embedding model.
+    - **Returns**: `list`: A list of initial output components for the UI.
+
+- `change(state, inp)`: Changes the game state by incrementing the state variable.
+    - **Parameters**:
+        - `state`: The current game state.
+        - `inp`: The user input.
+    - **Returns**: `list`: A list containing the updated state and input component.
+
+- `update(state, radio, inp, hint)`: Updates the game state and UI components based on the current state and user inputs.
+    - **Parameters**:
+        - `state`: The current game state.
+        - `radio`: The radio input component.
+        - `inp`: The user input.
+        - `hint`: The hint state.
+    - **Returns**: `list`: A list of updated output components for the UI.
+
+### game.py
+
+This module defines the Semantrix class, which implements a word guessing game using word embeddings. The game can be configured to use either a Word2Vec model or a SentenceTransformer model for word embeddings. The game supports multiple languages and difficulty levels.
+
+#### Classes
+
+- `Semantrix`: A class that implements the Semantrix word guessing game.
+    - **Methods**:
+        - `__init__(self, lang=0, model_type="SentenceTransformer")`: Initializes the Semantrix game with the specified language and model type.
+        - `prepare_game(self, difficulty)`: Prepares the game with the selected difficulty level.
+        - `gen_rank(self, repeated)`: Generates the ranking file based on the scores.
+        - `play_game(self, word)`: Plays the game with the selected word and returns feedback.
+        - `curiosity(self)`: Generates a curiosity hint about the secret word once the game is over.
+
+### hints.py
+
+This module provides functions to generate dynamic hints and curiosities about a secret word using language models (LLMs).
+
+#### Functions
+
+- `hint(secret, n, model, last_hint, lang, Config)`: Generates a dynamic hint based on the secret word and the number of hints given.
+    - **Parameters**:
+        - `secret (str)`: The secret word.
+        - `n (int)`: The number of hints already given.
+        - `model`: The sentence transformer model used for encoding.
+        - `last_hint (int)`: The index of the last hint given.
+        - `lang (int)`: The language code (0 for Spanish, 1 for English).
+        - `Config`: Configuration object containing hint templates.
+    - **Returns**: `tuple`: A tuple containing the generated hint (str), the updated number of hints (int), and the index of the last hint given (int).
+
+- `curiosity(secret, Config)`: Generates a curiosity about the secret word.
+    - **Parameters**:
+        - `secret (str)`: The secret word.
+        - `Config`: Configuration object containing the curiosity template.
+    - **Returns**: `str`: The generated curiosity.
+
+- `ireplace(old, new, text)`: Replaces all occurrences of a substring in a string, case-insensitively.
+    - **Parameters**:
+        - `old (str)`: The substring to be replaced.
+        - `new (str)`: The substring to replace with.
+        - `text (str)`: The original string.
+    - **Returns**: `str`: The modified string with all occurrences of the old substring replaced by the new substring.
+
+    
+## How to Run
+
+1. Clone the repository.
+2. Install the required dependencies.
+3. Run the `app.py` script to launch the Gradio web application.
+
+## Dependencies
+
+- Gradio
+- OpenAI
+- SentenceTransformers
+- Gensim
+- NumPy
+
+## License
+
+This project is licensed under the MIT License.

app.py

@@ -0,0 +1,641 @@
+# """
+# This module defines a Gradio-based web application for the Semantrix game. The application allows users to play the game in either Spanish or English, using different embedding models for word similarity.
+
+# Modules:
+#     gradio: Used for creating the web interface.
+#     json: Used for loading configuration files.
+#     game: Contains the Semantrix class for game logic.
+
+# File Paths:
+#     config_file_path: Path to the configuration file.
+#     logo_path: Path to the logo image.
+#     logo_win_path: Path to the winning logo image.
+
+# Functions:
+#     convert_to_markdown_centered(text):
+#         Converts text to a centered markdown format for displaying game history and last attempt.
+
+#     reset(difficulty, lang, model):
+#         Resets the game state based on the selected difficulty, language, and model.
+
+#     change(state, inp):
+#         Changes the game state by incrementing the state variable.
+
+#     update(state, radio, inp, hint):
+#         Updates the game state and UI components based on the current state and user inputs.
+
+# Gradio Components:
+#     demo: The main Gradio Blocks component that contains the entire UI layout.
+#     header: A Markdown component for displaying the game header.
+#     state: A State component for tracking the current game state.
+#     difficulty: A State component for tracking the difficulty level.
+#     hint: A State component for tracking if a hint is provided.
+#     img: An Image component for displaying the game logo.
+#     ranking: A Markdown component for displaying the ranking.
+#     out: A Textbox component for displaying game messages.
+#     hint_out: A Textbox component for displaying hints.
+#     radio: A Radio component for user selections.
+#     inp: A Textbox component for user input.
+#     but: A Button component for several actions.
+#     give_up: A Button component for giving up.
+#     reload: A Button component for reloading the game.
+#     model: A Dropdown component for selecting the embedding model.
+#     lang: A Dropdown component for selecting the language.
+
+# Events:
+#     inp.submit: Triggers the change function on input submission.
+#     but.click: Triggers the change function on button click.
+#     give_up.click: Triggers the change function on give up button click.
+#     radio.input: Triggers the change function on radio input.
+#     reload.click: Triggers the reset function on reload button click.
+#     demo.load: Triggers the reset function on demo load.
+#     lang[0].select: Triggers the reset function on language selection.
+#     model[0].select: Triggers the reset function on model selection.
+#     state.change: Triggers the update function on state change.
+
+# Main:
+#     Launches the Gradio application if the script is run as the main module.
+# """
+
+import gradio as gr
+import json
+from datetime import datetime, date
+from game import Semantrix, Model_class
+from huggingface_hub import CommitScheduler
+import os
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+# File paths for configuration and images
+base_path = os.path.dirname(os.path.abspath(__file__))
+config_file_path = os.path.join(base_path, "config/lang.json")
+logo_path = os.path.join(base_path, "config/images/logo.png")
+logo_win_path = os.path.join(base_path, "config/images/logo_win.gif")
+condition_config_path = os.path.join(base_path, "config/condition.json")
+data_path = os.path.join(base_path, "data")
+plays_path = os.path.join(data_path, "plays")
+
+condition_name = "condition_3"
+# Dynamically determine the condition name based on the folder name
+# folder_name = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
+# condition = folder_name.split("_")[-1][-1]
+# condition_name = "condition_" + condition
+
+
+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:
+    Config_full = json.load(file)
+
+scheduler = CommitScheduler(
+    repo_id="Jsevisal/semantrix_data_" + condition_name[-1],
+    repo_type="dataset",
+    folder_path=plays_path,
+    path_in_repo="data",
+    every=10,
+)
+
+lang = 0  # Language configuration flag (0 for Spanish, 1 for English)
+
+# Setting the configuration based on the language flag
+if lang == 1:
+    Config = Config_full["ENG"]["Game"]
+    Menu = Config_full["ENG"]["Menu"]
+else:
+    Config = Config_full["SPA"]["Game"]
+    Menu = Config_full["SPA"]["Menu"]
+
+
+# Function to convert text to centered markdown format
+def convert_to_markdown_centered(text):
+    lines = text.strip().split("\n")
+
+    if not lines:
+        return ""
+
+    last_attempt = lines[0]
+    history_attempts = lines[2:12]
+    markdown = '<div align="center">\n\n'
+
+    markdown += "## " + Menu["Best_tries"] + "\n"
+    markdown += "<table>\n"
+    markdown += "  <tr>\n"
+    markdown += "    <th>" + Menu["N_try"] + "</th>\n"
+    markdown += "    <th>" + Menu["Word"] + "</th>\n"
+    markdown += "    <th>" + Menu["Score"] + "</th>\n"
+    markdown += "  </tr>\n"
+
+    for line in history_attempts:
+        items = eval(line.strip())
+        markdown += "  <tr>\n"
+        markdown += f"    <td><strong>{items[0]}</strong></td>\n"
+        markdown += f"    <td>{items[1]}</td>\n"
+        markdown += f"    <td>{items[2]}</td>\n"
+        markdown += "  </tr>\n"
+
+    markdown += "</table>\n\n"
+
+    last_items = eval(last_attempt)
+    markdown += f"## " + Menu["Last_try"] + "\n"
+    markdown += (
+        f"**{last_items[0]}:** {last_items[1]} - "
+        + Menu["Score"]
+        + f": {last_items[2]}\n\n"
+    )
+    markdown += "---\n\n"
+
+    markdown += "</div>"
+
+    return markdown
+
+
+#
+with gr.Blocks(
+    theme="ocean",
+) as demo:
+    # Initializing state variables to manage the internal state of the application
+    state = gr.State(-1)  # State variable to track the current game state
+    difficulty = gr.State(-1)  # State variable to track the difficulty level
+    hint = gr.State(False)  # State variable to track if the hint is provided
+
+    secret_word_used = gr.BrowserState(
+        0
+    )  # State variable to track the number of secret words used
+
+    # Initializing the game using the Semantrix class with default parameters
+    game_instances = {}
+    sessions_to_remove = {}
+    cooldown_time = 120  # Time in seconds to remove the session from the game_instances
+    model_class = Model_class(lang=0, model_type=model)
+
+    # Creating a Markdown component to display the header
+    header = gr.Markdown(
+        """
+    <p style="text-align:center"> """
+        + Menu["Header"]
+        + """ </p>
+    """
+    )
+
+    # Function to reset the game
+    def reset(reload, request: gr.Request):
+        global Config, game, Menu, model, lang  # Declare global variables to modify them within the function
+
+        if reload:
+            game_instances[request.session_hash] = Semantrix(
+                lang=0, model_type=model, session_hash=request.session_hash
+            )
+            game_instances[request.session_hash].reset_game()  # Reset the game state
+
+            logger.info("New session detected: %s", request.session_hash)
+            logger.info("Game instances: %s", game_instances)
+
+        # Define the initial output components for the UI
+        output = [
+            -1,
+            gr.Textbox(visible=False),
+            gr.Textbox(visible=False),
+            gr.Image(logo_path, visible=True, interactive=False),
+            gr.Button(Menu["Start"], visible=True, variant="secondary"),
+            gr.Radio(visible=False),
+            gr.Textbox(visible=False),
+            gr.Button(visible=False),
+            gr.Markdown(
+                """
+                    <p style="text-align:center"> """
+                + Menu["Header"]
+                + """ </p>
+                    """
+            ),
+            gr.Button(visible=False),
+        ]
+
+        # Return the initial output components
+        return output
+
+    def remove_game_instance(timer_tick=False, request: gr.Request | None = None):
+        request = None if timer_tick else request
+
+        if request is not None:
+            logger.info("Session on inactivity timer: %s", request.session_hash)
+            sessions_to_remove[request.session_hash] = datetime.now()
+        if len(sessions_to_remove.items()) > 0:
+            for session_hash, timestamp in list(sessions_to_remove.items()):
+                if (datetime.now() - timestamp).seconds > cooldown_time:
+                    del sessions_to_remove[session_hash]
+
+                    session_id = game_instances[session_hash].get_session_id()
+                    del game_instances[session_hash]
+
+                    # Delete ranking file if it exists
+                    ranking_file = os.path.join(
+                        data_path, f"rankings/ranking_{session_hash}.txt"
+                    )
+                    if os.path.exists(ranking_file):
+                        os.remove(ranking_file)
+
+                    # Delete plays files if it exists
+                    session_files = [
+                        f for f in os.listdir(plays_path) if f.startswith(session_id)
+                    ]
+                    for file_name in session_files:
+                        with open(os.path.join(plays_path, file_name), "r") as file:
+                            os.remove(os.path.join(plays_path, file_name))
+
+                    logger.info("Deleted session: %s", session_hash)
+
+    # Function to change the state of the game
+    def change(state, inp):
+        # Increment the state by 1
+        state = state + 1
+
+        # Return the updated state and input component
+        return [state, inp]
+
+    # Function to update the game state based on the current state of the game
+    def update(state, radio, inp, hint, secret_word_used, request: gr.Request):
+        global difficulty, hints_enabled
+
+        # Define the difficulty state
+        dif_state = 3
+
+        # Initialize the output component list with the current state
+
+        state_int = state
+
+        output = [state]
+
+        if request.session_hash in sessions_to_remove:
+            sessions_to_remove.pop(request.session_hash)
+            logger.info("Session saved: %s", request.session_hash)
+
+        # Define UI components for the initial state
+        if state_int == -1:
+            output.extend(
+                [
+                    gr.Button(Menu["Start"], visible=True),
+                    gr.Radio(label="", visible=False),
+                    gr.Textbox(
+                        Config[list(Config.keys())[state_int]], visible=False, label=""
+                    ),
+                    gr.Button(Menu["Give_up"], visible=False),
+                    gr.Textbox(visible=False),
+                    gr.Image(interactive=False, visible=True),
+                    gr.Textbox(visible=False),
+                    gr.Button(visible=False),
+                    gr.Markdown(visible=False),
+                    gr.Button(visible=False),
+                    secret_word_used,
+                ]
+            )
+
+        # Define UI components for the first state, ask the user if they want to know the rules
+        elif state_int == 1:
+            output.extend(
+                [
+                    gr.Button(visible=False),
+                    gr.Radio(
+                        [Menu["Yes"], Menu["No"]], value=None, label="", 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),
+                    gr.Button(visible=False),
+                    secret_word_used,
+                ]
+            )
+
+        # Define UI components for the second state, Depending on the answer, show the rules or keep going
+        elif state_int == 2:
+            if radio == Menu["No"]:
+                output = [
+                    dif_state,
+                    gr.Button("Introducir", visible=True),
+                    gr.Radio(visible=False),
+                    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),
+                    gr.Button(visible=False),
+                    secret_word_used,
+                ]
+
+            else:
+                output.extend(
+                    [
+                        gr.Button(Menu["Next"], visible=True),
+                        gr.Radio(visible=False),
+                        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),
+                        gr.Button(visible=False),
+                        secret_word_used,
+                    ]
+                )
+
+        # 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["Start"], visible=True, variant="primary"),
+                    gr.Radio(visible=False),
+                    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),
+                    gr.Button(visible=False),
+                    secret_word_used,
+                ]
+            )
+
+        # 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 + 1:
+
+            game_instances[request.session_hash].prepare_game(
+                secret_word_used, 2 if hints_enabled else 4
+            )
+
+            output.extend(
+                [
+                    gr.Button(Menu["Send"], visible=True, variant="primary"),
+                    gr.Radio(label="", visible=False),
+                    gr.Textbox(visible=False, label=""),
+                    gr.Button(visible=False, variant="stop"),
+                    gr.Textbox(
+                        value="",
+                        visible=True,
+                        autofocus=True,
+                        placeholder=Menu["New_word"],
+                    ),
+                    gr.Image(interactive=False, visible=False),
+                    gr.Textbox(visible=False),
+                    gr.Button(visible=False),
+                    gr.Markdown(visible=False),
+                    gr.Button(visible=False),
+                    secret_word_used + 1,
+                ]
+            )
+
+        # 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 + 1:
+
+            # Send the user input to the game and get the feedback from the game
+            feed = game_instances[request.session_hash].play_game(inp, model_class)
+
+            # Check if the feedback contains the ranking information and process it
+            feedback_trim = feed.split("[rank]")
+            if len(feedback_trim) > 1:
+                ranking_vis = True
+                ranking_md = convert_to_markdown_centered(feedback_trim[1])
+
+            else:
+                ranking_vis = False
+                ranking_md = ""
+
+            # Check if the feedback contains a hint, win, or lose message
+            feedback = feedback_trim[0].split("[hint]")
+            win = feedback_trim[0].split("[win]")
+            lose = feedback_trim[0].split("[lose]")
+
+            # Check if the feedback contains a hint message
+            if len(feedback) > 1:
+                hint = True
+                hint_out = feedback[1]
+                feedback = feedback[0]
+            else:
+                hint = False
+                feedback = feedback[0]
+
+            # Check if the feedback contains a win or lose message and process it
+            if len(win) > 1 or len(lose) > 1:
+
+                # Check if the user won the game
+                won = True if len(win) > 1 else False
+
+                # Get the curiosity message from the game
+                curiosity = game_instances[request.session_hash].curiosity()
+
+                # Define the output components for the win or lose state
+                output.extend(
+                    [
+                        gr.Button(Menu["Send"], visible=False, variant="primary"),
+                        gr.Radio(label="", visible=False),
+                        gr.Textbox(win[1] if won else lose[1], visible=True, label=""),
+                        gr.Button(visible=False, variant="stop"),
+                        gr.Textbox(
+                            value="", visible=False, placeholder=Menu["New_word"]
+                        ),
+                        gr.Image(
+                            logo_win_path if won else logo_path,
+                            interactive=False,
+                            visible=True,
+                        ),
+                        gr.Textbox(curiosity, visible=True, label=Menu["Curiosity"]),
+                        gr.Button(Menu["Play_again"], variant="primary", visible=True),
+                        gr.Markdown(visible=False),
+                        gr.Button(visible=True),
+                        secret_word_used,
+                    ]
+                )
+
+                return output
+
+            # Define the output components for the feedback and keep playing
+            output.extend(
+                [
+                    gr.Button(Menu["Send"], visible=True, variant="primary"),
+                    gr.Radio(label="", visible=False),
+                    gr.Textbox(feedback, visible=True, label=""),
+                    gr.Button(visible=True, variant="stop"),
+                    gr.Textbox(value="", visible=True, placeholder=Menu["New_word"]),
+                    gr.Image(logo_path, interactive=False, visible=False),
+                    gr.Textbox(hint_out if hint else "", visible=hint, label="Pista"),
+                    gr.Button(visible=False),
+                    gr.Markdown(ranking_md, visible=ranking_vis),
+                    gr.Button(visible=False),
+                    secret_word_used,
+                ]
+            )
+
+        # Define UI components for the rest of the states, state for showing basic text to the user
+        else:
+            output.extend(
+                [
+                    gr.Button(Menu["Next"], visible=True),
+                    gr.Radio(label="", visible=False),
+                    gr.Textbox(
+                        Config[list(Config.keys())[state_int]], visible=True, label=""
+                    ),
+                    gr.Button("Pista", visible=False),
+                    gr.Textbox(visible=False),
+                    gr.Image(interactive=False, visible=False),
+                    gr.Textbox(visible=False),
+                    gr.Button(visible=False),
+                    gr.Markdown(visible=False),
+                    gr.Button(visible=False),
+                    secret_word_used,
+                ]
+            )
+
+        # Return the output components
+        return output
+
+    def commit_data(request: gr.Request):
+        session_id = game_instances[request.session_hash].get_session_id()
+        session_files = [f for f in os.listdir(plays_path) if f.startswith(session_id)]
+        combined_data = []
+
+        for file_name in session_files:
+            with open(os.path.join(plays_path, file_name), "r") as file:
+                combined_data.append(json.load(file))
+                os.remove(os.path.join(plays_path, file_name))
+
+        combined_file_path = os.path.join(plays_path, f"{session_id}.json")
+        with open(combined_file_path, "w") as combined_file:
+            json.dump(combined_data, combined_file, indent=4)
+
+        scheduler.push_to_hub()
+
+        if os.path.exists(combined_file_path):
+            os.remove(combined_file_path)
+
+        return [
+            gr.Button(visible=False),
+            gr.Textbox(visible=False),
+            gr.Textbox(visible=False),
+            gr.Button(
+                "Rellenar cuestionario",
+                variant="primary",
+                link="https://docs.google.com/forms/d/e/1FAIpQLScqPES3cM6i7yS87_PZtD0T7Q0W-YynKBY_m-Frja3BL5t9Tw/viewform?usp=pp_url&entry.1903327713="
+                + session_id,
+                visible=True,
+            ),
+        ]
+
+    # Define the UI layout for the gam
+    img = gr.Image(logo_path, height=430, interactive=False, visible=True)
+    ranking = gr.Markdown(visible=False)
+
+    with gr.Row():
+        out = gr.Textbox(visible=False, placeholder=Config[list(Config.keys())[0]])
+        hint_out = gr.Textbox(visible=False)
+
+    radio = gr.Radio(visible=False)
+
+    with gr.Row():
+        inp = gr.Textbox(visible=False, interactive=True, label="")
+        but = gr.Button(Menu["Start"])
+        give_up = gr.Button("Pista", visible=False)
+        reload = gr.Button(Menu["Play_again"], visible=False)
+    finish = gr.Button(
+        "Terminar",
+        variant="stop",
+        # link="https://docs.google.com/forms/d/e/1FAIpQLSd0z8nI4hhOSR83yPIw_bR3KkSt25Lsq0ZXG1pZnkldeoceqA/viewform?usp=pp_url&entry.327829192=Condici%C3%B3n+1",
+        visible=False,
+    )
+
+    timer_delete = gr.Timer(value=30)
+
+    # Define the UI events for the game
+
+    # Define events that trigger the game state change
+    timer_delete.tick(remove_game_instance, inputs=[gr.State(True)])
+    inp.submit(
+        change,
+        inputs=[state, inp],
+        outputs=[state, inp],
+        concurrency_limit=5,
+    )
+    but.click(
+        change,
+        inputs=[state, inp],
+        outputs=[state, inp],
+        concurrency_limit=5,
+    )
+    give_up.click(
+        change,
+        inputs=[
+            state,
+            gr.Textbox("give_up", visible=False, interactive=True, label=""),
+        ],
+        outputs=[state, inp],
+        concurrency_limit=5,
+    )
+    radio.input(
+        change,
+        inputs=[state, inp],
+        outputs=[state, inp],
+        concurrency_limit=5,
+    )
+    finish.click(
+        commit_data, outputs=[reload, out, hint_out, finish]
+    )  # Define events that trigger the game reset
+    reload.click(
+        reset,
+        inputs=[gr.State(False)],
+        outputs=[state, out, inp, img, but, radio, hint_out, reload, header, finish],
+    )
+    demo.load(
+        reset,
+        inputs=[gr.State(True)],
+        outputs=[state, out, inp, img, but, radio, hint_out, reload, header, finish],
+    )
+    demo.unload(remove_game_instance)
+
+    # Define events that trigger the game state update
+    state.change(
+        update,
+        inputs=[state, radio, inp, hint, secret_word_used],
+        outputs=[
+            state,
+            but,
+            radio,
+            out,
+            give_up,
+            inp,
+            img,
+            hint_out,
+            reload,
+            ranking,
+            finish,
+            secret_word_used,
+        ],
+    )
+
+if __name__ == "__main__":
+    demo.launch(debug=True)

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

@@ -0,0 +1,153 @@
+{
+    "SPA": {
+        "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\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: ",
+            "Feedback_2": "Templado, puntuación: ",
+            "Feedback_3": "Caliente, puntuación: ",
+            "Feedback_4": "Quemando, puntuación: ",
+            "Feedback_5": "Ardiendo, puntuación: ",
+            "Feedback_6": "Te estás acercando",
+            "Feedback_7": "Te estás alejando",
+            "Feedback_8": "¡Has ganado, ENHORABUENA!",
+            "Feedback_9": "La palabra secreta era: ",
+            "Feedback_10": "Aunque no fue una victoria esta vez, ¡no temas! ¡Cada intento es una nueva oportunidad para brillar! ¡Sigue adelante!",
+            "secret_word": "PALABRA SECRETA",
+            "hint_intro": [
+                "Parece que las palabras están jugando al escondite contigo. ¿Necesitas una ayudita? Aquí va una pista:",
+                "¡Vamos, estás tan cerca de descifrar el enigma semántico! Pero si sientes que te falta un empujón, aquí tienes una pista:",
+                "Tu mente está explorando este campo semántico como un detective, ¡pero incluso los detectives a veces necesitan pistas extra! Así que, aquí va una para ti:",
+                "El camino semántico puede volverse un poco sinuoso a veces. No te preocupes, estoy aquí para allanar el camino con una pista:",
+                "Las palabras son como piezas de un rompecabezas, y sé que estás cerca de completar la imagen. Aquí va una pista para encajar las piezas restantes:",
+                "Estás navegando por las aguas semánticas con destreza, ¡pero incluso los capitanes expertos pueden necesitar un faro de vez en cuando! Aquí está tu faro, tu pista:",
+                "La danza de las palabras puede ser complicada, pero no te preocupes, estoy aquí para ser tu guía de baile. Aquí tienes una pista para que sigas moviéndote con gracia:"
+            ]
+        },
+        "Hint": {
+            "secret_word": "La palabra secreta",
+            "hint_0_0": "Define brevemente \"",
+            "hint_0_1": "\"  sin incluir la propia palabra ni palabras de su familia léxica. En caso de usarla refiérete a ",
+            "hint_0_2": "  como \"la palabra secreta\":",
+            "hint_0_3": "Podría definir la palabra secreta como:\n",
+            "hint_1_0": "Representa la palabra ",
+            "hint_1_1": " con emojis:",
+            "hint_1_2": "Voy a intentar representarte la palabra usando emojis:\n",
+            "hint_2_0": "Da una pista en forma de poema de 4 versos sobre ",
+            "hint_2_1": " que no incluya la propia palabra:",
+            "hint_2_2": "Me he inspirado un poco, voy a recitar un poema sobre la palabra secreta:\n",
+            "hint_3_0": "Dime tres palabras aleatorias separadas por coma:",
+            "hint_3_1": "Dime una palabra relacionada con",
+            "hint_3_2": " pero no puede ser la propia palabra ni de su familia léxica. No añadas texto adicional",
+            "hint_3_3": "Voy a pensar cuatro palabras y te muestro entre ellas cual se acerca más a la palabra secreta:\n",
+            "hint_4_0": "Dime el título de una película real donde aparece ",
+            "hint_4_1": ". Di únicamente el título, nada mas:",
+            "hint_4_2": "Representa la película ",
+            "hint_4_3": " únicamente con unos pocos emojis:",
+            "hint_4_4": "He pensado en una película relacionada con la palabra secreta y te la voy a representar con emojis, la película es:\n",
+            "curiosity": "Cuéntame una curiosidad sobre \""
+        },
+        "Menu": {
+            "Header": "SEMANTRIX: EL JUEGO DE LAS PALABRAS",
+            "Start": "Empezar",
+            "Next": "Siguiente",
+            "Yes": "Sí",
+            "No": "No",
+            "Easy": "Fácil",
+            "Normal": "Normal",
+            "Hard": "Difícil",
+            "Expert": "Experto",
+            "New_word": "Nueva palabra",
+            "Send": "Enviar",
+            "Give_up": "Rendirse",
+            "Language": "Idioma",
+            "Best_tries": "Mejores intentos",
+            "N_try": "Intento nº",
+            "Word": "Palabra",
+            "Score": "Puntuación",
+            "Last_try": "Último intento",
+            "Curiosity": "Curiosidad",
+            "Play_again": "Jugar de nuevo"
+        }
+    },
+    "ENG": {
+        "Game": {
+
+            "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!",
+            "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: ",
+            "Feedback_1": "Cold, score: ",
+            "Feedback_2": "Warm, score: ",
+            "Feedback_3": "Hot, score: ",
+            "Feedback_4": "Burning, score: ",
+            "Feedback_5": "On fire, score: ",
+            "Feedback_6": "You're getting closer",
+            "Feedback_7": "You're moving away",
+            "Feedback_8": "You've won, CONGRATULATIONS!",
+            "Feedback_9": "The secret word was: ",
+            "Feedback_10": "Though it wasn't a win this time, fear not! Each try is a new chance to shine! Keep going!",
+            "secret_word": "SECRET WORD",
+            "hint_intro": [
+                "It seems like the words are playing hide-and-seek with you. Need a little help? Here's a hint:",
+                "Come on, you're so close to unraveling the semantic mystery! But if you feel like you need a push, here's a hint:",
+                "Your mind is exploring this semantic field like a detective, but even detectives sometimes need extra clues! So, here's one for you:",
+                "The semantic path can get a bit winding at times. Don't worry, I'm here to smooth the way with a hint:",
+                "Words are like pieces of a puzzle, and I know you're close to completing the picture. Here's a hint to fit the remaining pieces:",
+                "You're navigating the semantic waters skillfully, but even expert captains may need a lighthouse now and then! Here's your lighthouse, your hint:",
+                "The dance of words can be intricate, but don't worry, I'm here to be your dance guide. Here's a hint to keep you moving with grace:"
+            ]
+        },
+        "Hint": {
+            "secret_word": "The secret word",
+            "hint_0_0": "Briefly define \"",
+            "hint_0_1": "\" without including the word itself or words from its lexical family. If using it, refer to ",
+            "hint_0_2": " as \"the secret word\":",
+            "hint_0_3": "I could define the secret word as:\n",
+            "hint_1_0": "Represent the word ",
+            "hint_1_1": " with emojis:",
+            "hint_1_2": "I'll try to represent the word using emojis:\n",
+            "hint_2_0": "Give a hint in the form of a 4-verse poem about ",
+            "hint_2_1": " that doesn't include the word itself:",
+            "hint_2_2": "I've been a bit inspired; I'll recite a poem about the secret word:\n",
+            "hint_3_0": "Tell me three random words separated by commas:",
+            "hint_3_1": "Tell me a word related to",
+            "hint_3_2": " but it can't be the word itself or from its lexical family. Don't add any additional text",
+            "hint_3_3": "I'll think of four words and show you which one comes closest to the secret word:\n",
+            "hint_4_0": "Tell me the title of a real movie where ",
+            "hint_4_1": ". Only say the title, nothing more:",
+            "hint_4_2": "Represent the movie ",
+            "hint_4_3": " only with a few emojis:",
+            "hint_4_4": "I've thought of a movie related to the secret word, and I'll represent it with emojis. The movie is:\n",
+            "curiosity": "Tell me an interesting fact about \""
+        },
+        "Menu": {
+            "Header": "SEMANTRIX: THE WORD GUESSING GAME",
+            "Start": "Start",
+            "Next": "Next",
+            "Yes": "Yes",
+            "No": "No",
+            "Easy": "Easy",
+            "Normal": "Normal",
+            "Hard": "Hard",
+            "Expert": "Expert",
+            "New_word": "New word",
+            "Send": "Send",
+            "Give_up": "Give up",
+            "Language": "Language",
+            "Best_tries": "Best tries",
+            "N_try": "Try nº",
+            "Word": "Word",
+            "Score": "Score",
+            "Last_try": "Last try",
+            "Curiosity": "Curiosity",
+            "Play_again": "Play again"
+        }
+    }
+}

config/secret.json

@@ -0,0 +1,1035 @@
+{
+    "ENG": {
+        "basic": [
+            "ant",
+            "tree",
+            "glass",
+            "mountains",
+            "dress",
+            "rain",
+            "soap",
+            "finger",
+            "man",
+            "earth",
+            "stick",
+            "office",
+            "sadness",
+            "radio",
+            "keyboard",
+            "dirt",
+            "plum",
+            "message",
+            "eel",
+            "king",
+            "wild boar",
+            "nut",
+            "planet",
+            "party",
+            "son",
+            "cellphone",
+            "visit",
+            "tab",
+            "elegance",
+            "gloves",
+            "turtle",
+            "lock",
+            "plane",
+            "leaf",
+            "suitcase",
+            "cookie",
+            "hand",
+            "lamp",
+            "woman",
+            "pen",
+            "mountain",
+            "leaves",
+            "wind",
+            "helmet",
+            "spring",
+            "atom",
+            "dad",
+            "father-in-law",
+            "watch",
+            "cabin",
+            "map",
+            "cow",
+            "rectangle",
+            "shoe",
+            "parrot",
+            "insect",
+            "letter",
+            "baby",
+            "keys",
+            "toucan",
+            "wall",
+            "jacket",
+            "waterfall",
+            "seat",
+            "ear",
+            "team",
+            "luck",
+            "soul",
+            "guitar",
+            "choir",
+            "summer",
+            "dream",
+            "button",
+            "chair",
+            "lamb",
+            "ease",
+            "notebook",
+            "curiosity",
+            "coin",
+            "hanger",
+            "violin",
+            "singer",
+            "camera",
+            "snow",
+            "pool",
+            "container",
+            "photograph",
+            "shelter",
+            "animal",
+            "fear",
+            "rat",
+            "plastic",
+            "debate",
+            "duck",
+            "feather",
+            "monkey",
+            "people",
+            "door",
+            "blind",
+            "nose",
+            "wood",
+            "leg",
+            "car",
+            "hair",
+            "key",
+            "stewardess",
+            "living room",
+            "forest",
+            "castle",
+            "salad",
+            "lock",
+            "carnation",
+            "molar",
+            "bird",
+            "table",
+            "beach",
+            "screen",
+            "agenda",
+            "person",
+            "idea",
+            "clothing",
+            "wheel",
+            "tool",
+            "aluminium",
+            "house",
+            "cup",
+            "clouds",
+            "jug",
+            "circle",
+            "brother",
+            "farm",
+            "sorrow",
+            "hook",
+            "iron",
+            "hump",
+            "sound",
+            "zoo",
+            "photo",
+            "toy",
+            "crib",
+            "war",
+            "dressing room",
+            "sheep",
+            "hail",
+            "pilot",
+            "grass",
+            "spider",
+            "hammer",
+            "last name",
+            "boat",
+            "armchair",
+            "plate",
+            "seal",
+            "tiger",
+            "lawn",
+            "dog",
+            "oil",
+            "bow",
+            "helm",
+            "school",
+            "can opener",
+            "chimney",
+            "match",
+            "molecule",
+            "shirt",
+            "hut",
+            "calculator",
+            "horse",
+            "pine grove",
+            "paper",
+            "ornament",
+            "church",
+            "uncle",
+            "pencil",
+            "pig",
+            "cheese",
+            "cream",
+            "time",
+            "field",
+            "pants",
+            "pen",
+            "cloud",
+            "friend",
+            "purse",
+            "competition",
+            "light",
+            "program",
+            "cable",
+            "key",
+            "writing",
+            "floor",
+            "job",
+            "compass",
+            "coaster",
+            "sun",
+            "lights",
+            "furniture",
+            "dogs",
+            "eye",
+            "rope",
+            "noodles",
+            "kindness",
+            "sailboat",
+            "bed",
+            "sand",
+            "corner",
+            "cat",
+            "honey",
+            "chocolate",
+            "bell",
+            "noise",
+            "pillar",
+            "child",
+            "street",
+            "rocket",
+            "herd",
+            "godfather",
+            "headphones",
+            "nephew",
+            "hospital",
+            "July",
+            "bunch",
+            "speaker",
+            "brother-in-law",
+            "coffee",
+            "satellite",
+            "screw",
+            "books",
+            "letter",
+            "folder",
+            "train",
+            "briefcase",
+            "school",
+            "picture",
+            "eagle",
+            "love",
+            "room",
+            "truck",
+            "newspapers",
+            "tablecloth",
+            "notes",
+            "heron",
+            "painting",
+            "fluff",
+            "tie",
+            "letters",
+            "printer",
+            "sofa",
+            "flower",
+            "weasel",
+            "lemon",
+            "mason",
+            "glass",
+            "meat",
+            "city",
+            "designer",
+            "lagoon",
+            "darkness",
+            "meadow",
+            "puma",
+            "ship",
+            "troop",
+            "lime",
+            "cage",
+            "sport",
+            "casino",
+            "building",
+            "firefighter",
+            "plant"
+        ],
+        "advanced": [
+            "accountant",
+            "hatred",
+            "engineer",
+            "viewer",
+            "window",
+            "substance",
+            "complaint",
+            "platform",
+            "toilet",
+            "Argentina",
+            "Guadeloupe",
+            "machinist",
+            "explosion",
+            "gas",
+            "presidency",
+            "lake",
+            "visit",
+            "speech",
+            "archipelago",
+            "entrepreneur",
+            "Temple",
+            "utensil",
+            "theater",
+            "classroom",
+            "television",
+            "glasses",
+            "reptile",
+            "whale",
+            "fauna",
+            "plane",
+            "stone",
+            "family",
+            "discotheque",
+            "bomb",
+            "waitress",
+            "candidate",
+            "triangle",
+            "famous",
+            "auction",
+            "belt",
+            "atom",
+            "bookstore",
+            "watch",
+            "music",
+            "Grandmother",
+            "candies",
+            "battery",
+            "brother",
+            "Colombia",
+            "hook",
+            "sound",
+            "government",
+            "note",
+            "hippopotamus",
+            "metal",
+            "happiness",
+            "baby",
+            "tiger",
+            "child",
+            "vocabulary",
+            "grapefruit",
+            "cloud",
+            "competition",
+            "cable",
+            "Mexico",
+            "program",
+            "writing",
+            "compass",
+            "coaster",
+            "program",
+            "writing",
+            "compass",
+            "coaster",
+            "lights",
+            "water",
+            "bottle",
+            "floor",
+            "rabbit",
+            "book",
+            "bridge",
+            "scarf",
+            "school",
+            "picture",
+            "notes",
+            "photo",
+            "toy",
+            "war",
+            "heron",
+            "carnation",
+            "enthusiasm",
+            "molar",
+            "bird",
+            "table",
+            "screen",
+            "agenda",
+            "person",
+            "idea",
+            "clothing",
+            "wheel",
+            "tool",
+            "aluminium",
+            "house",
+            "cup",
+            "clouds",
+            "jug",
+            "circle",
+            "Colombia",
+            "farm",
+            "sorrow",
+            "iron",
+            "hump",
+            "zoo",
+            "government",
+            "photo",
+            "toy",
+            "crib",
+            "war",
+            "dressing room",
+            "tornado",
+            "sheep",
+            "hail",
+            "pilot",
+            "grass",
+            "spider",
+            "anguish",
+            "hammer",
+            "statistics",
+            "last name",
+            "boat",
+            "armchair",
+            "plate",
+            "river",
+            "seal",
+            "rhinoceros",
+            "shirt",
+            "hut",
+            "calculator",
+            "horse",
+            "pine grove",
+            "paper",
+            "ornament",
+            "church",
+            "uncle",
+            "pencil",
+            "pig",
+            "cheese",
+            "cream",
+            "time",
+            "vocabulary",
+            "grapefruit",
+            "field",
+            "pants",
+            "pen",
+            "cloud",
+            "friend",
+            "purse",
+            "competition",
+            "light",
+            "program",
+            "cable",
+            "key",
+            "writing",
+            "Mexico",
+            "floor",
+            "job",
+            "compass",
+            "coaster",
+            "sun",
+            "lights",
+            "furniture",
+            "dogs",
+            "eye",
+            "rope",
+            "noodles",
+            "kindness",
+            "sailboat",
+            "bed",
+            "sand",
+            "corner",
+            "cat",
+            "honey",
+            "chocolate",
+            "bell",
+            "noise",
+            "pillar",
+            "child",
+            "street",
+            "rocket",
+            "herd",
+            "godfather",
+            "headphones",
+            "nephew",
+            "hospital",
+            "July",
+            "bunch",
+            "Chile",
+            "speaker",
+            "brother-in-law",
+            "coffee",
+            "satellite",
+            "screw",
+            "books",
+            "letter",
+            "folder",
+            "train",
+            "briefcase",
+            "school",
+            "picture",
+            "eagle",
+            "love",
+            "room",
+            "truck",
+            "newspapers",
+            "tablecloth",
+            "notes",
+            "heron",
+            "painting",
+            "fluff",
+            "tie",
+            "letters",
+            "printer",
+            "sofa",
+            "flower",
+            "weasel",
+            "lemon",
+            "mason",
+            "glass",
+            "meat",
+            "city",
+            "designer",
+            "lagoon",
+            "darkness",
+            "meadow",
+            "puma",
+            "ship",
+            "troop",
+            "lime",
+            "cage",
+            "sport",
+            "casino",
+            "building",
+            "firefighter",
+            "plant",
+            "clarity"
+        ]
+    },
+    "SPA": {
+        "basic": [
+            "vestido",
+            "lluvia",
+            "jabón",
+            "dedo",
+            "hombre",
+            "tierra",
+            "palo",
+            "oficina",
+            "tristeza",
+            "radio",
+            "teclado",
+            "tierra",
+            "ciruela",
+            "mensaje",
+            "anguila",
+            "rey",
+            "jabalí",
+            "nuez",
+            "planeta",
+            "fiesta",
+            "hijo",
+            "teléfono",
+            "visita",
+            "pestaña",
+            "elegancia",
+            "guantes",
+            "tortuga",
+            "cerradura",
+            "avión",
+            "hoja",
+            "maleta",
+            "galleta",
+            "mano",
+            "lámpara",
+            "mujer",
+            "pluma",
+            "montaña",
+            "hojas",
+            "viento",
+            "casco",
+            "primavera",
+            "átomo",
+            "papá",
+            "suegro",
+            "reloj",
+            "cabaña",
+            "mapa",
+            "vaca",
+            "rectángulo",
+            "zapato",
+            "loro",
+            "insecto",
+            "carta",
+            "bebé",
+            "llaves",
+            "tucán",
+            "pared",
+            "chaqueta",
+            "cascada",
+            "asiento",
+            "oreja",
+            "equipo",
+            "suerte",
+            "alma",
+            "guitarra",
+            "coro",
+            "verano",
+            "sueño",
+            "botón",
+            "silla",
+            "cordero",
+            "facilidad",
+            "cuaderno",
+            "curiosidad",
+            "moneda",
+            "percha",
+            "violín",
+            "cantante",
+            "cámara",
+            "nieve",
+            "piscina",
+            "contenedor",
+            "fotografía",
+            "refugio",
+            "animal",
+            "miedo",
+            "rata",
+            "plástico",
+            "debate",
+            "pato",
+            "pluma",
+            "mono",
+            "gente",
+            "puerta",
+            "persiana",
+            "nariz",
+            "madera",
+            "pierna",
+            "coche",
+            "cabello",
+            "llave",
+            "azafata",
+            "sala de estar",
+            "bosque",
+            "castillo",
+            "ensalada",
+            "cerradura",
+            "clavel",
+            "molar",
+            "pájaro",
+            "mesa",
+            "playa",
+            "pantalla",
+            "agenda",
+            "persona",
+            "idea",
+            "ropa",
+            "rueda",
+            "herramienta",
+            "aluminio",
+            "casa",
+            "taza",
+            "nubes",
+            "jarra",
+            "círculo",
+            "hermano",
+            "granja",
+            "pena",
+            "gancho",
+            "hierro",
+            "joroba",
+            "sonido",
+            "zoológico",
+            "foto",
+            "juguete",
+            "cuna",
+            "guerra",
+            "vestuario",
+            "oveja",
+            "granizo",
+            "piloto",
+            "césped",
+            "araña",
+            "martillo",
+            "apellido",
+            "barco",
+            "sillón",
+            "plato",
+            "foca",
+            "tigre",
+            "césped",
+            "perro",
+            "aceite",
+            "arco",
+            "timón",
+            "escuela",
+            "abrelatas",
+            "chimenea",
+            "fósforo",
+            "molécula",
+            "camisa",
+            "choza",
+            "calculadora",
+            "caballo",
+            "pinar",
+            "papel",
+            "adorno",
+            "iglesia",
+            "tío",
+            "lápiz",
+            "cerdo",
+            "queso",
+            "crema",
+            "tiempo",
+            "campo",
+            "pantalones",
+            "pluma",
+            "nube",
+            "amigo",
+            "bolso",
+            "competencia",
+            "luz",
+            "programa",
+            "cable",
+            "llave",
+            "escritura",
+            "piso",
+            "trabajo",
+            "brújula",
+            "posavasos",
+            "sol",
+            "luces",
+            "muebles",
+            "perros",
+            "ojo",
+            "cuerda",
+            "fideos",
+            "bondad",
+            "velero",
+            "cama",
+            "arena",
+            "esquina",
+            "gato",
+            "miel",
+            "chocolate",
+            "campana",
+            "ruido",
+            "pilar",
+            "niño",
+            "calle",
+            "cohete",
+            "manada",
+            "padrino",
+            "auriculares",
+            "sobrino",
+            "hospital",
+            "julio",
+            "ramo",
+            "altavoz",
+            "cuñado",
+            "café",
+            "satélite",
+            "tornillo",
+            "libros",
+            "carta",
+            "carpeta",
+            "tren",
+            "maletín",
+            "escuela",
+            "imagen",
+            "águila",
+            "amor",
+            "habitación",
+            "camión",
+            "periódicos",
+            "mantel",
+            "notas",
+            "garza",
+            "pintura",
+            "pelusa",
+            "corbata",
+            "letras",
+            "impresora",
+            "sofá",
+            "flor",
+            "comadreja",
+            "limón",
+            "albañil",
+            "vidrio",
+            "carne",
+            "ciudad",
+            "diseñador",
+            "laguna",
+            "oscuridad",
+            "prado",
+            "puma",
+            "barco",
+            "tropa",
+            "lima",
+            "jaula",
+            "deporte",
+            "casino",
+            "edificio",
+            "bombero",
+            "planta"
+        ],
+        "advanced": [
+            "contador",
+            "odio",
+            "ingeniero",
+            "espectador",
+            "ventana",
+            "sustancia",
+            "queja",
+            "plataforma",
+            "inodoro",
+            "Argentina",
+            "Guadalupe",
+            "mecánico",
+            "explosión",
+            "gas",
+            "presidencia",
+            "lago",
+            "visita",
+            "discurso",
+            "archipiélago",
+            "empresario",
+            "templo",
+            "utensilio",
+            "teatro",
+            "aula",
+            "televisión",
+            "gafas",
+            "reptil",
+            "ballena",
+            "fauna",
+            "avión",
+            "piedra",
+            "familia",
+            "discoteca",
+            "bomba",
+            "mesera",
+            "candidato",
+            "triángulo",
+            "famoso",
+            "subasta",
+            "cinturón",
+            "átomo",
+            "librería",
+            "reloj",
+            "música",
+            "abuela",
+            "caramelos",
+            "batería",
+            "hermano",
+            "Colombia",
+            "gancho",
+            "sonido",
+            "gobierno",
+            "nota",
+            "hipopótamo",
+            "metal",
+            "felicidad",
+            "bebé",
+            "tigre",
+            "niño",
+            "vocabulario",
+            "pomelo",
+            "nube",
+            "competencia",
+            "cable",
+            "México",
+            "programa",
+            "escritura",
+            "brújula",
+            "posavasos",
+            "programa",
+            "escritura",
+            "brújula",
+            "posavasos",
+            "luces",
+            "agua",
+            "botella",
+            "piso",
+            "conejo",
+            "libro",
+            "puente",
+            "bufanda",
+            "escuela",
+            "imagen",
+            "notas",
+            "foto",
+            "juguete",
+            "guerra",
+            "garza",
+            "clavel",
+            "entusiasmo",
+            "molar",
+            "pájaro",
+            "mesa",
+            "pantalla",
+            "agenda",
+            "persona",
+            "idea",
+            "ropa",
+            "rueda",
+            "herramienta",
+            "aluminio",
+            "casa",
+            "taza",
+            "nubes",
+            "jarra",
+            "círculo",
+            "Colombia",
+            "granja",
+            "pena",
+            "hierro",
+            "joroba",
+            "zoológico",
+            "gobierno",
+            "foto",
+            "juguete",
+            "cuna",
+            "guerra",
+            "vestuario",
+            "oveja",
+            "granizo",
+            "piloto",
+            "césped",
+            "araña",
+            "angustia",
+            "martillo",
+            "estadísticas",
+            "apellido",
+            "barco",
+            "sillón",
+            "plato",
+            "río",
+            "foca",
+            "rinoceronte",
+            "camisa",
+            "choza",
+            "calculadora",
+            "caballo",
+            "pinar",
+            "papel",
+            "adorno",
+            "iglesia",
+            "tío",
+            "lápiz",
+            "cerdo",
+            "queso",
+            "crema",
+            "tiempo",
+            "vocabulario",
+            "pomelo",
+            "campo",
+            "pantalones",
+            "pluma",
+            "nube",
+            "amigo",
+            "bolso",
+            "competencia",
+            "luz",
+            "programa",
+            "cable",
+            "llave",
+            "escritura",
+            "México",
+            "piso",
+            "trabajo",
+            "brújula",
+            "posavasos",
+            "sol",
+            "luces",
+            "muebles",
+            "perros",
+            "ojo",
+            "cuerda",
+            "fideos",
+            "bondad",
+            "velero",
+            "cama",
+            "arena",
+            "esquina",
+            "gato",
+            "miel",
+            "chocolate",
+            "campana",
+            "ruido",
+            "pilar",
+            "niño",
+            "calle",
+            "cohete",
+            "manada",
+            "padrino",
+            "auriculares",
+            "sobrino",
+            "hospital",
+            "julio",
+            "ramo",
+            "Chile",
+            "altavoz",
+            "cuñado",
+            "café",
+            "satélite",
+            "tornillo",
+            "libros",
+            "carta",
+            "carpeta",
+            "tren",
+            "maletín",
+            "escuela",
+            "imagen",
+            "águila",
+            "amor",
+            "habitación",
+            "camión",
+            "periódicos",
+            "mantel",
+            "notas",
+            "garza",
+            "pintura",
+            "pelusa",
+            "corbata",
+            "letras",
+            "impresora",
+            "sofá",
+            "flor",
+            "comadreja",
+            "limón",
+            "albañil",
+            "vidrio",
+            "carne",
+            "ciudad",
+            "diseñador",
+            "laguna",
+            "oscuridad",
+            "prado",
+            "puma",
+            "barco",
+            "tropa",
+            "lima",
+            "jaula",
+            "deporte",
+            "casino",
+            "edificio",
+            "bombero",
+            "planta",
+            "claridad"
+        ]
+    }
+}

game.py

@@ -0,0 +1,417 @@
+#!/usr/bin/env python3.10
+
+# """
+# Semantrix Game Module
+
+# This module defines the Semantrix class, which implements a word guessing game using word embeddings. The game can be configured to use either a Word2Vec model or a SentenceTransformer model for word embeddings. The game supports multiple languages and difficulty levels.
+
+# Classes:
+#     Semantrix: A class that implements the Semantrix word guessing game.
+#     Semantrix.DictWrapper: A helper class to wrap configuration dictionaries.
+
+# Functions:
+#     __init__(self, lang=0, model_type="SentenceTransformer"): Initializes the Semantrix game with the specified language and model type.
+#     prepare_game(self, difficulty): Prepares the game with the selected difficulty level.
+#     gen_rank(self, repeated): Generates the ranking file based on the scores.
+#     play_game(self, word): Plays the game with the selected word and returns feedback.
+#     curiosity(self): Generates a curiosity hint about the secret word once the game is over.
+
+# Attributes:
+#     model (KeyedVectors): The word embeddings model.
+#     config_file_path (str): Path to the configuration file.
+#     secret_file_path (str): Path to the secret words file.
+#     data_path (str): Path to the data directory.
+#     Config_full (dict): Full configuration data.
+#     secret (dict): Secret words data.
+#     lang (int): Language of the game (0 for Spanish, 1 for English).
+#     model_type (str): Type of the model ("word2vec" or "SentenceTransformer").
+#     Config (DictWrapper): Configuration data for the selected language.
+#     secret_dict (dict): Secret words for the selected language.
+#     secret_list (list): List of secret words for the selected difficulty.
+#     words (list): List of words guessed by the player.
+#     scores (list): List of scores for the guessed words.
+#     win (bool): Indicates if the player has won the game.
+#     n (int): Number of hints given.
+#     recent_hint (int): Counter for recent hints.
+#     f_dev_avg (float): Moving average of the tendency slope.
+#     last_hint (int): Index of the last hint given.
+#     difficulty (int): Difficulty level of the game.
+# """
+
+import os
+import sys
+import json
+import uuid
+import random
+from datetime import datetime
+import time
+from tqdm import tqdm
+import numpy as np
+from gensim.models import KeyedVectors
+from hints import curiosity, hint
+from tracking import (
+    calculate_moving_average,
+    calculate_tendency_slope,
+)
+from sentence_transformers import SentenceTransformer, util
+import warnings
+from huggingface_hub import snapshot_download
+
+
+warnings.filterwarnings(action="ignore", category=UserWarning, module="gensim")
+
+
+class Model_class:
+
+    base_path = os.path.dirname(os.path.abspath(__file__))
+
+    def __init__(self, lang=0, model_type="SentenceTransformer"):
+
+        if model_type == "SentenceTransformer":
+            repo_url = "Jsevisal/strans_models"
+
+        else:
+            repo_url = "Jsevisal/w2v_models"
+
+        # Check if the model exists, clone it if it doesn't
+        if not os.path.exists(
+            os.path.join(self.base_path, "config/strans_models/")
+        ) or not os.path.exists(os.path.join(self.base_path, "config/w2v_models/")):
+            model_path = snapshot_download(repo_id=repo_url)
+
+        if lang == 1:
+            if model_type == "word2vec":
+                self.model = KeyedVectors.load(
+                    os.path.join(model_path, "eng_w2v_model"),
+                    mmap="r",
+                )
+            elif model_type == "SentenceTransformer":
+                self.model = KeyedVectors.load(
+                    os.path.join(model_path, "eng_strans_model"),
+                    mmap="r",
+                )
+
+        else:
+            if model_type == "word2vec":
+                self.model = KeyedVectors.load(
+                    os.path.join(model_path, "esp_w2v_model"),
+                    mmap="r",
+                )
+
+            elif model_type == "SentenceTransformer":
+                self.model = KeyedVectors.load(
+                    os.path.join(model_path, "esp_strans_model"),
+                    mmap="r",
+                )
+
+        self.model_st = SentenceTransformer(
+            "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
+        )
+
+
+# Define the class Semantrix
+class Semantrix:
+
+    # Define the paths for the configuration files and the data
+    base_path = os.path.dirname(os.path.abspath(__file__))
+    config_file_path = os.path.join(base_path, "config/")
+    config_file_path = os.path.join(base_path, "config/lang.json")
+    secret_file_path = os.path.join(base_path, "config/secret.json")
+    data_path = os.path.join(base_path, "data/")
+
+    # Define the class DictWrapper to store the configuration data
+    class DictWrapper:
+        def __init__(self, data_dict):
+            self.__dict__.update(data_dict)
+
+    # Define the constructor of the class which loads the configuration files and initializes the class variables depending on the language parameter and the model type
+    def __init__(self, lang=0, model_type="SentenceTransformer", session_hash=None):
+
+        # Load the configuration files
+        with open(self.config_file_path, "r") as file:
+            self.Config_full = json.load(file)
+
+        # Load the secret file where the secret words are stored
+        with open(self.secret_file_path, "r") as file:
+            self.secret = json.load(file)
+
+        # Set the language of the game
+        self.lang = lang
+
+        self.session_id = str(uuid.uuid4().hex)
+
+        # Set the model type
+        self.model_type = model_type
+
+        self.session_hash = session_hash
+        self.ranking_path = "rankings/ranking_" + str(self.session_hash) + ".txt"
+
+        self.ranking_data = []
+        self.ranking_msg = ""
+
+        if lang == 1:
+            self.Config = self.DictWrapper(self.Config_full["ENG"]["Game"])
+            self.secret_dict = self.secret["ENG"]
+            self.secret_list = self.secret_dict["basic"]
+        else:
+            self.Config = self.DictWrapper(self.Config_full["SPA"]["Game"])
+            self.secret_dict = self.secret["SPA"]
+            self.secret_list = self.secret_dict["basic"]
+
+        # Create the ranking file
+        with open(self.data_path + self.ranking_path, "w+") as file:
+            file.write("---------------------------")
+
+    def reset_game(self):
+        self.session_id = str(uuid.uuid4().hex)
+        # Load the secret file where the secret words are stored
+        with open(self.secret_file_path, "r") as file:
+            self.secret = json.load(file)
+        self.secret_dict = self.secret["SPA"]
+        self.secret_list = self.secret_dict["basic"]
+
+    def generate_gensim_model(self, model_class, batch_size=32):
+        from tqdm import tqdm
+
+        self.model_trans = KeyedVectors(768)
+
+        self.model_trans.init_sims(replace=True)
+        words = list(model_class.model.key_to_index.keys())
+        num_batches = (
+            len(words) + batch_size - 1
+        ) // batch_size  # Calculate the number of batches
+
+        for batch_index in tqdm(range(num_batches)):
+            # Get the batch of words
+            start_index = batch_index * batch_size
+            end_index = min(start_index + batch_size, len(words))
+            batch_words = words[start_index:end_index]
+
+            # Encode the batch of words
+            encoded_vectors = model_class.model_st.encode(
+                batch_words,
+                convert_to_tensor=True,
+                prompt="Encuentra el valor semántico de la palabra: ",
+            ).tolist()
+
+            # # Add vectors to the model
+            self.model_trans.add_vectors(batch_words, encoded_vectors)
+
+        self.model_trans.save("config/strans_models/esp_strans_model_prompt")
+
+    # Define the function to prepare the game with the selected difficulty
+    def prepare_game(self, secret_word_used, difficulty):
+
+        # Set the secret list depending on the difficulty
+        self.secret = self.secret_list[secret_word_used]
+        self.secret = self.secret.lower()
+
+        self.init_time = time.time()
+
+        # Store the secret word in the words list
+        self.words = [self.Config.secret_word]
+
+        # Store the score in the scores list
+        self.scores = [10]
+
+        # Initialize the game variables
+        self.win = False
+        self.n = 0
+        self.recent_hint = 0
+        self.f_dev_avg = 0
+        self.last_hint = -1
+        self.difficulty = difficulty
+
+        # Set the number of hints depending on the difficulty
+        if self.difficulty == 1:
+            self.n = 3
+
+    # Define the function to generate the ranking file
+    def gen_rank(self, repeated):
+        ascending_indices = np.argsort(self.scores)
+        descending_indices = list(ascending_indices[::-1])
+        self.ranking_data.clear()
+        k = len(self.words) - 1
+        if repeated != -1:
+            k = repeated
+
+        self.ranking_data.append(["#" + str(k), self.words[k], self.scores[k]])
+
+        self.ranking_data.append("---------------------------")
+        for i in descending_indices:
+            if i == 0:
+                continue
+            self.ranking_data.append(["#" + str(i), self.words[i], self.scores[i]])
+
+        with open(self.data_path + self.ranking_path, "w+") as file:
+            for item in self.ranking_data:
+                file.write("%s\n" % item)
+
+        self.ranking_msg = ""
+        for item in self.ranking_data:
+            self.ranking_msg += f"{item}\n"
+
+    # Define the function to play the game with the selected word
+    def play_game(self, word, model_class):
+
+        # Convert the word to lowercase
+        word = word.lower().strip()
+
+        # Check if the user wants to give up
+        if word == "give_up":
+            text = (
+                "[lose]"
+                + str(self.Config.Feedback_9)
+                + self.secret
+                + "\n\n"
+                + self.Config.Feedback_10
+            )
+            return text
+
+        # Check if the word is repeated
+        if word in self.words:
+            repeated = self.words.index(word)
+        else:
+            repeated = -1
+            self.words.append(word)
+
+        # Check if the word is in the model already
+        if word not in model_class.model.key_to_index.keys():
+            # If the word is not in the model, remove it from the words list and provide feedback
+            self.words.pop(len(self.words) - 1)
+            feedback = (
+                "I don't know that word. Try another word."
+                if self.lang == 1
+                else "No conozco esa palabra. Prueba con otra palabra."
+            )
+
+            feedback += "[rank]" + self.ranking_msg if len(self.words) > 1 else "\n\n"
+            return feedback
+
+        similarity = model_class.model.similarity(self.secret, word)
+
+        if self.model_type == "word2vec":
+            score = np.round(similarity * 10, 2)
+        else:
+            # log_similarity = np.log10(similarity * 10) if np.any(similarity > 0) else 0
+            # score = np.round(
+            #     np.interp(
+            #         log_similarity,
+            #         [0, np.log10(10)],
+            #         [0, 10],
+            #     ),
+            #     2,
+            # )
+            score = np.round(similarity * 10, 2)
+
+        # Remove the word from the score list if it is repeated
+        if repeated == -1:
+            self.scores.append(score)
+
+        # Generate the feedback message depending on the score
+        if score <= 2.5:
+            feedback = self.Config.Feedback_0 + str(score)
+        elif score > 2.5 and score <= 6.0:
+            feedback = self.Config.Feedback_1 + str(score)
+        elif score > 6.0 and score <= 7.0:
+            feedback = self.Config.Feedback_2 + str(score)
+        elif score > 7.0 and score <= 8:
+            feedback = self.Config.Feedback_3 + str(score)
+        elif score > 8 and score <= 9.0:
+            feedback = self.Config.Feedback_4 + str(score)
+        elif score > 9.0 and score < 10.0:
+            feedback = self.Config.Feedback_5 + str(score)
+        # If the score is 10, the user wins the game
+        else:
+            self.win = True
+            feedback = "[win]" + self.Config.Feedback_8
+            self.words[0] = self.secret
+            self.words.pop(len(self.words) - 1)
+            self.scores.pop(len(self.scores) - 1)
+
+        # Generate the feedback message depending on the score and the previous score
+        if score > self.scores[len(self.scores) - 2] and self.win == False:
+            feedback += "\n" + self.Config.Feedback_6
+        elif score < self.scores[len(self.scores) - 2] and self.win == False:
+            feedback += "\n" + self.Config.Feedback_7
+
+        ## Hint generation
+        # If the difficulty is not 4, calculate the moving average of the scores and the tendency slope
+        if self.difficulty != 4 and len(self.scores) > 1:
+            mov_avg = calculate_moving_average(self.scores[1:], 5)
+
+            # If the moving average has more than one element and the user has not won yet, calculate the tendency slope and the moving average of the tendency slope
+            if len(mov_avg) > 1 and self.win == False:
+                f_dev = calculate_tendency_slope(mov_avg)
+                f_dev_avg = calculate_moving_average(f_dev, 3)
+
+                # If the tendency slope is negative and the hint has not been given recently (at least three rounds earlier), generate a hint
+                if f_dev_avg[len(f_dev_avg) - 1] < 0 and self.recent_hint == 0:
+
+                    # Generate a random hint intro from the hint list
+                    i = random.randint(0, len(self.Config.hint_intro) - 1)
+                    feedback += "\n\n[hint]" + self.Config.hint_intro[i]
+
+                    # Generate a dynamic hint
+                    hint_text, self.n, self.last_hint = hint(
+                        self.secret,
+                        self.n,
+                        model_class.model_st,
+                        self.last_hint,
+                        self.lang,
+                        (
+                            self.DictWrapper(self.Config_full["ENG"]["Hint"])
+                            if self.lang == 1
+                            else self.DictWrapper(self.Config_full["SPA"]["Hint"])
+                        ),
+                    )
+                    feedback += "\n" + hint_text
+                    self.recent_hint = 3
+
+            if self.recent_hint != 0:
+                self.recent_hint -= 1
+
+        # Generate the ranking file
+        self.gen_rank(repeated)
+
+        # Add the ranking file to the feedback message
+        feedback += "[rank]" + self.ranking_msg if len(self.words) > 1 else "\n\n"
+
+        # Return the feedback message
+        return feedback
+
+    # Define the function to generate a curiosity hint once the game is over
+    def curiosity(self):
+
+        # Generate a curiosity aboyt the secret word
+        feedback = curiosity(
+            self.secret,
+            (
+                self.DictWrapper(self.Config_full["ENG"]["Hint"])
+                if self.lang == 1
+                else self.DictWrapper(self.Config_full["SPA"]["Hint"])
+            ),
+        )
+
+        # Save the ranking file with the plays of the user if the user wins
+        with open(self.data_path + self.ranking_path, "r") as original_file:
+            file_content = original_file.readlines()[2:]
+            new_file_name = f"{self.session_id}-{self.secret}.json"
+            play_data = {
+                "session_id": self.session_id,
+                "datetime": str(datetime.now()),
+                "time": time.time() - self.init_time,
+                "data": file_content,
+                "win": self.win,
+                "secret": self.secret,
+                "number_of_hints": self.n,
+            }
+
+            with open(self.data_path + "plays/" + new_file_name, "w") as new_file:
+                json.dump(play_data, new_file, indent=4)
+
+        # Return the feedback message
+        return feedback
+
+    def get_session_id(self):
+        return self.session_id

gen_model.py

@@ -0,0 +1,13 @@
+# %%
+from game import Semantrix, Model_class
+
+# %%
+model = "word2vec"
+model_class = Model_class(lang=0, model_type=model)
+
+sem = Semantrix(lang=1, model_type="SentenceTransformer")
+
+# %%
+sem.generate_gensim_model(batch_size=128, model_class=model_class)
+
+# %%

hints.py

@@ -0,0 +1,286 @@
+# """
+# This module provides functions to generate dynamic hints and curiosities about a secret word using llms.
+
+# Functions:
+#     hint(secret, n, model, last_hint, lang, Config):
+#         Generates a dynamic hint based on the secret word and the number of hints given.
+#         Parameters:
+#             secret (str): The secret word.
+#             n (int): The number of hints already given.
+#             model: The sentence transformer model used for encoding.
+#             last_hint (int): The index of the last hint given.
+#             lang (int): The language code (0 for Spanish, 1 for English).
+#             Config: Configuration object containing hint templates.
+#         Returns:
+#             tuple: A tuple containing the generated hint (str), the updated number of hints (int), and the index of the last hint given (int).
+
+#     curiosity(secret, Config):
+#         Generates a curiosity about the secret word.
+#         Parameters:
+#             secret (str): The secret word.
+#             Config: Configuration object containing the curiosity template.
+#         Returns:
+#             str: The generated curiosity.
+
+#     ireplace(old, new, text):
+#         Replaces all occurrences of a substring in a string, case-insensitively.
+#         Parameters:
+#             old (str): The substring to be replaced.
+#             new (str): The substring to replace with.
+#             text (str): The original string.
+#         Returns:
+#             str: The modified string with all occurrences of the old substring replaced by the new substring.
+# """
+
+import random
+import openai
+from sentence_transformers import util
+
+gpt_model = "gpt-3.5-turbo"
+
+
+# Dynamic hint function that returns a hint based on the secret word and the number of hints given
+def hint(secret, n, model, last_hint, lang, Config):
+
+    # Initialize hint variable
+    hint = ""
+
+    # Advanced hints
+    if n >= 3:
+        j = random.randint(0, 2)
+        while j == last_hint:
+            j = random.randint(0, 2)
+
+        # Advanced hint 1: Definition of the secret word
+        if j == 0:
+            response = openai.chat.completions.create(
+                model=gpt_model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": Config.hint_0_0  # type: ignore
+                        + secret
+                        + Config.hint_0_1  # type: ignore
+                        + secret
+                        + Config.hint_0_2,  # type: ignore
+                    }
+                ],
+                temperature=1,
+                max_tokens=256,
+                top_p=1,
+                frequency_penalty=0.5,
+                presence_penalty=0,
+            )
+            output = str(response.choices[0].message.content)
+            output = output.replace('"', "").replace("'", "")
+
+            # Replace the secret word with "La palabra secreta" or "The secret word" just in case the model uses the secret word in the definition
+            if lang == 0:
+                output = ireplace("la " + secret, "La palabra secreta", output)
+                output = ireplace("las " + secret, "La palabra secreta", output)
+                output = ireplace("el " + secret, "La palabra secreta", output)
+                output = ireplace("los " + secret, "La palabra secreta", output)
+                output = ireplace("un " + secret, "La palabra secreta", output)
+                output = ireplace("una " + secret, "La palabra secreta", output)
+                output = ireplace("unos " + secret, "La palabra secreta", output)
+                output = ireplace("unas " + secret, "La palabra secreta", output)
+            elif lang == 1:
+                output = ireplace("the " + secret, "The secret word", output)
+                output = ireplace("a " + secret, "The secret word", output)
+
+            hint += Config.hint_0_3 + output  # type: ignore
+            last_hint = 0
+
+        # Advanced hint 2: Representation of the secret word with emojis
+        elif j == 1:
+            response = openai.chat.completions.create(
+                model=gpt_model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": Config.hint_1_0 + secret + Config.hint_1_1,  # type: ignore
+                    }
+                ],
+                temperature=1,
+                max_tokens=256,
+                top_p=1,
+                frequency_penalty=0,
+                presence_penalty=0,
+            )
+            output = str(response.choices[0].message.content)
+            hint += Config.hint_1_2 + output  # type: ignore
+            last_hint = 1
+
+        # Advanced hint 3: Poem about the secret word
+        elif j == 2:
+            response = openai.chat.completions.create(
+                model=gpt_model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": Config.hint_2_0 + secret + Config.hint_2_1,  # type: ignore
+                    }
+                ],
+                temperature=1,
+                max_tokens=256,
+                top_p=1,
+                frequency_penalty=0,
+                presence_penalty=0,
+            )
+            output = str(response.choices[0].message.content)
+
+            hint += Config.hint_2_2 + output  # type: ignore
+
+            last_hint = 2
+    # Initial hints
+    else:
+        j = random.randint(3, 4)
+        while j == last_hint:
+            j = random.randint(3, 4)
+
+        # Initial hint 1: Rank of four words related to the secret word
+        if j == 3:
+            words = []
+            response = openai.chat.completions.create(
+                model=gpt_model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": Config.hint_3_0,  # type: ignore
+                    }
+                ],
+                temperature=1.25,
+                max_tokens=256,
+                top_p=1,
+                frequency_penalty=0,
+                presence_penalty=0,
+            )
+            output = str(response.choices[0].message.content)
+            output = (output.replace(" ", "").replace(".", "")).lower()
+            words.extend(output.strip().split(","))
+            response = openai.chat.completions.create(
+                model=gpt_model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": Config.hint_3_1  # type: ignore
+                        + secret
+                        + Config.hint_3_2,  # type: ignore
+                    }
+                ],
+                temperature=1.1,
+                max_tokens=256,
+                top_p=1,
+                frequency_penalty=0,
+                presence_penalty=0,
+            )
+            output = str(response.choices[0].message.content)
+            output = (output.replace(".", "")).lower()
+            words.append(output)  # type: ignore
+            random.shuffle(words)
+            sentences1 = [secret, secret, secret, secret]
+            sentences2 = words
+            embeddings1 = model.encode(sentences1, convert_to_tensor=True)
+            embeddings2 = model.encode(sentences2, convert_to_tensor=True)
+
+            cosine_scores = util.cos_sim(embeddings1, embeddings2)
+            scores = cosine_scores[0].tolist()
+            sum_scores = sum(scores)
+            normalized_scores = [round(score * 100 / sum_scores, 1) for score in scores]
+
+            hint += Config.hint_3_3  # type: ignore
+
+            max_len = -1
+            for ele in words:
+                if len(ele) > max_len:
+                    max_len = len(ele)
+                    longest_word = ele
+
+            for i in range(len(words)):
+
+                word_hint = words[i].ljust(len(longest_word) + 1)
+                hint += (
+                    # word_hint[: len(longest_word)]
+                    word_hint
+                    + "|"
+                    + ("🟩") * round(normalized_scores[i] * 0.2)
+                    + " "
+                    + str(normalized_scores[i])
+                    + "%\n"
+                )
+            last_hint = 3
+
+        # Initial hint 2: Film representation with emojis with the secret word
+        elif j == 4:
+            response = openai.chat.completions.create(
+                model=gpt_model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": Config.hint_4_0  # type: ignore
+                        + secret
+                        + Config.hint_4_1,  # type: ignore
+                    }
+                ],
+                temperature=1,
+                max_tokens=256,
+                top_p=1,
+                frequency_penalty=0,
+                presence_penalty=0,
+            )
+            film_title = str(response.choices[0].message.content).replace('"', "")
+            response = openai.chat.completions.create(
+                model=gpt_model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": Config.hint_4_2  # type: ignore
+                        + film_title
+                        + Config.hint_4_3,  # type: ignore
+                    }
+                ],
+                temperature=1,
+                max_tokens=256,
+                top_p=1,
+                frequency_penalty=0,
+                presence_penalty=0,
+            )
+            output = str(response.choices[0].message.content)
+            hint += Config.hint_4_4 + "\n" + output  # type: ignore
+            last_hint = 4
+
+    return hint, n + 1, last_hint
+
+
+# Tell a curiosity about the secret word
+def curiosity(secret, Config):
+
+    response = openai.chat.completions.create(
+        model=gpt_model,
+        messages=[
+            {
+                "role": "user",
+                "content": Config.curiosity + secret + '".',
+            }
+        ],
+        temperature=1,
+        max_tokens=256,
+        top_p=1,
+        frequency_penalty=0,
+        presence_penalty=0,
+    )
+    output = str(response.choices[0].message.content)
+
+    return output
+
+
+# Replace all occurrences of a substring in a string
+def ireplace(old, new, text):
+    idx = 0
+    while idx < len(text):
+        index_l = text.lower().find(old.lower(), idx)
+        if index_l == -1:
+            return text
+        text = text[:index_l] + new + text[index_l + len(old) :]
+        idx = index_l + len(new)
+    return text

requirements.txt

@@ -0,0 +1,8 @@
+gensim==4.3.0
+sentence_transformers==3.4.1
+openai==1.2.3
+gradio==5.21.0
+transformers==4.49.0
+huggingface-hub==0.28.1
+python-multipart==0.0.18
+httpx==0.27.2

tracking.py

@@ -0,0 +1,23 @@
+import numpy as np
+
+
+def calculate_moving_average(scores, window_size):
+    # Convert the scores list to a NumPy array for better performance
+    scores_array = np.array(scores)
+
+    # Create an array of rolling windows using the np.convolve function
+    moving_averages = np.around(
+        np.convolve(scores_array, np.ones(window_size) / window_size, mode="valid"), 2
+    )
+
+    return list(moving_averages)
+
+
+def calculate_tendency_slope(scores):
+    # Convert the scores list to a NumPy array for better performance
+    scores_array = np.array(scores)
+
+    # Calculate the first derivative (slope) of the scores
+    derivative = np.around(np.gradient(scores_array), 2)
+
+    return list(derivative)