# %% 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 class Semantrix: model = KeyedVectors(768) 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): 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 if self.lang == 0: self.Config = self.DictWrapper(self.Config_full["SPA"]["Game"]) self.secret_dict = self.secret["SPA"] elif self.lang == 1: self.Config = self.DictWrapper(self.Config_full["ENG"]["Game"]) 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 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.secret = "amigo" 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.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 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] # 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 word = word.lower() if word == "give_up": text = ( "[win]" + 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) # 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.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["SPA"]["Hint"]) if self.lang == 0 else self.DictWrapper(self.Config_full["ENG"]["Hint"]) ), ) feedback += "\n" + hint_text self.recent_hint = 3 if self.recent_hint != 0: self.recent_hint -= 1 ( words_display, scores_display, bold_display, ) = self.preproc_vectors(repeated) 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() 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["SPA"]["Hint"])) return feedback