Add hybrid model method and languages

.gitattributes

@@ -33,3 +33,6 @@ 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

app.py

@@ -1,28 +1,31 @@
 import gradio as gr
 import json
-from game import Semantrix
+from game_word2vec import Semantrix as semantrix_word2vec
+from game import Semantrix as semantrix_sentence_transformers
 
 
-config_file_path = "config/lang.json"
-
+# config_file_path = "config/lang.json"
+config_file_path = "/home/user/Research/semantrix/config/lang.json"
 
 
 with open(config_file_path, "r") as file:
     Config_full = json.load(file)
 
-lang = 0
+lang_conf = 0
 
-if lang == 0:
-    Config = Config_full["SPA"]["Game"]
-elif lang == 1:
+
+if lang_conf == 1:
     Config = Config_full["ENG"]["Game"]
+    Menu = Config_full["ENG"]["Menu"]
 else:
     Config = Config_full["SPA"]["Game"]
+    Menu = Config_full["SPA"]["Menu"]
+
 
 def convert_to_markdown_centered(text):
     # Separar el texto de último intento y el historial
-    lines = text.strip().split('\n')
-    
+    lines = text.strip().split("\n")
+
     if not lines:
         return ""
 
@@ -31,14 +34,13 @@ def convert_to_markdown_centered(text):
     # Crear el formato Markdown
     markdown = '<div align="center">\n\n'
 
-    
     # Crear la tabla de historial
-    markdown += "## Mejores intentos\n"
+    markdown += "## " + Menu["Best_tries"] + "\n"
     markdown += "<table>\n"
     markdown += "  <tr>\n"
-    markdown += "    <th>Ranking</th>\n"
-    markdown += "    <th>Palabra</th>\n"
-    markdown += "    <th>Puntuación</th>\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:
@@ -53,177 +55,215 @@ def convert_to_markdown_centered(text):
 
     # Formatear el último intento
     last_items = eval(last_attempt)
-    markdown += f"## Último Intento\n"
-    markdown += f"**{last_items[0]}:** {last_items[1]} - Score: {last_items[2]}\n\n"
+    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() as demo:
     state = gr.State(-1)
     difficulty = gr.State(-1)
     hint = gr.State(False)
-    hint_path = "config/hint.png"
-    game = Semantrix()
-
+    logo_path = "config/logo.png"
+    logo_win_path = "config/logo_win.gif"
 
-    
+    game = semantrix_sentence_transformers()
 
