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 Cond2
-emoji: 🏆
-colorFrom: purple
+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_2"
+# 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/1FAIpQLSdGkCMsjk4r5Zvm1hZuebbPRK5LVc_aivbb8e9WrblX_yTHvg/viewform?usp=pp_url&entry.1459162177="
+                + 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)

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)