Add word check and change ln to log10

app.py

@@ -1,61 +1,61 @@
-"""
-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.
-"""
+# """
+# 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
@@ -411,7 +411,7 @@ with gr.Blocks() as demo:
                             visible=True,
                         ),
                         gr.Textbox(curiosity, visible=True, label=Menu["Curiosity"]),
-                        gr.Button(visible=True),
+                        gr.Button(Menu["Play_again"], visible=True),
                         gr.Markdown(visible=False),
                     ]
                 )

data/ranking.txt

@@ -1,10 +1 @@
-['#8', 'medium', 6.94]
----------------------------
-['#1', 'amigo', 8.3]
-['#2', 'loco', 7.64]
-['#7', 'fantasma', 7.41]
-['#8', 'medium', 6.94]
-['#4', 'hermano', 6.81]
-['#5', 'duelo', 5.76]
-['#3', 'familia', 4.88]
-['#6', 'divorcio', 1.67]
+---------------------------

game.py

@@ -1,40 +1,40 @@
-"""
-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.
-"""
+# """
+# 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 json
 import random
@@ -55,9 +55,6 @@ warnings.filterwarnings(action="ignore", category=UserWarning, module="gensim")
 # Define the class Semantrix
 class Semantrix:
 
-    # Create empty KeyedVectors model with predefined size where the embeddings will be stored
-    model = KeyedVectors(768)
-
     # Define the paths for the configuration files and the data
     config_file_path = "config/lang.json"
     secret_file_path = "config/secret.json"
@@ -85,33 +82,23 @@ class Semantrix:
         # Set the model type
         self.model_type = model_type
 
-        # Load word2vec model if needed
-        if self.model_type == "word2vec":
-            if self.lang == 1:
-                self.model = KeyedVectors.load(
-                    "config/w2v_models/eng_w2v_model", mmap="r"
-                )
-                self.Config = self.DictWrapper(self.Config_full["ENG"]["Game"])
-                self.secret_dict = self.secret["ENG"]
-            else:
-                self.model = KeyedVectors.load(
-                    "config/w2v_models/esp_w2v_model", mmap="r"
-                )
-                self.Config = self.DictWrapper(self.Config_full["SPA"]["Game"])
-                self.secret_dict = self.secret["SPA"]
-        else:
-            self.model_st = SentenceTransformer(
-                "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
-            )
-
-        # Set the configuration variables depending on the language
         if self.lang == 1:
+            self.model = KeyedVectors.load("config/w2v_models/eng_w2v_model", mmap="r")
             self.Config = self.DictWrapper(self.Config_full["ENG"]["Game"])
             self.secret_dict = self.secret["ENG"]
         else:
+            self.model = KeyedVectors.load("config/w2v_models/esp_w2v_model", mmap="r")
             self.Config = self.DictWrapper(self.Config_full["SPA"]["Game"])
             self.secret_dict = self.secret["SPA"]
 
+        # Create empty KeyedVectors model with predefined size where the embeddings will be stored if Sentence Transformer used
+        if self.model_type == "SentenceTransformer":
+            self.model_trans = KeyedVectors(768)
+
+        self.model_st = SentenceTransformer(
+            "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
+        )
+
         # Create the ranking file
         with open(self.data_path + "ranking.txt", "w+") as file:
             file.write("---------------------------")
@@ -137,12 +124,11 @@ class Semantrix:
         self.scores = [10]
 
         # Store the embedding of the secret word in the embeddings dictionary
-        if self.secret not in self.model.key_to_index.keys():
-
+        if self.model_type == "SentenceTransformer":
             # Add the secret word to the KeyedVectors model if the model type is SentenceTransformer
             # If the model type is word2vec, the secret word is already in the model
-            if self.model_type == "SentenceTransformer":
-                self.model.add_vector(
+            if self.secret not in self.model_trans.key_to_index.keys():
+                self.model_trans.add_vector(
                     self.secret,
                     self.model_st.encode(self.secret, convert_to_tensor=True).tolist(),
                 )
@@ -206,31 +192,40 @@ class Semantrix:
 
         # Check if the word is in the model already
         if word not in self.model.key_to_index.keys():
-            # Add the word to the KeyedVectors model if the model type is SentenceTransformer
-            if self.model_type == "SentenceTransformer":
-                self.model.add_vector(
-                    word, self.model_st.encode(word, convert_to_tensor=True).tolist()
-                )
-            else:
-                # If the word is not in the model when using word2vec, remove it from the words list and provide feedback
-                self.words.pop(len(self.words) - 1)
-                feedback = (
-                    "I don't know that word. Try again."
-                    if self.lang == 1
-                    else "No conozco esa palabra. Inténtalo de nuevo."
-                )
-                feedback += (
-                    "[rank]" + open(self.data_path + "ranking.txt", "r").read()
-                    if len(self.words) > 1
-                    else "\n\n"
-                )
-                return feedback
+            # 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 again."
+                if self.lang == 1
+                else "No conozco esa palabra. Inténtalo de nuevo."
+            )
+            feedback += (
+                "[rank]" + open(self.data_path + "ranking.txt", "r").read()
+                if len(self.words) > 1
+                else "\n\n"
+            )
+            return feedback
+
+        # Add the word to the KeyedVectors model if the model type is SentenceTransformer and the word is not already in the model
+        if (
+            self.model_type == "SentenceTransformer"
+            and word not in self.model_trans.key_to_index.keys()
+        ):
+            self.model_trans.add_vector(
+                word, self.model_st.encode(word, convert_to_tensor=True).tolist()
+            )
 
         # Calculate the score of the word, apply logarithmic scaling, interpolate the score to a range from 0 to 10, and round it to two decimal places
+        if self.model_type == "word2vec":
+            similarity = self.model.similarity(self.secret, word)
+        else:
+            similarity = self.model_trans.similarity(self.secret, word)
+
+        log_similarity = np.log10((similarity if similarity > 0 else 0) * 10)
         score = round(
             np.interp(
-                np.log(self.model.similarity(self.secret, word) * 10),
-                [0, np.log(10)],
+                log_similarity,
+                [0, np.log10(10)],
                 [0, 10],
             ),
             2,

hints.py

@@ -1,36 +1,36 @@
-"""
-This module provides functions to generate dynamic hints and curiosities about a secret word using llms.
+# """
+# 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).
+# 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.
+#     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.
-"""
+#     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