-    gr.Markdown(
+    header = gr.Markdown(
         """
-    <p style="text-align:center"> SEMANTRIX: EL JUEGO DE LAS PALABRAS </p>
+    <p style="text-align:center"> """
+        + Menu["Header"]
+        + """ </p>
     """
     )
 
-        
+    def reset(difficulty, lang, model):
+        global Config, game, Menu
+        language = 1 if lang == "English" else 0
+
+        if model == "Word2Vec":
+            game = semantrix_word2vec(language)
+        else:
+            game = semantrix_sentence_transformers(language)
+
+        if language == 1:
+            Config = Config_full["ENG"]["Game"]
+            Menu = Config_full["ENG"]["Menu"]
+        else:
+            Config = Config_full["SPA"]["Game"]
+            Menu = Config_full["SPA"]["Menu"]
 
-    def reset(difficulty):
         game.prepare_game(difficulty)
         output = [
-                    -1,
-                    gr.Textbox(visible=False),
-                    gr.Textbox(visible=False),
-                    gr.Image(hint_path,visible=True,interactive=False),
-                    gr.Button("Empezar",visible=True,variant="secondary"),
-                    gr.Radio(visible=False),
-                    gr.Textbox(visible=False),
-                    gr.Button(visible=False)
-
-                    ]
+            -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>
+                    """
+            ),
+        ]
 
         return output
 
-    def change(state,inp):
+    def change(state, inp):
 
         state = state + 1
-        return [state,inp]
+        return [state, inp]
 
-    def update(state, radio,inp,hint):
+    def update(state, radio, inp, hint):
         global difficulty
         dif_state = 4
         output = [state]
-        
+
         state_int = state
 
         if state_int == -1:
             output.extend(
-            [
-                gr.Button("Empezar", visible=True),
-                gr.Radio(label="", visible=False),
-                gr.Textbox(Config[list(Config.keys())[state_int]], visible=False, label=""),
-                gr.Button("Rendirse", visible=False),
-                gr.Textbox(visible=False),
-                gr.Image(interactive=False, visible=True),
-                gr.Textbox(visible=False),
-                gr.Button(visible=False),
-                gr.Markdown(visible=False),  
-            ]
-            )  
-
-        if state_int == 1:
+                [
+                    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),
+                ]
+            )
+
+        elif state_int == 1:
             output.extend(
-            [
-                gr.Button("Si", visible=False),
-                gr.Radio(["SÍ", "NO"], label="", visible=True),
-                gr.Textbox(Config[list(Config.keys())[state_int]], visible=True, label=""),
-                gr.Button("Rendirse", 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),
+                    gr.Radio([Menu["Yes"], Menu["No"]], 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),
+                ]
             )
         elif state_int == 2:
-            if radio == "NO":
+            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("Rendirse", 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),
-                    ]
-                
+                ]
+
             else:
                 output.extend(
                     [
-                    gr.Button("Siguiente", visible=True), 
-                    gr.Radio(visible=False),
-                    gr.Textbox(Config[list(Config.keys())[state_int]], visible=True, label=""),
-                    gr.Button("Rendirse", visible=False),
+                        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),
+                    ]
+                )
+        elif state_int == dif_state:
+            output.extend(
+                [
+                    gr.Button(Menu["Next"], visible=False),
+                    gr.Radio(
+                        [Menu["Easy"], Menu["Normal"], Menu["Hard"], Menu["Expert"]],
+                        visible=True,
+                    ),
+                    gr.Textbox(
+                        Config[list(Config.keys())[state_int]], visible=True, label=""
+                    ),
+                    gr.Button(Menu["Give_up"], visible=False),
                     gr.Textbox(visible=False),
                     gr.Image(interactive=False, visible=False),
                     gr.Textbox(visible=False),
                     gr.Button(visible=False),
                     gr.Markdown(visible=False),
-                    ]
-                )
-        elif state_int == dif_state:
-            output.extend(
-            [
-                gr.Button("Siguiente", visible=False),
-                gr.Radio(["Fácil", "Normal", "Difícil", "Experto"], visible=True),
-                gr.Textbox(Config[list(Config.keys())[state_int]], visible=True, label=""),
-                gr.Button("Rendirse", visible=False),
-                gr.Textbox(visible=False),
-                gr.Image(interactive=False, visible=False),
-                gr.Textbox(visible=False),
-                gr.Button(visible=False),
-                gr.Markdown(visible=False),
-            ]
+                ]
             )
         elif state_int == dif_state + 1:
-            if radio == "Fácil":
+            if radio == Menu["Easy"]:
                 difficulty = 1
-            elif radio == "Normal":
+            elif radio == Menu["Normal"]:
                 difficulty = 2
-            elif radio == "Dificil":
+            elif radio == Menu["Hard"]:
                 difficulty = 3
             else:
                 difficulty = 4
 
-            
-
             output.extend(
-            [
-                gr.Button("Empezar", visible=True, variant="primary"), 
-                gr.Radio(visible=False),
-                gr.Textbox(Config[list(Config.keys())[state_int]], visible=True, label=""),
-                gr.Button("Rendirse", 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(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),
+                ]
             )
-            
+
         elif state_int == dif_state + 2:
 
             game.prepare_game(difficulty)
 
             # feed = game.play_game(inp)
             output.extend(
-            [
-                gr.Button("Enviar", visible=True, variant="primary"),
-                gr.Radio(label="", visible=False),
-                gr.Textbox( visible=False, label=""),
-                gr.Button(visible=True,variant='stop'),
-                gr.Textbox(value="",visible=True,placeholder="Nueva palabra"),
-                gr.Image(interactive=False, visible=False),
-                gr.Textbox(visible=False),
-                gr.Button(visible=False),
-                gr.Markdown(visible=False),
-            ]
+                [
+                    gr.Button(Menu["Send"], visible=True, variant="primary"),
+                    gr.Radio(label="", visible=False),
+                    gr.Textbox(visible=False, label=""),
+                    gr.Button(visible=True, variant="stop"),
+                    gr.Textbox(value="", visible=True, placeholder=Menu["New_word"]),
+                    gr.Image(interactive=False, visible=False),
+                    gr.Textbox(visible=False),
+                    gr.Button(visible=False),
+                    gr.Markdown(visible=False),
+                ]
             )
         elif state_int > dif_state + 2:
             feed = game.play_game(inp)
@@ -232,86 +272,136 @@ with gr.Blocks() as demo:
                 ranking_md = convert_to_markdown_centered(feedback_trim[1])
             feedback = feedback_trim[0].split("[hint]")
             win = feedback_trim[0].split("[win]")
+            lose = feedback_trim[0].split("[lose]")
             if len(feedback) > 1:
                 hint = True
             else:
                 hint = False
-                
-            if len(win) > 1:
-                won = True
+
+            if len(win) > 1 or len(lose) > 1:
+                won = True if len(win) > 1 else False
                 curiosity = game.curiosity()
                 output.extend(
-                [
-                    gr.Button("Enviar", visible=False, variant="primary"),
-                    gr.Radio(label="", visible=False),
-                    gr.Textbox(win[1], visible=True, label=""),
-                    gr.Button(visible=False,variant='stop'),
-                    gr.Textbox(value="",visible=False,placeholder="Nueva palabra"),
-                    gr.Image(hint_path,interactive=False, visible=True),
-                    gr.Textbox(curiosity, visible=True, label="Curiosidad"),
-                    gr.Button(visible=True),
-                    gr.Markdown(visible=False),
-                ]
-                )  
+                    [
+                        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(visible=True),
+                        gr.Markdown(visible=False),
+                    ]
+                )
                 return output
 
             output.extend(
-            [
-                gr.Button("Enviar", visible=True, variant="primary"),
-                gr.Radio(label="", visible=False),
-                gr.Textbox(feedback[0], visible=True, label=""),
-                gr.Button(visible=True,variant='stop'),
-                gr.Textbox(value="",visible=True,placeholder="Nueva palabra"),
-                gr.Image(hint_path,interactive=False, visible=False),
-                gr.Textbox(feedback[1] if hint else "", visible=hint, label="Pista"),
-                gr.Button(visible=False),
-                gr.Markdown(ranking_md, visible=True),
-            ]
-            )  
-
+                [
+                    gr.Button(Menu["Send"], visible=True, variant="primary"),
+                    gr.Radio(label="", visible=False),
+                    gr.Textbox(feedback[0], 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(
+                        feedback[1] if hint else "", visible=hint, label="Pista"
+                    ),
+                    gr.Button(visible=False),
+                    gr.Markdown(ranking_md, visible=True),
+                ]
+            )
 
         else:
             output.extend(
-            [
-                gr.Button("Siguiente", 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(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),
+                ]
             )
         return output
-        
-    img = gr.Image(hint_path,height=430,interactive=False, visible=True)
+
+    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
-        )
+        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("Empezar")
+        inp = gr.Textbox(visible=False, interactive=True, label="")
+        but = gr.Button(Menu["Start"])
         give_up = gr.Button("Pista", visible=False)
-        reload = gr.Button("Volver a jugar", visible=False)
-
-    inp.submit(change, inputs=[state,inp], outputs=[state,inp])
-    but.click(change, inputs=[state,inp], outputs=[state,inp])
-    give_up.click(change, inputs=[state,gr.Textbox("give_up",visible=False,interactive=True,label="")], outputs=[state,inp])
-    reload.click(reset,inputs=difficulty,outputs=[state,out,inp,img, but, radio,hint_out,reload])
-    radio.input(change, inputs=[state,inp], outputs=[state,inp])
-    demo.load(reset,inputs=difficulty,outputs=[state,out,inp,img, but, radio,hint_out,reload])
-
-    # out.change(button_name, inputs=radio, outputs=[but, radio, out])
-    
-    state.change(update, inputs=[state, radio,inp,hint], outputs=[state, but, radio, out, give_up, inp, img, hint_out, reload,ranking])
+        reload = gr.Button(Menu["Play_again"], visible=False)
+
+    with gr.Accordion("Configuración/Settings", open=False):
+        with gr.Row():
+            model = (
+                gr.Dropdown(
+                    ["Sentence Transformers", "Word2Vec"],
+                    value="Sentence Transformers",
+                    label="Embedding Model",
+                ),
+            )
+            lang = (
+                gr.Dropdown(
+                    ["Español", "English"], value="Español", label="Idioma/Language"
+                ),
+            )
+
+    inp.submit(change, inputs=[state, inp], outputs=[state, inp])
+    but.click(change, inputs=[state, inp], outputs=[state, inp])
+    give_up.click(
+        change,
+        inputs=[
+            state,
+            gr.Textbox("give_up", visible=False, interactive=True, label=""),
+        ],
+        outputs=[state, inp],
+    )
+    radio.input(change, inputs=[state, inp], outputs=[state, inp])
+
+    reload.click(
+        reset,
+        inputs=[difficulty, lang[0], model[0]],
+        outputs=[state, out, inp, img, but, radio, hint_out, reload, header],
+    )
+    demo.load(
+        reset,
+        inputs=[difficulty, lang[0], model[0]],
+        outputs=[state, out, inp, img, but, radio, hint_out, reload, header],
+    )
+    lang[0].select(
+        reset,
+        inputs=[difficulty, lang[0], model[0]],
+        outputs=[state, out, inp, img, but, radio, hint_out, reload, header],
+    )
+    model[0].select(
+        reset,
+        inputs=[difficulty, lang[0], model[0]],
+        outputs=[state, out, inp, img, but, radio, hint_out, reload, header],
+    )
+
+    state.change(
+        update,
+        inputs=[state, radio, inp, hint],
+        outputs=[state, but, radio, out, give_up, inp, img, hint_out, reload, ranking],
+    )
+
 if __name__ == "__main__":
     demo.launch()

app_trans.py

@@ -0,0 +1,317 @@
+import gradio as gr
+import json
+from game import Semantrix
+
+
+config_file_path = "config/lang.json"
+
+
+
+with open(config_file_path, "r") as file:
+    Config_full = json.load(file)
+
+lang = 0
+
+if lang == 0:
+    Config = Config_full["SPA"]["Game"]
+elif lang == 1:
+    Config = Config_full["ENG"]["Game"]
+else:
+    Config = Config_full["SPA"]["Game"]
+
+def convert_to_markdown_centered(text):
+    # Separar el texto de último intento y el historial
+    lines = text.strip().split('\n')
+    
+    if not lines:
+        return ""
+
+    last_attempt = lines[0]
+    history_attempts = lines[2:12]
+    # Crear el formato Markdown
+    markdown = '<div align="center">\n\n'
+
+    
+    # Crear la tabla de historial
+    markdown += "## Mejores intentos\n"
+    markdown += "<table>\n"
+    markdown += "  <tr>\n"
+    markdown += "    <th>Ranking</th>\n"
+    markdown += "    <th>Palabra</th>\n"
+    markdown += "    <th>Puntuación</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"
+
+    # Formatear el último intento
+    last_items = eval(last_attempt)
+    markdown += f"## Último Intento\n"
+    markdown += f"**{last_items[0]}:** {last_items[1]} - Score: {last_items[2]}\n\n"
+    markdown += "---\n\n"
+
+
+    markdown += "</div>"
+
+    return markdown
+
+with gr.Blocks() as demo:
+    state = gr.State(-1)
+    difficulty = gr.State(-1)
+    hint = gr.State(False)
+    hint_path = "config/hint.png"
+    game = Semantrix()
+
+
+    
+
+    gr.Markdown(
+        """
+    <p style="text-align:center"> SEMANTRIX: EL JUEGO DE LAS PALABRAS </p>
+    """
+    )
+
+        
+
+    def reset(difficulty):
+        game.prepare_game(difficulty)
+        output = [
+                    -1,
+                    gr.Textbox(visible=False),
+                    gr.Textbox(visible=False),
+                    gr.Image(hint_path,visible=True,interactive=False),
+                    gr.Button("Empezar",visible=True,variant="secondary"),
+                    gr.Radio(visible=False),
+                    gr.Textbox(visible=False),
+                    gr.Button(visible=False)
+
+                    ]
+
+        return output
+
+    def change(state,inp):
+
+        state = state + 1
+        return [state,inp]
+
+    def update(state, radio,inp,hint):
+        global difficulty
+        dif_state = 4
+        output = [state]
+        
+        state_int = state
+
+        if state_int == -1:
+            output.extend(
+            [
+                gr.Button("Empezar", visible=True),
+                gr.Radio(label="", visible=False),
+                gr.Textbox(Config[list(Config.keys())[state_int]], visible=False, label=""),
+                gr.Button("Rendirse", visible=False),
+                gr.Textbox(visible=False),
+                gr.Image(interactive=False, visible=True),
+                gr.Textbox(visible=False),
+                gr.Button(visible=False),
+                gr.Markdown(visible=False),  
+            ]
+            )  
+
+        if state_int == 1:
+            output.extend(
+            [
+                gr.Button("Si", visible=False),
+                gr.Radio(["SÍ", "NO"], label="", visible=True),
+                gr.Textbox(Config[list(Config.keys())[state_int]], visible=True, label=""),
+                gr.Button("Rendirse", visible=False),
+                gr.Textbox(visible=False),
+                gr.Image(interactive=False, visible=False),
+                gr.Textbox(visible=False),
+                gr.Button(visible=False),
+                gr.Markdown(visible=False),
+            ]
+            )
+        elif state_int == 2:
+            if radio == "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("Rendirse", visible=False),
+                    gr.Textbox(visible=False),
+                    gr.Image(interactive=False, visible=False),
+                    gr.Textbox(visible=False),
+                    gr.Button(visible=False),
+                    gr.Markdown(visible=False),
+                    ]
+                
+            else:
+                output.extend(
+                    [
+                    gr.Button("Siguiente", visible=True), 
+                    gr.Radio(visible=False),
+                    gr.Textbox(Config[list(Config.keys())[state_int]], visible=True, label=""),
+                    gr.Button("Rendirse", visible=False),
+                    gr.Textbox(visible=False),
+                    gr.Image(interactive=False, visible=False),
+                    gr.Textbox(visible=False),
+                    gr.Button(visible=False),
+                    gr.Markdown(visible=False),
+                    ]
+                )
+        elif state_int == dif_state:
+            output.extend(
+            [
+                gr.Button("Siguiente", visible=False),
+                gr.Radio(["Fácil", "Normal", "Difícil", "Experto"], visible=True),
+                gr.Textbox(Config[list(Config.keys())[state_int]], visible=True, label=""),
+                gr.Button("Rendirse", visible=False),
+                gr.Textbox(visible=False),
+                gr.Image(interactive=False, visible=False),
+                gr.Textbox(visible=False),
+                gr.Button(visible=False),
+                gr.Markdown(visible=False),
+            ]
+            )
+        elif state_int == dif_state + 1:
+            if radio == "Fácil":
+                difficulty = 1
+            elif radio == "Normal":
+                difficulty = 2
+            elif radio == "Dificil":
+                difficulty = 3
+            else:
+                difficulty = 4
+
+            
+
+            output.extend(
+            [
+                gr.Button("Empezar", visible=True, variant="primary"), 
+                gr.Radio(visible=False),
+                gr.Textbox(Config[list(Config.keys())[state_int]], visible=True, label=""),
+                gr.Button("Rendirse", visible=False),
+                gr.Textbox(visible=False),
+                gr.Image(interactive=False, visible=False),
+                gr.Textbox(visible=False),
+                gr.Button(visible=False),
+                gr.Markdown(visible=False),
+
+            ]
+            )
+            
+        elif state_int == dif_state + 2:
+
+            game.prepare_game(difficulty)
+
+            # feed = game.play_game(inp)
+            output.extend(
+            [
+                gr.Button("Enviar", visible=True, variant="primary"),
+                gr.Radio(label="", visible=False),
+                gr.Textbox( visible=False, label=""),
+                gr.Button(visible=True,variant='stop'),
+                gr.Textbox(value="",visible=True,placeholder="Nueva palabra"),
+                gr.Image(interactive=False, visible=False),
+                gr.Textbox(visible=False),
+                gr.Button(visible=False),
+                gr.Markdown(visible=False),
+            ]
+            )
+        elif state_int > dif_state + 2:
+            feed = game.play_game(inp)
+            feedback_trim = feed.split("[rank]")
+            if len(feedback_trim) > 1:
+                ranking_md = convert_to_markdown_centered(feedback_trim[1])
+            feedback = feedback_trim[0].split("[hint]")
+            win = feedback_trim[0].split("[win]")
+            if len(feedback) > 1:
+                hint = True
+            else:
+                hint = False
+                
+            if len(win) > 1:
+                won = True
+                curiosity = game.curiosity()
+                output.extend(
+                [
+                    gr.Button("Enviar", visible=False, variant="primary"),
+                    gr.Radio(label="", visible=False),
+                    gr.Textbox(win[1], visible=True, label=""),
+                    gr.Button(visible=False,variant='stop'),
+                    gr.Textbox(value="",visible=False,placeholder="Nueva palabra"),
+                    gr.Image(hint_path,interactive=False, visible=True),
+                    gr.Textbox(curiosity, visible=True, label="Curiosidad"),
+                    gr.Button(visible=True),
+                    gr.Markdown(visible=False),
+                ]
+                )  
+                return output
+
+            output.extend(
+            [
+                gr.Button("Enviar", visible=True, variant="primary"),
+                gr.Radio(label="", visible=False),
+                gr.Textbox(feedback[0], visible=True, label=""),
+                gr.Button(visible=True,variant='stop'),
+                gr.Textbox(value="",visible=True,placeholder="Nueva palabra"),
+                gr.Image(hint_path,interactive=False, visible=False),
+                gr.Textbox(feedback[1] if hint else "", visible=hint, label="Pista"),
+                gr.Button(visible=False),
+                gr.Markdown(ranking_md, visible=True),
+            ]
+            )  
+
+
+        else:
+            output.extend(
+            [
+                gr.Button("Siguiente", 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),
+            ]
+            )
+        return output
+        
+    img = gr.Image(hint_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("Empezar")
+        give_up = gr.Button("Pista", visible=False)
+        reload = gr.Button("Volver a jugar", visible=False)
+
+    inp.submit(change, inputs=[state,inp], outputs=[state,inp])
+    but.click(change, inputs=[state,inp], outputs=[state,inp])
+    give_up.click(change, inputs=[state,gr.Textbox("give_up",visible=False,interactive=True,label="")], outputs=[state,inp])
+    reload.click(reset,inputs=difficulty,outputs=[state,out,inp,img, but, radio,hint_out,reload])
+    radio.input(change, inputs=[state,inp], outputs=[state,inp])
+    demo.load(reset,inputs=difficulty,outputs=[state,out,inp,img, but, radio,hint_out,reload])
+
+    # out.change(button_name, inputs=radio, outputs=[but, radio, out])
+    
+    state.change(update, inputs=[state, radio,inp,hint], outputs=[state, but, radio, out, give_up, inp, img, hint_out, reload,ranking])
+if __name__ == "__main__":
+    demo.launch()

config/lang.json

@@ -52,6 +52,28 @@
             "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": {
@@ -62,7 +84,7 @@
             "Rules": "Each word you propose will receive a semantic score between 0 and 10. A high score means you're very close to guessing the secret word.\n\nIf I see you're a bit lost, I'll be here to give you hints to help you get closer to the secret word.\n\nAs extra help, I'll show a ranking of all the words you've suggested, ordered by their score. This way, you can have a better idea of how close they are and which words work best.\n\nYou'll be the winner when you correctly guess the secret word. Don't give up, it's within your reach!",
             "Difficulty_presentation_Full": "In this exciting semantic guessing challenge, you can choose how big you want the challenge to be. Here are the difficulty levels:\n\n- Easy: Obvious clues for quick guessing. Ideal for beginners.\n\n- Normal: Clues only when you're very lost. An intermediate challenge.\n\n- Hard: Minimal help and complex words. For sharp thinkers.\n\n- Expert: No clues and difficult words. For semantic champions.\n\nRemember, whether you win or lose, each level is designed to make you enjoy and improve your guessing and word comprehension skills. Choose your level and start playing!",
             "Difficulty": "Choose your difficulty level",
-            "Begin": "\n\nTurn 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!",
+            "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: ",
@@ -108,6 +130,28 @@
             "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

@@ -105,7 +105,7 @@
             "nose",
             "wood",
             "leg",
-            "cars",
+            "car",
             "hair",
             "key",
             "stewardess",
@@ -626,7 +626,7 @@
             "nariz",
             "madera",
             "pierna",
-            "autos",
+            "coche",
             "cabello",
             "llave",
             "azafata",

data/ranking.txt

@@ -1 +1,24 @@
----------------------------
+['#22', 'ring', 2.82]
+---------------------------
+['#10', 'prado', 5.47]
+['#6', 'lugar', 5.35]
+['#15', 'robar', 5.31]
+['#7', 'campo', 5.18]
+['#14', 'robo', 5.02]
+['#2', 'loco', 4.74]
+['#21', 'lucha', 4.65]
+['#18', 'palabra', 4.39]
+['#3', 'persona', 4.33]
+['#1', 'amigo', 4.27]
+['#19', 'dispositivo', 4.25]
+['#8', 'habitación', 4.19]
+['#13', 'policía', 4.1]
+['#12', 'policia', 3.57]
+['#17', 'invento', 3.54]
+['#16', 'niño', 3.44]
+['#9', 'personal', 3.18]
+['#20', 'pelea', 3.12]
+['#22', 'ring', 2.82]
+['#4', 'imbecil', 2.81]
+['#11', 'vaca', 2.13]
+['#5', 'psicólogo', 2.05]

display.py

@@ -1,192 +0,0 @@
-# %%
-import asyncio
-import pickle as pk
-import time
-import warnings
-
-import matplotlib as mpl
-import matplotlib.pyplot as plt
-import mpl_toolkits.mplot3d.art3d as art3d
-import numpy as np
-import torch
-from matplotlib import cm
-from matplotlib.animation import FuncAnimation
-from matplotlib.gridspec import GridSpec
-from matplotlib.patches import Circle, PathPatch
-from mpl_toolkits.mplot3d import Axes3D, axes3d
-from sklearn.decomposition import PCA
-
-warnings.filterwarnings("ignore", category=UserWarning)
-
-# file_path = "word_embeddings_mpnet.pth"
-# embeddings_dict = torch.load(file_path)
-
-# # %%
-# words = list(embeddings_dict.keys())
-
-# sentences = [[word] for word in words]
-
-# vectors = list(embeddings_dict.values())
-# vectors_list = []
-# for item in vectors:
-#     vectors_list.append(item.tolist())
-
-# vector_list = vectors_list[:10]
-# # %%
-# # pca = PCA(n_components=3)
-# # pca = pca.fit(vectors_list)
-# # pk.dump(pca, open("pca_mpnet.pkl", "wb"))
-# score = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
-
-
-# %%
-def display_words(words, vector_list, score, bold):
-    # %%
-    plt.ioff()
-    fig = plt.figure()
-
-    ax = fig.add_subplot(111, projection="3d")
-    plt.rcParams["image.cmap"] = "magma"
-    colormap = cm.get_cmap("magma")  # You can choose any colormap you like
-
-    # Normalize the float values to the range [0, 1]
-    score = np.array(score)
-    norm = plt.Normalize(0, 10)  # type: ignore
-    colors = colormap(norm(score))
-    ax.xaxis.pane.fill = False
-    ax.yaxis.pane.fill = False
-    ax.w_zaxis.set_pane_color(
-        (0.87, 0.91, 0.94, 0.8)
-    )  # Set the z-axis face color (gray)
-    ax.xaxis.line.set_color((1.0, 1.0, 1.0, 0.0))  # Transparent x-axis line
-    ax.yaxis.line.set_color((1.0, 1.0, 1.0, 0.0))  # Transparent y-axis line
-    ax.zaxis.line.set_color((1.0, 1.0, 1.0, 0.0))
-
-    # Turn off axis labels
-    ax.set_xticks([])
-    ax.set_yticks([])
-    ax.set_zticks([])
-    ax.grid(False)
-    # %%
-    data_pca = vector_list
-
-    if len(data_pca) > 1:
-        # for i in range(len(data_pca) - 1):
-        #     data = np.append(
-        #         data_pca,
-        #         [norm_distance(data_pca[0], data_pca[i + 1], score[i + 1])],
-        #         axis=0,
-        #     )
-
-        # Create copies of the zero-th element of data_pca
-        data_pca0 = np.repeat(data_pca[0][None, :], len(data_pca) - 1, axis=0)
-
-        # Use these arrays to construct the calls to norm_distance_v
-        data = norm_distance_v(data_pca0, data_pca[1:], score[1:])
-
-    else:
-        data = data_pca.transpose()
-
-    (
-        x,
-        y,
-        z,
-    ) = data
-
-    center_x = x[0]
-    center_y = y[0]
-    center_z = z[0]
-    # %%
-    ax.autoscale(enable=True, axis="both", tight=True)
-    # if bold == -1:
-    #     k = len(words) - 1
-    # else:
-    #     k = repeated
-    for i, word in enumerate(words):
-        if i == bold:
-            fontsize = "large"
-            fontweight = "demibold"
-        else:
-            fontsize = "medium"
-            fontweight = "normal"
-
-        ax.text(
-            x[i],
-            y[i],
-            z[i] + 0.05,
-            word,
-            fontsize=fontsize,
-            fontweight=fontweight,
-            alpha=1,
-        )
-    # ax.text(
-    #     x[0],
-    #     y[0],
-    #     z[0] + 0.05,
-    #     words[0],
-    #     fontsize="medium",
-    #     fontweight="normal",
-    #     alpha=1,
-    # )
-    ax.scatter(x, y, z, c="black", marker="o", s=75, cmap="magma", vmin=0, vmax=10)
-    scatter = ax.scatter(
-        x,
-        y,
-        z,
-        marker="o",
-        s=70,
-        c=colors,
-        cmap="magma",
-        vmin=0,
-        vmax=10,
-    )
-
-    # cax = fig.add_subplot(gs[1, :])  # cb = plt.colorbar(sc, cax=cax)
-    # a = fig.colorbar(
-    #     mappable=scatter,
-    #     ax=ax,
-    #     cmap="magma",
-    #     norm=mpl.colors.Normalize(vmin=0, vmax=10),
-    #     orientation="horizontal",
-    # )
-    fig.colorbar(
-        cm.ScalarMappable(norm=mpl.colors.Normalize(0, 10), cmap="magma"),
-        ax=ax,
-        orientation="horizontal",
-    )
-    # cbar.set_label("Score Values")
-
-    def update(frame):
-        distance = 0.5 * (score.max() - score.min())
-        ax.set_xlim(center_x - distance, center_x + distance)
-        ax.set_ylim(center_y - distance, center_y + distance)
-        ax.set_zlim(center_z - distance, center_z + distance)
-        ax.view_init(elev=20, azim=frame)
-
-    # %%
-
-    # Create the animation
-    frames = np.arange(0, 360, 5)
-    ani = FuncAnimation(fig, update, frames=frames, interval=120)
-
-    ani.save("3d_rotation.gif", writer="pillow", dpi=140)
-    plt.close(fig)
-
-
-# %%
-def norm_distance_v(orig, points, distances):
-    # Calculate the vector AB
-
-    AB = points - orig
-
-    # Calculate the normalized vector AB
-    Normalized_AB = AB / np.linalg.norm(AB, axis=1, keepdims=True)
-
-    # Specify the desired distance from point A
-    d = 10 - (distances.reshape(-1, 1) * 1)
-
-    # Calculate the new points C
-    C = orig + (Normalized_AB * d)
-    C = np.append([orig[0]], C, axis=0)
-
-    return np.array([C[:, 0], C[:, 1], C[:, 2]])

game.py

@@ -1,16 +1,14 @@
 # %%
 import json
-# import pickle as pk
 import random
-# import threading
 from datetime import datetime
-# import time
-# import gradio as gr
 import numpy as np
-# from display import display_words
 from gensim.models import KeyedVectors
-from pistas import curiosity, hint
-from seguimiento import calculate_moving_average, calculate_tendency_slope
+from hints import curiosity, hint
+from tracking import (
+    calculate_moving_average,
+    calculate_tendency_slope,
+)
 from sentence_transformers import SentenceTransformer
 import warnings
 
@@ -23,70 +21,60 @@ class Semantrix:
         "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
     )
 
-    
-
     config_file_path = "config/lang.json"
     secret_file_path = "config/secret.json"
     data_path = "data/"
+
     class DictWrapper:
         def __init__(self, data_dict):
             self.__dict__.update(data_dict)
 
-    def __init__(self):
+    def __init__(self, lang=0):
 
         self.embeddings_dict = {}
-        
-        
+
         with open(self.config_file_path, "r") as file:
             self.Config_full = json.load(file)
 
         with open(self.secret_file_path, "r") as file:
             self.secret = json.load(file)
 
-        self.lang = 0
+        self.lang = lang
 
-        if self.lang == 0:   
-            self.Config = self.DictWrapper(self.Config_full["SPA"]["Game"])
-            self.secret_dict = self.secret["SPA"]
-        elif self.lang == 1:
+        if self.lang == 1:
             self.Config = self.DictWrapper(self.Config_full["ENG"]["Game"])
-            secret_dict = self.secret["ENG"]
+            self.secret_dict = self.secret["ENG"]
         else:
             self.Config = self.DictWrapper(self.Config_full["SPA"]["Game"])
             self.secret_dict = self.secret["SPA"]
 
-
         with open(self.data_path + "ranking.txt", "w+") as file:
             file.write("---------------------------")
 
-# pca = pk.load(open("pca_mpnet.pkl", "rb"))
-
-# print(Config.Difficulty_presentation_Full)
-# difficulty = int(input(Config.Difficulty + ": "))
-
-    def prepare_game(self,difficulty):
-        # global secret, secret_list, words, scores, word_vect, thread, win, n, recent_hint, f_dev_avg, last_hint
+    def prepare_game(self, difficulty):
 
-        self.secret_list = self.secret_dict["basic"] if difficulty <= 2 else self.secret_dict["advanced"]
+        self.secret_list = (
+            self.secret_dict["basic"]
+            if difficulty <= 2
+            else self.secret_dict["advanced"]
+        )
 
         self.secret = self.secret_list.pop(random.randint(0, len(self.secret_list) - 1))
         self.secret = self.secret.lower()
 
-
         self.words = [self.Config.secret_word]
         self.scores = [10]
 
         if self.secret not in self.embeddings_dict.keys():
-            self.embeddings_dict[self.secret] = self.model_st.encode(self.secret, convert_to_tensor=True)
-            self.model.add_vector(self.secret, self.embeddings_dict[self.secret].tolist())
+            self.embeddings_dict[self.secret] = self.model_st.encode(
+                self.secret, convert_to_tensor=True
+            )
+            self.model.add_vector(
+                self.secret, self.embeddings_dict[self.secret].tolist()
+            )
 
         self.word_vect = [self.embeddings_dict[self.secret].tolist()]
 
-        # thread = threading.Thread(
-        #     target=display_words, args=(words, pca.transform(word_vect), scores, -1)
-        # )
-        # thread.start()
-
         self.win = False
         self.n = 0
         self.recent_hint = 0
@@ -97,8 +85,7 @@ class Semantrix:
         if self.difficulty == 1:
             self.n = 3
 
-
-    def preproc_vectors(self,repeated):
+    def preproc_vectors(self, repeated):
         ascending_indices = np.argsort(self.scores)
         descending_indices = list(ascending_indices[::-1])
         ranking_data = []
@@ -118,47 +105,41 @@ class Semantrix:
             for item in ranking_data:
                 file.write("%s\n" % item)
 
-        if len(self.words) > 11:
-            if k in descending_indices[:11]:
-                descending_indices = descending_indices[:11]
-            else:
-                descending_indices = descending_indices[:11]
-                descending_indices.append(k)
-            words_display = [self.words[i] for i in descending_indices]
-            # displayvect_display = pca.transform([word_vect[i] for i in descending_indices])
-            scores_display = [self.scores[i] for i in descending_indices]
-            bold = descending_indices.index(k)
-
-        else:
-            words_display = self.words
-            # displayvect_display = pca.transform(word_vect)
-            scores_display = self.scores
-            bold = k
-
-        return (
-            words_display,
-            # displayvect_display,
-            scores_display,
-            bold,
-        )
-
-
-        
-
+        # if len(self.words) > 11:
+        #     if k in descending_indices[:11]:
+        #         descending_indices = descending_indices[:11]
+        #     else:
+        #         descending_indices = descending_indices[:11]
+        #         descending_indices.append(k)
+        #     words_display = [self.words[i] for i in descending_indices]
+        #     # displayvect_display = pca.transform([word_vect[i] for i in descending_indices])
+        #     scores_display = [self.scores[i] for i in descending_indices]
+        #     bold = descending_indices.index(k)
+
+        # else:
+        #     words_display = self.words
+        #     # displayvect_display = pca.transform(word_vect)
+        #     scores_display = self.scores
+        #     bold = k
+
+        # return (
+        #     words_display,
+        #     # displayvect_display,
+        #     scores_display,
+        #     bold,
+        # )
 
-    def play_game(self,word):
-        # global win, n, recent_hint, f_dev_avg, last_hint, words, word_vect, scores, thread
+    def play_game(self, word):
 
         word = word.lower()
         if word == "give_up":
             text = (
-                "[win]"
-                +
-            self.Config.Feedback_9
-            + self.secret
-            + "\n\n"
-            + self.Config.Feedback_10
-        )
+                "[lose]"
+                + self.Config.Feedback_9
+                + self.secret
+                + "\n\n"
+                + self.Config.Feedback_10
+            )
             return text
 
         if word in self.words:
@@ -167,19 +148,15 @@ class Semantrix:
             repeated = -1
             self.words.append(word)
 
-        # thread.join()
-
         if word not in self.embeddings_dict.keys():
             embedding = self.model_st.encode(word, convert_to_tensor=True)
             self.embeddings_dict[word] = embedding
             self.model.add_vector(word, embedding.tolist())
 
-        if repeated == -1:
-            self.word_vect.append(self.embeddings_dict[word].tolist())
-
         score = round(self.model.similarity(self.secret, word) * 10, 2)
 
         if repeated == -1:
+            self.word_vect.append(self.embeddings_dict[word].tolist())
             self.scores.append(score)
 
         if score <= 2.5:
@@ -223,9 +200,9 @@ class Semantrix:
                         self.last_hint,
                         self.lang,
                         (
-                            self.DictWrapper(self.Config_full["SPA"]["Hint"])
-                            if self.lang == 0
-                            else self.DictWrapper(self.Config_full["ENG"]["Hint"])
+                            self.DictWrapper(self.Config_full["ENG"]["Hint"])
+                            if self.lang == 1
+                            else self.DictWrapper(self.Config_full["SPA"]["Hint"])
                         ),
                     )
                     feedback += "\n" + hint_text
@@ -234,25 +211,14 @@ class Semantrix:
             if self.recent_hint != 0:
                 self.recent_hint -= 1
 
-        (
-            words_display,
-            scores_display,
-            bold_display,
-        ) = self.preproc_vectors(repeated)
+        self.preproc_vectors(repeated)
 
-        feedback += "[rank]" + open(self.data_path + "ranking.txt", "r").read() 
+        feedback += "[rank]" + open(self.data_path + "ranking.txt", "r").read()
 
         if self.win:
             bold_display = 0
 
-        # thread = threading.Thread(
-        #     target=display_words,
-        #     args=(words_display, displayvect_display, scores_display, bold_display),
-        # )
-        # thread.start()
-
         if self.win:
-            # feedback += "\nCongratulations! You guessed the secret word."
 
             with open(self.data_path + "ranking.txt", "r") as original_file:
                 file_content = original_file.readlines()
@@ -262,11 +228,17 @@ class Semantrix:
             with open(self.data_path + "plays/" + new_file_name, "w+") as new_file:
                 new_file.writelines(file_content[2:])
 
-
         return feedback
-    
+
     def curiosity(self):
 
-        feedback = curiosity(self.secret, self.DictWrapper(self.Config_full["SPA"]["Hint"]))
-        
+        feedback = curiosity(
+            self.secret,
+            (
+                self.DictWrapper(self.Config_full["ENG"]["Hint"])
+                if self.lang == 1
+                else self.DictWrapper(self.Config_full["SPA"]["Hint"])
+            ),
+        )
+
         return feedback

game_word2vec.py

@@ -0,0 +1,250 @@
+# %%
+import json
+import random
+from datetime import datetime
+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
+import warnings
+
+warnings.filterwarnings(action="ignore", category=UserWarning, module="gensim")
+
+
+class Semantrix:
+
+    model_st = SentenceTransformer(
+        "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
+    )
+
+    config_file_path = "config/lang.json"
+
+    secret_file_path = "config/secret.json"
+
+    data_path = "data/"
+
+    class DictWrapper:
+        def __init__(self, data_dict):
+            self.__dict__.update(data_dict)
+
+    def __init__(self, lang=0):
+
+        self.lang = lang
+
+        self.embeddings_dict = {}
+
+        with open(self.config_file_path, "r") as file:
+            self.Config_full = json.load(file)
+
+        with open(self.secret_file_path, "r") as file:
+            self.secret = json.load(file)
+
+        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"]
+
+        with open(self.data_path + "ranking.txt", "w+") as file:
+            file.write("---------------------------")
+
+    def prepare_game(self, difficulty):
+
+        self.secret_list = (
+            self.secret_dict["basic"]
+            if difficulty <= 2
+            else self.secret_dict["advanced"]
+        )
+
+        self.secret = self.secret_list.pop(random.randint(0, len(self.secret_list) - 1))
+        self.secret = self.secret.lower()
+
+        self.words = [self.Config.secret_word]
+        self.scores = [10]
+
+        if self.secret not in self.embeddings_dict.keys():
+            self.embeddings_dict[self.secret] = self.model[self.secret]
+
+        self.word_vect = [self.embeddings_dict[self.secret].tolist()]
+
+        self.win = False
+        self.n = 0
+        self.recent_hint = 0
+        self.f_dev_avg = 0
+        self.last_hint = -1
+        self.difficulty = difficulty
+
+        if self.difficulty == 1:
+            self.n = 3
+
+    def preproc_vectors(self, repeated):
+        ascending_indices = np.argsort(self.scores)
+        descending_indices = list(ascending_indices[::-1])
+        ranking_data = []
+        k = len(self.words) - 1
+        if repeated != -1:
+            k = repeated
+
+        ranking_data.append(["#" + str(k), self.words[k], self.scores[k]])
+
+        ranking_data.append("---------------------------")
+        for i in descending_indices:
+            if i == 0:
+                continue
+            ranking_data.append(["#" + str(i), self.words[i], self.scores[i]])
+
+        with open(self.data_path + "ranking.txt", "w+") as file:
+            for item in ranking_data:
+                file.write("%s\n" % item)
+
+        # if len(self.words) > 11:
+        #     if k in descending_indices[:11]:
+        #         descending_indices = descending_indices[:11]
+        #     else:
+        #         descending_indices = descending_indices[:11]
+        #         descending_indices.append(k)
+        #     words_display = [self.words[i] for i in descending_indices]
+        #     scores_display = [self.scores[i] for i in descending_indices]
+        #     bold = descending_indices.index(k)
+
+        # else:
+        #     words_display = self.words
+        #     scores_display = self.scores
+        #     bold = k
+
+        # return (
+        #     words_display,
+        #     scores_display,
+        #     bold,
+        # )
+
+    def play_game(self, word):
+
+        word = word.lower()
+        if word == "give_up":
+            text = (
+                "[lose]"
+                + self.Config.Feedback_9
+                + self.secret
+                + "\n\n"
+                + self.Config.Feedback_10
+            )
+            return text
+
+        if word in self.words:
+            repeated = self.words.index(word)
+        else:
+            repeated = -1
+            self.words.append(word)
+
+        if word not in self.embeddings_dict.keys():
+            if word not in self.model.key_to_index.keys():
+                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()
+
+                return feedback
+
+            embedding = self.model[word]
+            self.embeddings_dict[word] = embedding
+
+        score = round(self.model.similarity(self.secret, word) * 10, 2)
+
+        if repeated == -1:
+            self.word_vect.append(self.embeddings_dict[word].tolist())
+            self.scores.append(score)
+
+        if score <= 2.5:
+            feedback = self.Config.Feedback_0 + str(score)
+        elif score > 2.5 and score <= 4.0:
+            feedback = self.Config.Feedback_1 + str(score)
+        elif score > 4.0 and score <= 6.0:
+            feedback = self.Config.Feedback_2 + str(score)
+        elif score > 6.0 and score <= 7.5:
+            feedback = self.Config.Feedback_3 + str(score)
+        elif score > 7.5 and score <= 8.0:
+            feedback = self.Config.Feedback_4 + str(score)
+        elif score > 8.0 and score < 10.0:
+            feedback = self.Config.Feedback_5 + str(score)
+        else:
+            self.win = True
+            feedback = "[win]" + self.Config.Feedback_8
+            self.words[0] = self.secret
+            self.words.pop(len(self.words) - 1)
+            self.word_vect.pop(len(self.word_vect) - 1)
+            self.scores.pop(len(self.scores) - 1)
+
+        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
+
+        if self.difficulty != 4:
+            mov_avg = calculate_moving_average(self.scores[1:], 5)
+
+            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 f_dev_avg[len(f_dev_avg) - 1] < 0 and self.recent_hint == 0:
+                    i = random.randint(0, len(self.Config.hint_intro) - 1)
+                    feedback += "\n\n[hint]" + self.Config.hint_intro[i]
+                    hint_text, self.n, self.last_hint = hint(
+                        self.secret,
+                        self.n,
+                        self.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
+
+        self.preproc_vectors(repeated)
+
+        feedback += "[rank]" + open(self.data_path + "ranking.txt", "r").read()
+
+        if self.win:
+            bold_display = 0
+
+        if self.win:
+
+            with open(self.data_path + "ranking.txt", "r") as original_file:
+                file_content = original_file.readlines()
+
+            new_file_name = self.secret + "_" + str(datetime.now())
+
+            with open(self.data_path + "plays/" + new_file_name, "w+") as new_file:
+                new_file.writelines(file_content[2:])
+
+        return feedback
+
+    def curiosity(self):
+
+        feedback = curiosity(
+            self.secret,
+            (
+                self.DictWrapper(self.Config_full["ENG"]["Hint"])
+                if self.lang == 1
+                else self.DictWrapper(self.Config_full["SPA"]["Hint"])
+            ),
+        )
+
+        return feedback

pistas.py → hints.py

@@ -194,7 +194,7 @@ def hint(secret, n, model, last_pista, lang, Config):
                 presence_penalty=0,
             )
             output = str(response.choices[0].message.content)
-            pista += Config.hint_4_4 + film_title + "\n" + output  # type: ignore
+            pista += Config.hint_4_4 + "\n" + output  # type: ignore
             last_pista = 4
 
     return pista, n + 1, last_pista

juego_embbedings_chat.py

@@ -1,371 +0,0 @@
-# %%
-import json
-import pickle as pk
-import random
-import threading
-from datetime import datetime
-import time
-import gradio as gr
-import numpy as np
-from display import display_words
-from gensim.models import KeyedVectors
-from pistas import curiosity, hint
-from seguimiento import calculate_moving_average, calculate_tendency_slope
-from sentence_transformers import SentenceTransformer
-
-model = KeyedVectors(768)
-model_st = SentenceTransformer(
-    "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
-)
-
-embeddings_dict = {}
-
-config_file_path = "config/lang.json"
-secret_file_path = "config/secret.json"
-
-
-class DictWrapper:
-    def __init__(self, data_dict):
-        self.__dict__.update(data_dict)
-
-
-with open(config_file_path, "r") as file:
-    Config_full = json.load(file)
-
-with open(secret_file_path, "r") as file:
-    secret = json.load(file)
-
-lang = 0
-
-if lang == 0:
-    Config = DictWrapper(Config_full["SPA"]["Game"])
-    secret_dict = secret["SPA"]
-elif lang == 1:
-    Config = DictWrapper(Config_full["ENG"]["Game"])
-    secret_dict = secret["ENG"]
-else:
-    Config = DictWrapper(Config_full["SPA"]["Game"])
-    secret_dict = secret["SPA"]
-
-
-with open("ranking.txt", "w+") as file:
-    file.write("---------------------------")
-
-pca = pk.load(open("pca_mpnet.pkl", "rb"))
-
-# print(Config.Difficulty_presentation_Full)
-# difficulty = int(input(Config.Difficulty + ": "))
-difficulty = -1
-
-def prepare_game(difficulty):
-    global secret, secret_list, words, scores, word_vect, thread, win, n, recent_hint, f_dev_avg, last_hint
-
-    secret_list = secret_dict["basic"] if difficulty <= 2 else secret_dict["advanced"]
-
-    secret = secret_list.pop(random.randint(0, len(secret_list) - 1))
-    secret = secret.lower()
-
-    words = [Config.secret_word]
-    scores = [10]
-
-    if secret not in embeddings_dict.keys():
-        embeddings_dict[secret] = model_st.encode(secret, convert_to_tensor=True)
-        model.add_vector(secret, embeddings_dict[secret].tolist())
-
-    word_vect = [embeddings_dict[secret].tolist()]
-
-    thread = threading.Thread(
-        target=display_words, args=(words, pca.transform(word_vect), scores, -1)
-    )
-    thread.start()
-
-    win = False
-    n = 0
-    recent_hint = 0
-    f_dev_avg = 0
-    last_hint = -1
-
-    if difficulty == 1:
-        n = 3
-
-
-def preproc_vectors(words, word_vect, scores, repeated):
-    ascending_indices = np.argsort(scores)
-    descending_indices = list(ascending_indices[::-1])
-    ranking_data = []
-    k = len(words) - 1
-    if repeated != -1:
-        k = repeated
-
-    ranking_data.append(["#" + str(k), words[k], scores[k]])
-
-    ranking_data.append("---------------------------")
-    for i in descending_indices:
-        if i == 0:
-            continue
-        ranking_data.append(["#" + str(i), words[i], scores[i]])
-
-    with open("ranking.txt", "w+") as file:
-        for item in ranking_data:
-            file.write("%s\n" % item)
-
-    if len(words) > 11:
-        if k in descending_indices[:11]:
-            descending_indices = descending_indices[:11]
-        else:
-            descending_indices = descending_indices[:11]
-            descending_indices.append(k)
-        words_display = [words[i] for i in descending_indices]
-        displayvect_display = pca.transform([word_vect[i] for i in descending_indices])
-        scores_display = [scores[i] for i in descending_indices]
-        bold = descending_indices.index(k)
-
-    else:
-        words_display = words
-        displayvect_display = pca.transform(word_vect)
-        scores_display = scores
-        bold = k
-
-    return (
-        words_display,
-        displayvect_display,
-        scores_display,
-        bold,
-    )
-
-
-    
-
-
-def play_game(word):
-    global win, n, recent_hint, f_dev_avg, last_hint, words, word_vect, scores, thread
-
-    word = word.lower()
-    if word == "give_up":
-        return "Game Over"
-
-    if word in words:
-        repeated = words.index(word)
-    else:
-        repeated = -1
-        words.append(word)
-
-    thread.join()
-
-    if word not in embeddings_dict.keys():
-        embedding = model_st.encode(word, convert_to_tensor=True)
-        embeddings_dict[word] = embedding
-        model.add_vector(word, embedding.tolist())
-
-    if repeated == -1:
-        word_vect.append(embeddings_dict[word].tolist())
-
-    score = round(model.similarity(secret, word) * 10, 2)
-
-    if repeated == -1:
-        scores.append(score)
-
-    if score <= 2.5:
-        feedback = Config.Feedback_0 + str(score)
-    elif score > 2.5 and score <= 4.0:
-        feedback = Config.Feedback_1 + str(score)
-    elif score > 4.0 and score <= 6.0:
-        feedback = Config.Feedback_2 + str(score)
-    elif score > 6.0 and score <= 7.5:
-        feedback = Config.Feedback_3 + str(score)
-    elif score > 7.5 and score <= 8.0:
-        feedback = Config.Feedback_4 + str(score)
-    elif score > 8.0 and score < 10.0:
-        feedback = Config.Feedback_5 + str(score)
-    else:
-        win = True
-        feedback = Config.Feedback_8
-        words[0] = secret
-        words.pop(len(words) - 1)
-        word_vect.pop(len(word_vect) - 1)
-        scores.pop(len(scores) - 1)
-
-    if score > scores[len(scores) - 2] and win == False:
-        feedback += "\n" + Config.Feedback_6
-    elif score < scores[len(scores) - 2] and win == False:
-        feedback += "\n" + Config.Feedback_7
-
-    if difficulty != 4:
-        mov_avg = calculate_moving_average(scores[1:], 5)
-
-        if len(mov_avg) > 1 and win == False:
-            f_dev = calculate_tendency_slope(mov_avg)
-            f_dev_avg = calculate_moving_average(f_dev, 3)
-            if f_dev_avg[len(f_dev_avg) - 1] < 0 and recent_hint == 0:
-                i = random.randint(0, len(Config.hint_intro) - 1)
-                feedback += "\n\n" + Config.hint_intro[i]
-                hint_text, n, last_hint = hint(
-                    secret,
-                    n,
-                    model_st,
-                    last_hint,
-                    lang,
-                    (
-                        DictWrapper(Config_full["SPA"]["Hint"])
-                        if lang == 0
-                        else DictWrapper(Config_full["ENG"]["Hint"])
-                    ),
-                )
-                feedback += "\n" + hint_text
-                recent_hint = 3
-
-        if recent_hint != 0:
-            recent_hint -= 1
-
-    (
-        words_display,
-        displayvect_display,
-        scores_display,
-        bold_display,
-    ) = preproc_vectors(words, word_vect, scores, repeated)
-
-    if win:
-        bold_display = 0
-
-    thread = threading.Thread(
-        target=display_words,
-        args=(words_display, displayvect_display, scores_display, bold_display),
-    )
-    thread.start()
-
-    if win:
-        feedback += "\nCongratulations! You guessed the secret word."
-
-    return feedback
-
-
-
-i = -1
-
-with gr.Blocks() as demo:
-    gr.Markdown(
-        """
-    <p style="text-align:center"> SEMANTRIX: JUEGO DE LA ADIVINANZA SEMÁNTICA </p>
-    """
-    )
-    lang = {
-        "Introduction_0": "Bienvenido a Semantrix, el emocionante Juego de la Adivinanza Semántica.",
-        "Introduction_1": "¿Quieres saber cómo se juega?",
-        "Rules_1": "Tu 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.",
-        "Rules_3": "Adicionalmente, Cada palabra que propongas recibirá una puntuación 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.",
-        "Rules_5": "Como 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.",
-        "Rules_6": "Serás el ganador cuando adivines correctamente la palabra secreta. ¡No desistas, lo tienes al alcance!\n\nAsí que, ¡enciende tu mente, confía en tus ideas y por sobre todo, pasa un buen rato! Este es un juego en el que cada palabra, cada puntuación y cada pista te acerca a tu victoria. ¡Mucha suerte!",
-        "Difficulty_presentation_Full": "En este emocionante desafío de adivinanza semántica, puedes elegir cuán grande quieres que sea el reto. Aquí te presento los niveles de dificultad:\n\nFácil: ¡Es hora de calentar motores! En este nivel, te daré pistas evidentes para que puedas adivinar la palabra secreta de manera más rápida. Si estás comenzando a jugar o simplemente quieres pasar un buen rato sin mucha presión, ¡este es tu nivel!\n\nNormal: Aquí es donde las cosas comienzan a ponerse interesantes. En este nivel, solo te daré pistas cuando te vea muy perdido. Es bueno para aquellos jugadores que quieren un reto, pero sin ser tan duros consigo mismos.\n\nDifícil: ¿Listo para un verdadero desafío? En este nivel, te ayudaré solo cuando te vea realmente perdido, y prepárate, porque las palabras pueden llegar a ser más complejas. Para esos pensadores agudos que les encanta una buena cabeza rompecabezas.\n\nExperto: ¿Eres un maestro de las palabras? Este es el camino menos transitado, para aquellos campeones de la semántica que buscan la pura adrenalina del reto. No te daré ninguna pista y las palabras serán complejas. Aquí es donde puedes demostrar tu verdadero poder.\n\nRecuerda, ganes o pierdas, cada nivel está diseñado para hacerte disfrutar y mejorar tus habilidades de adivinanza y comprensión de las palabras. ¡Escoge tu nivel y empieza a jugar!",
-        "Difficulty": "Elige tu nivel de dificultad",
-        "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:",
-        ],
-    }
-
-    def reset():
-        global i
-        i = -1
-        return gr.Textbox(visible=False, placeholder=lang[list(lang.keys())[0]], min_width=15),gr.Textbox(visible=False),gr.Image(interactive=False, visible=False),gr.Button("Empezar"),gr.Radio(["SÍ", "NO"], visible=False)
-    def change(radio):
-        global i
-        i = i + 1
-        if i == 2 and radio == "NO":
-            i = 7
-        #   txt=gr.Textbox(lang[list(lang.keys())[i]],visible=True,label='')
-        # else:
-        txt = gr.Textbox(lang[list(lang.keys())[i]], visible=True, label="")
-        return txt
-
-    def button_name(radio):
-        global i, difficulty
-        output = []
-        if i == 1:
-            output.extend(
-                [
-                    gr.Button("Si", visible=False),
-                    gr.Radio(["SÍ", "NO"], label="", visible=True),
-                ]
-            )
-        elif i == 2:
-            if radio == "NO":
-                output.extend(
-                    [
-                        gr.Button("Introducir", visible=True),
-                        gr.Radio(["SÍ", "NO"], visible=False),
-                    ]
-                )
-            else:
-                output.extend(
-                    [
-                        gr.Button("Siguiente", visible=True),
-                        gr.Radio(["SÍ", "NO"], visible=False),
-                    ]
-                )
-        elif i == 7:
-            output.extend(
-                [
-                    gr.Button("Siguiente", visible=False),
-                    gr.Radio(["Fácil", "Normal", "Dificil", "Experto"], visible=True),
-                ]
-            )
-        elif i == 8:
-            if radio == "Fácil":
-                difficulty = 1
-            elif radio == "Normal":
-                difficulty = 2
-            elif radio == "Dificil":
-                difficulty = 3
-            else:
-                difficulty = 4
-            output.extend(
-                [
-                    gr.Button("Empezar", visible=True),
-                    gr.Radio(["Fácil", "Normal", "Dificil", "Experto"], visible=False),
-                ]
-            )
-            print(difficulty)
-        else:
-            output.extend(
-                [
-                    gr.Button("Siguiente", visible=True),
-                    gr.Radio(["SÍ", "NO"], label="", visible=False),
-                ]
-            )
-        return output
-
-    img = gr.Image(interactive=False, visible=False)
-    out = gr.Textbox(
-        visible=False, placeholder=lang[list(lang.keys())[0]], min_width=15
-    )
-    radio = gr.Radio(["SÍ", "NO"], visible=False)
-    with gr.Row():
-        inp = gr.Textbox(visible=False)
-        but = gr.Button("Empezar")
-
-    but.click(change, inputs=radio, outputs=out)
-    radio.input(change, inputs=radio, outputs=out)
-    demo.load(reset,outputs=[out,inp,img, but, radio])
-    out.change(button_name, inputs=radio, outputs=[but, radio])
-
-
-if __name__ == "__main__":
-    demo.launch()

juego_embbedings_text_config.py

@@ -1,252 +0,0 @@
-# %%
-import json
-import pickle as pk
-import random
-import threading
-from datetime import datetime
-
-import gradio as gr
-import numpy as np
-from display import display_words
-from gensim.models import KeyedVectors
-from pistas import curiosity, hint
-from seguimiento import calculate_moving_average, calculate_tendency_slope
-from sentence_transformers import SentenceTransformer
-
-model = KeyedVectors(768)
-model_st = SentenceTransformer(
-    "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
-)
-
-embeddings_dict = {}
-
-config_file_path = "config/lang.json"
-secret_file_path = "config/secret.json"
-
-
-class DictWrapper:
-    def __init__(self, data_dict):
-        self.__dict__.update(data_dict)
-
-
-with open(config_file_path, "r") as file:
-    Config_full = json.load(file)
-
-with open(secret_file_path, "r") as file:
-    secret = json.load(file)
-
-lang = 0
-
-if lang == 0:
-    Config = DictWrapper(Config_full["SPA"]["Game"])
-    secret_dict = secret["SPA"]
-elif lang == 1:
-    Config = DictWrapper(Config_full["ENG"]["Game"])
-    secret_dict = secret["ENG"]
-else:
-    Config = DictWrapper(Config_full["SPA"]["Game"])
-    secret_dict = secret["SPA"]
-
-
-with open("ranking.txt", "w+") as file:
-    file.write("---------------------------")
-
-pca = pk.load(open("pca_mpnet.pkl", "rb"))
-
-print(Config.Difficulty_presentation_Full)
-difficulty = int(input(Config.Difficulty + ": "))
-
-secret_list = secret_dict["basic"] if difficulty <= 2 else secret_dict["advanced"]
-
-secret = secret_list.pop(random.randint(0, len(secret_list) - 1))
-secret = secret.lower()
-
-words = [Config.secret_word]
-scores = [10]
-
-if secret not in embeddings_dict.keys():
-    embeddings_dict[secret] = model_st.encode(secret, convert_to_tensor=True)
-    model.add_vector(secret, embeddings_dict[secret].tolist())
-
-word_vect = [embeddings_dict[secret].tolist()]
-
-thread = threading.Thread(
-    target=display_words, args=(words, pca.transform(word_vect), scores, -1)
-)
-thread.start()
-
-
-def preproc_vectors(words, word_vect, scores, repeated):
-    ascending_indices = np.argsort(scores)
-    descending_indices = list(ascending_indices[::-1])
-    ranking_data = []
-    k = len(words) - 1
-    if repeated != -1:
-        k = repeated
-
-    ranking_data.append(["#" + str(k), words[k], scores[k]])
-
-    ranking_data.append("---------------------------")
-    for i in descending_indices:
-        if i == 0:
-            continue
-        ranking_data.append(["#" + str(i), words[i], scores[i]])
-
-    with open("ranking.txt", "w+") as file:
-        for item in ranking_data:
-            file.write("%s\n" % item)
-
-    if len(words) > 11:
-        if k in descending_indices[:11]:
-            descending_indices = descending_indices[:11]
-        else:
-            descending_indices = descending_indices[:11]
-            descending_indices.append(k)
-        words_display = [words[i] for i in descending_indices]
-        displayvect_display = pca.transform([word_vect[i] for i in descending_indices])
-        scores_display = [scores[i] for i in descending_indices]
-        bold = descending_indices.index(k)
-
-    else:
-        words_display = words
-        displayvect_display = pca.transform(word_vect)
-        scores_display = scores
-        bold = k
-
-    return (
-        words_display,
-        displayvect_display,
-        scores_display,
-        bold,
-    )
-
-
-win = False
-n = 0
-recent_hint = 0
-f_dev_avg = 0
-last_hint = -1
-
-if difficulty == 1:
-    n = 3
-
-
-def play_game(word):
-    global win, n, recent_hint, f_dev_avg, last_hint, words, word_vect, scores, thread
-
-    word = word.lower()
-    if word == "give_up":
-        return "Game Over"
-
-    if word in words:
-        repeated = words.index(word)
-    else:
-        repeated = -1
-        words.append(word)
-
-    thread.join()
-
-    if word not in embeddings_dict.keys():
-        embedding = model_st.encode(word, convert_to_tensor=True)
-        embeddings_dict[word] = embedding
-        model.add_vector(word, embedding.tolist())
-
-    if repeated == -1:
-        word_vect.append(embeddings_dict[word].tolist())
-
-    score = round(model.similarity(secret, word) * 10, 2)
-
-    if repeated == -1:
-        scores.append(score)
-
-    if score <= 2.5:
-        feedback = Config.Feedback_0 + str(score)
-    elif score > 2.5 and score <= 4.0:
-        feedback = Config.Feedback_1 + str(score)
-    elif score > 4.0 and score <= 6.0:
-        feedback = Config.Feedback_2 + str(score)
-    elif score > 6.0 and score <= 7.5:
-        feedback = Config.Feedback_3 + str(score)
-    elif score > 7.5 and score <= 8.0:
-        feedback = Config.Feedback_4 + str(score)
-    elif score > 8.0 and score < 10.0:
-        feedback = Config.Feedback_5 + str(score)
-    else:
-        win = True
-        feedback = Config.Feedback_8
-        words[0] = secret
-        words.pop(len(words) - 1)
-        word_vect.pop(len(word_vect) - 1)
-        scores.pop(len(scores) - 1)
-
-    if score > scores[len(scores) - 2] and win == False:
-        feedback += "\n" + Config.Feedback_6
-    elif score < scores[len(scores) - 2] and win == False:
-        feedback += "\n" + Config.Feedback_7
-
-    if difficulty != 4:
-        mov_avg = calculate_moving_average(scores[1:], 5)
-
-        if len(mov_avg) > 1 and win == False:
-            f_dev = calculate_tendency_slope(mov_avg)
-            f_dev_avg = calculate_moving_average(f_dev, 3)
-            if f_dev_avg[len(f_dev_avg) - 1] < 0 and recent_hint == 0:
-                i = random.randint(0, len(Config.hint_intro) - 1)
-                feedback += "\n\n" + Config.hint_intro[i]
-                hint_text, n, last_hint = hint(
-                    secret,
-                    n,
-                    model_st,
-                    last_hint,
-                    lang,
-                    (
-                        DictWrapper(Config_full["SPA"]["Hint"])
-                        if lang == 0
-                        else DictWrapper(Config_full["ENG"]["Hint"])
-                    ),
-                )
-                feedback += "\n" + hint_text
-                recent_hint = 3
-
-        if recent_hint != 0:
-            recent_hint -= 1
-
-    (
-        words_display,
-        displayvect_display,
-        scores_display,
-        bold_display,
-    ) = preproc_vectors(words, word_vect, scores, repeated)
-
-    if win:
-        bold_display = 0
-
-    thread = threading.Thread(
-        target=display_words,
-        args=(words_display, displayvect_display, scores_display, bold_display),
-    )
-    thread.start()
-
-    if win:
-        feedback += "\nCongratulations! You guessed the secret word."
-
-    return feedback
-
-
-def gradio_interface():
-    return gr.Interface(
-        fn=play_game,
-        inputs="text",
-        outputs="text",
-        title="Secret Word Game",
-        description="Guess the secret word!",
-        examples=[
-            ["apple"],
-            ["banana"],
-            ["cherry"],
-        ],
-    )
-
-
-if __name__ == "__main__":
-    gradio_interface().launch()