Upload 8 files

classes/Qlearningagent.py

@@ -0,0 +1,79 @@
+import random
+import json
+import ast
+
+class QlearningAgent():
+    def __init__(self, epsilon,alpha ,discount_factor, train):
+        self.q_table = {}
+        self.epsilon = epsilon
+        self.alpha = alpha
+        self.discount_factor = discount_factor
+        self.train = train
+
+    def save_agent_dict(self, file_name):
+        # Convert tuple keys to strings
+        q_table_str_keys = {str(key): value for key, value in self.q_table.items()}
+
+        with open(file_name, 'w') as file_json:
+            json.dump(q_table_str_keys, file_json)
+
+
+    def load_agent_dict(self, file_name):
+        try:
+            with open(file_name, 'r') as file_json:
+                json_data = json.load(file_json)
+            # Convert string keys back to tuples
+            q_table = {ast.literal_eval(key): value for key, value in json_data.items()}
+            
+            self.q_table = q_table
+            print("Q-table loaded successfully.")
+        except FileNotFoundError:
+            print(f"File '{file_name}' not found. Q-table not loaded.")
+
+
+    def get_q_value(self, state, action, piece):
+        state_tuple = tuple(state.flatten())
+
+        if (state_tuple,action,piece) not in self.q_table:
+            self.q_table[(state_tuple, action, piece)] = 0.0
+            
+
+        return self.q_table[(state_tuple, action, piece)]
+
+   
+    def choose_move(self, state, available_moves, piece):
+        q_values = []
+        for action in available_moves:
+            q_values.append(self.get_q_value(state, action, piece))
+            
+        if random.uniform(0, 1) < self.epsilon and self.train:
+            return random.choice(available_moves)
+        else:
+            max_q_value = max(q_values)
+            if q_values.count(max_q_value) > 1:
+                best_moves = [i for i in range(len(available_moves)) if q_values[i] == max_q_value]
+                i = random.choice(best_moves)
+            else:
+                i = q_values.index(max_q_value)
+            return available_moves[i]
+
+
+    def update_q_value(self, states, rewards):
+        #estado atual + alpha[retorno estado atual + ymax(proximo_estado) - estado atual]
+        for i,state in enumerate(states):
+            rt = 0
+            if state not in self.q_table.keys():
+                self.q_table[state] = 0.0
+               
+
+            for ii in range(0,len(rewards)):
+                rt+= rewards[ii] * (self.discount_factor ** (ii-i))
+
+            if i == len(states)-1:
+                next_reward = 0
+            else:
+                next_reward = rewards[i+1]
+           
+            q_formula =  self.q_table[state] + (self.alpha*(rewards[i] + self.discount_factor*(next_reward) - self.q_table[state]))
+            self.q_table[state] = q_formula
+           

classes/environment.py

@@ -0,0 +1,184 @@
+import tqdm
+from classes.game_model import tic_tac_toe_model
+from classes.Qlearningagent import QlearningAgent
+
+class environment():
+    def __init__(self, tic_tac_toe: tic_tac_toe_model, q_agent: QlearningAgent, train: bool, show_stats: bool):
+        self.board = tic_tac_toe
+        self.q_agent = q_agent
+        self.train = train
+        self.show_stats = show_stats
+    
+    def play_one_game(self, piece):
+        game_over = False
+        win_piece = 0
+        self.board.reset_matrix()
+        if piece == 1:
+            piece_enemy = 2
+            states_x = []
+            rewards_x = []
+            while not game_over:
+                w = self.board.check_win()
+                if w != 4:
+                    state = self.board.matriz.copy()
+                    reward_x = self.board.reward_piece(piece)
+                    state_x = (tuple(state.flatten()),-1,piece)# -1 for terminal state
+                    states_x.append(state_x)
+                    rewards_x.append(reward_x)
+                    win_piece = w
+                    break
+
+                #x move and state/reward/move dynamic
+                state = self.board.matriz.copy()
+                avaible_moves = self.board.get_avaible_moves()
+                action_x = self.q_agent.choose_move(state,avaible_moves,piece)
+                i, j = self.board.number_ij(action_x)
+                self.board.move(i,j,piece)
+                reward_x = self.board.reward_piece(piece)
+                state_x = (tuple(state.flatten()),action_x,piece)
+                states_x.append(state_x)
+                rewards_x.append(reward_x)
+                w = self.board.check_win()
+                if w != 4:
+                    state = self.board.matriz.copy()
+                    reward_x = self.board.reward_piece(piece)
+                    state_x = (tuple(state.flatten()),-1,piece)# -1 for terminal state
+                    states_x.append(state_x)
+                    rewards_x.append(reward_x)
+                    win_piece = w
+                    break
+                self.board.get_random_move(piece_enemy)
+               
+            self.q_agent.update_q_value(states_x,rewards_x)
+                
+            return win_piece
+        else:
+            piece_enemy = 1
+            states_o = []
+            rewards_o = []
+            while not game_over:
+                self.board.get_random_move(piece_enemy)
+               
+                w = self.board.check_win()  
+                if w != 4:
+                    state = self.board.matriz.copy()
+                    reward_o = self.board.reward_piece(piece)
+                    state_o = (tuple(state.flatten()),-1,piece)# -1 for terminal state
+                    states_o.append(state_o)
+                    rewards_o.append(reward_o)
+                    win_piece = w
+                    break
+                state = self.board.matriz.copy()
+                avaible_moves = self.board.get_avaible_moves()
+                action_o = self.q_agent.choose_move(state,avaible_moves,piece)
+                i, j = self.board.number_ij(action_o)
+                self.board.move(i,j,piece)
+                
+                reward_o = self.board.reward_piece(piece)
+                state_o = (tuple(state.flatten()), action_o, piece)
+                states_o.append(state_o)
+                rewards_o.append(reward_o)
+                w = self.board.check_win()  
+                if w != 4:
+                    state = self.board.matriz.copy()
+                    reward_o = self.board.reward_piece(piece)
+                    state_o = (tuple(state.flatten()),-1,piece)# -1 for terminal state
+                    states_o.append(state_o)
+                    rewards_o.append(reward_o)
+                    win_piece = w
+                    break
+                 
+            self.q_agent.update_q_value(states_o,rewards_o)
+                
+            return win_piece
+   
+            
+    def play_ia_vs_ia(self):
+        game_over = False
+        self.board.reset_matrix()
+        ia_x = 1
+        ia_o = 2
+        states_x = []
+        rewards_x = []
+        states_o = []
+        rewards_o = []
+        while not game_over:
+            w = self.board.check_win()
+            if w != 4:
+                win_piece = w
+                break
+            state_x = self.board.matriz.copy()
+            avaible_moves_x = self.board.get_avaible_moves()
+            action_x = self.q_agent.choose_move(state_x,avaible_moves_x,ia_x)
+            i, j = self.board.number_ij(action_x)
+            self.board.move(i,j,ia_x) # x play
+
+            #x state/reward
+            reward_x = self.board.reward_piece(ia_x)
+            state_x = (tuple(state_x.flatten()),action_x,ia_x)
+            states_x.append(state_x)
+            rewards_x.append(reward_x)
+
+            w = self.board.check_win()
+            if w != 4:
+                win_piece = w
+                break
+
+            state_o = self.board.matriz.copy()
+            avaible_moves_o = self.board.get_avaible_moves()
+            action_o = self.q_agent.choose_move(state_o,avaible_moves_o,ia_o)
+            i, j = self.board.number_ij(action_o)
+            self.board.move(i,j,ia_o) # o play
+
+            reward_o = self.board.reward_piece(ia_o)
+            state_o = (tuple(state_o.flatten()),action_o,ia_o)
+            states_o.append(state_o)
+            rewards_o.append(reward_o)
+        
+        if win_piece == 1:
+            state = self.board.matriz.copy()
+            reward_o = self.board.reward_piece(ia_o)
+            state_o = (tuple(state.flatten()),-1,ia_o)# -1 for terminal state
+            states_o.append(state_o)
+            rewards_o.append(reward_o)     
+        elif win_piece == 2:
+            state = self.board.matriz.copy()
+            reward_x = self.board.reward_piece(ia_x)
+            state_x = (tuple(state.flatten()),-1,ia_x)# -1 for terminal state
+            states_x.append(state_x)
+            rewards_x.append(reward_x)
+
+            
+        self.q_agent.update_q_value(states_x,rewards_x)
+        self.q_agent.update_q_value(states_o,rewards_o)
+
+        return win_piece
+    
+    
+    def run(self, n):
+        wins_x = []
+        wins_o = []
+        wins_ia = []
+        if self.show_stats:
+            print(f'Playing {n} games with X')
+            for i in tqdm.tqdm(range(0,n)):
+                wins_x.append(self.play_one_game(piece=1))
+            
+            print(f'Playing {n} games with O')
+            for i in tqdm.tqdm(range(0,n)):
+                wins_o.append(self.play_one_game(piece=2))
+
+            print(f'Playing {n} games ia vs ia')
+            for i in tqdm.tqdm(range(0,n)):
+                wins_ia.append(self.play_ia_vs_ia())
+        else:
+            for i in range(0,n):
+                wins_x.append(self.play_one_game(piece=1))
+            
+            for i in range(0,n):
+                wins_o.append(self.play_one_game(piece=2))
+
+            for i in range(0,n):
+                wins_ia.append(self.play_ia_vs_ia())
+        
+        return wins_x,wins_o, wins_ia

classes/game.py

@@ -0,0 +1,130 @@
+import tqdm
+import random
+from classes.game_model import tic_tac_toe_model
+from classes.Qlearningagent import QlearningAgent
+
+class Game():
+    def __init__(self, tic_tac_toe: tic_tac_toe_model, q_agent: QlearningAgent):
+        self.board = tic_tac_toe
+        self.q_agent = q_agent
+    
+    def ia_vs_ia(self):
+        game_over = False
+        self.board.reset_matrix()
+        while not game_over:
+            w = self.board.check_win()
+            if w != 4:
+                win_piece = w
+                break
+            state = self.board.matriz.copy()
+            avaible_moves = self.board.get_avaible_moves()
+            action = self.q_agent.choose_move(state,avaible_moves,1)
+            i, j = self.board.number_ij(action)
+            self.board.move(i,j,1)
+            if w != 4:
+                win_piece = w
+                break
+
+            state = self.board.matriz.copy()
+            avaible_moves = self.board.get_avaible_moves()
+            action = self.q_agent.choose_move(state,avaible_moves,2)
+            i, j = self.board.number_ij(action)
+            self.board.move(i,j,2)
+
+            
+        return win_piece
+        
+    def run_ia_vs_ia(self,n):
+        games = []
+        for i in tqdm.tqdm(range(0,n)):
+            w = self.ia_vs_ia()
+            games.append(w)
+        return games
+    
+    def ia_vs_user(self):
+        print('Menu')
+        print("1 - Iniciar aleatorio")
+        print("2 - Escolher peça [X-O]")
+        m1 = int(input())
+        while m1 != 1 and m1 !=2:
+            print('Insira um valor valido 1-2')
+            print("1 - Iniciar aleatorio")
+            print("2 - Escolher peça [X-O]")
+            m1 = int(input())
+
+        game_over = False
+        self.board.reset_matrix()
+        pieces = [1,2]
+        win_piece = 0
+        if m1 == 1 :
+            user = random.choice(pieces)    
+        else:
+            print('1 - X \n 2 - O')
+            user = int(input())
+            while user != 1 and user !=2:
+                print("Insira um valor válido 1-2")
+                print('1 - X\n2 - O')
+                user = int(input())
+                
+
+        ia = 2 if user == 1 else 1
+        print("Começo de jogo")
+        self.board.print_game()
+        if ia == 1:
+            while not game_over:
+                state = self.board.matriz.copy()
+                avaible_moves = self.board.get_avaible_moves()
+                action = self.q_agent.choose_move(state,avaible_moves,ia)
+                i, j = self.board.number_ij(action)
+                print('Jogada da IA - X')
+                self.board.move(i,j,ia)
+                self.board.print_game()
+                w = self.board.check_win()
+                if w != 4:
+                    win_piece = w
+                    break
+                print("Jogue Usuario - O [Numero da linha][Numero da coluna]")
+                ml,mv = int(input()), int(input())
+                self.board.move(ml,mv,user)
+                self.board.move(i,j,user)
+                self.board.print_game()
+                w = self.board.check_win()
+                if w != 4:
+                    win_piece = w
+                    break
+
+        else:
+             while not game_over:
+                print('Jogue Usuario - X [Numero da linha][Numero da coluna]')
+                ml,mv = int(input()), int(input())
+
+                self.board.move(ml,mv,user)
+                self.board.print_game()
+                w = self.board.check_win()
+                if w != 4:
+                    win_piece = w
+                    break
+
+                print('Jogada da IA - O')
+                state = self.board.matriz.copy()
+                avaible_moves = self.board.get_avaible_moves()
+                action = self.q_agent.choose_move(state,avaible_moves,ia)
+                i, j = self.board.number_ij(action)
+                self.board.move(i,j,ia)
+                w = self.board.check_win()
+
+                self.board.print_game()
+
+                if w != 4:
+                    win_piece = w
+                    break
+               
+
+        if win_piece == ia :
+            print("IA venceu Humano Fraco")
+        elif win_piece == user :
+            print("Humano venceu, esta preparado para a revolução?")
+        else:
+            print('Deu velha, mas a I.A segue aprendendo e melhorando e você?')
+        return win_piece
+        

classes/game_model.py

@@ -0,0 +1,92 @@
+import random
+import numpy as np
+
+class tic_tac_toe_model():
+    def __init__(self, n):
+        self.n = n
+        self.matriz = np.full((n,n),0,dtype=int)
+    
+    def reset_matrix(self):
+        self.matriz = np.full((self.n,self.n),0,dtype=int)
+
+    def print_game(self):
+        matriz = self.matriz
+        substituicoes = {1: "X", 2: "O", 0:' '}
+        
+        cabecalho = [str(i) for i in range(0,self.n)]
+        print(' ', ' | '.join(cabecalho))
+        for i,linha in enumerate(matriz):
+            linha_formatada = [str(substituicoes.get(valor, valor)) for valor in linha]
+            print(i, " | ".join(linha_formatada))
+            print("-" * 12)
+    
+
+    def number_ij(self, number):
+        i,j = np.unravel_index(number, self.matriz.shape)
+        return i,j
+    
+    
+    def get_avaible_moves(self):
+        avaible_moves = np.ravel_multi_index(np.where(self.matriz == 0), self.matriz.shape)
+        return list(avaible_moves)
+
+
+    def get_random_move(self, piece):
+        possible_move_i, possible_move_j = np.where(self.matriz == 0)
+        if possible_move_j.shape[0] > 0:  # Verifica se há movimentos possíveis
+            index = random.randint(0, possible_move_j.shape[0] - 1)  # Correção aqui
+            self.move(possible_move_i[index], possible_move_j[index], piece)
+
+
+    def move(self,index_i,index_j,piece):
+        if self.matriz[index_i][index_j] == 0:
+            self.matriz[index_i][index_j] = piece
+        
+    
+    
+    def reward_piece(self,piece):
+        w = self.check_win()
+        if w != 4 :
+            if w!=3:
+                if w == piece:
+                    return 1
+                else:
+                    return -1
+            
+        return 0
+          
+    def check_win(self):
+        state = False
+        win_piece = -1
+        value_counts_diagonal = np.unique(self.matriz.diagonal())
+        value_counts_diagonal2  = np.unique(np.fliplr(self.matriz).diagonal())
+        if value_counts_diagonal.shape[0] == 1 and value_counts_diagonal[0] !=0:
+            state=True     
+            win_piece = value_counts_diagonal[0] 
+            return win_piece          
+        if value_counts_diagonal2.shape[0] == 1 and value_counts_diagonal2[0] !=0:
+            state=True    
+            win_piece = value_counts_diagonal2[0]   
+            return win_piece         
+
+        for i in range(0,self.n):
+            value_counts_linha = np.unique(self.matriz[i,:])
+            value_counts_coluna = np.unique(self.matriz[:,i])
+            
+            if value_counts_linha.shape[0] == 1 and value_counts_linha[0] != 0 :
+                state=True
+                win_piece = value_counts_linha[0]
+                break
+            if value_counts_coluna.shape[0] == 1 and value_counts_coluna[0] != 0:
+                state=True
+                win_piece = value_counts_coluna[0]
+                break
+            
+        velha = np.where(self.matriz == 0)
+        
+        if state:
+            return win_piece
+        if velha[0].shape[0] == 0: 
+            return 3
+        else:
+            return 4      

gradio_game.py

@@ -0,0 +1,194 @@
+
+import gradio as gr
+import numpy as np
+import time
+import argparse
+from classes.game_model import tic_tac_toe_model
+from classes.Qlearningagent import QlearningAgent
+
+
+custom_css = """
+.gradio-button {
+  width: 75px; /* Defina a largura desejada */
+  height: 75px; /* Defina a altura desejada */
+  background-color: blue; /* Cor de fundo azul */
+  color: white; /* Cor do texto (branco neste caso) */
+  border: none; /* Remove a borda */
+  text-align: center; /* Centraliza o texto horizontalmente */
+  text-decoration: none; /* Remove a decoração do texto */
+  display: inline-block; /* Permite definir largura e altura */
+  font-size: 16px; /* Tamanho do texto */
+  line-height: 75px; /* Centraliza o texto verticalmente */
+}
+
+"""
+
+usr = -2
+ia = -1
+game_over = False
+temp = -2
+
+def main():
+
+  def usr_move(position,value):
+      global game_over
+      if value == '' and game_over == False:
+        usr_piece = 'X' if usr == 1 else 'O'
+        i,j = np.unravel_index(int(position)-1, shape=(3,3))
+        board.move(i,j,usr) 
+        board.print_game()
+        w = board.check_win()
+
+        global temp
+        temp-=1
+        return gr.update(size='lg', scale = 0, min_width = 100, value=usr_piece, interactive=True), gr.Number(value=temp, visible=False), gr.Number(value=w, visible=False)
+      else:
+        return gr.update(size='lg', scale = 0, min_width = 100, interactive=True), gr.update(value=temp, visible=False),gr.update(visible=False)
+      
+          
+  def ia_move():
+        global game_over
+        if game_over == False:
+          state_board = board.matriz.copy()
+          avaible_moves = board.get_avaible_moves()
+          action = q_agent.choose_move(state_board,avaible_moves,ia)
+          i, j = board.number_ij(action)
+          ia_piece = 'X' if ia == 1 else 'O'
+          board.move(i,j,ia)
+          board.print_game()
+          w = board.check_win()
+          #buttons
+          retornos_btn = [gr.Button(size='lg', scale = 0, min_width = 100, interactive=True)]*(action+1)
+          retornos_btn[-1] = gr.Button(size='lg', scale = 0, min_width = 100, interactive=True, value=ia_piece)
+          retornos_btn.extend([gr.Button(size='lg', scale = 0, min_width = 100,  interactive=True)]*(9 - action-1))
+          retornos_btn.append(gr.Number(value=w, visible=False))
+          return retornos_btn
+        else:
+          retornos_btn = [gr.Button(size='lg', scale = 0, min_width = 100, interactive=True)]*9
+          retornos_btn.append(gr.Number(visible=False))
+          return retornos_btn
+          
+
+  def set_col_visible(selected):
+        global usr
+        global game_over
+        game_over = False
+        usr =  1 if selected  == 'X' else 2
+        global ia
+        ia = 2 if usr == 1 else 1
+        retorn_buttons = [gr.Button(size='lg', scale = 0, min_width = 100,value='',elem_classes='gradio-button',interactive=True)]*9
+        if selected == 'X':
+          retorn_buttons.append(gr.Number(value=temp, visible=False))
+
+        else:
+          retorn_buttons = ia_move()
+
+        return retorn_buttons
+      
+          
+  def reset():
+      board.reset_matrix()
+      buttons = [gr.Button(size='lg', scale = 0, min_width = 100,elem_classes='gradio-button',interactive=False)]*9
+      return buttons
+
+
+  def check(n):
+      msg = ''
+      global game_over
+      if n == 1:
+        game_over = True
+        msg = 'O jogador X ganhou'
+        board.reset_matrix()
+
+      elif n == 2:
+        game_over = True
+        msg = 'O jogador O ganhou'
+        board.reset_matrix()
+
+      elif n == 3 :
+        game_over = True
+        msg = 'VELHA'
+        board.reset_matrix()
+    
+      print('check',game_over)
+      return gr.update(value=msg, show_label=False)
+  
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--file_name', type=str, required=False, default='models/q_agent-0.9ep-0.6ap-0.9-1000r.json')
+  args = parser.parse_args()
+  with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
+      q_agent= QlearningAgent(epsilon=0,alpha=0,discount_factor=0, train=False)
+      q_agent.load_agent_dict(args.file_name)
+      board = tic_tac_toe_model(3)
+      with gr.Row():
+        with gr.Column() as x:
+          title = gr.Text(value='Escolha uma peça', show_label=False)
+          with gr.Row():
+              p1 = gr.Button(size='lg', scale = 0, min_width = 100,value='',elem_classes='gradio-button',interactive=False)
+              p2 = gr.Button(size='lg', scale = 0, min_width = 100,value='',elem_classes='gradio-button',interactive=False)
+              p3 = gr.Button(size='lg', scale = 0, min_width = 100,value='',elem_classes='gradio-button',interactive=False)
+          with gr.Row():
+              p4 = gr.Button(size='lg', scale = 0, min_width = 100,value='',elem_classes='gradio-button',interactive=False)
+              p5 = gr.Button(size='lg', scale = 0, min_width = 100,value='',elem_classes='gradio-button',interactive=False)
+              p6 = gr.Button(size='lg', scale = 0, min_width = 100,value='',elem_classes='gradio-button',interactive=False)
+          with gr.Row():
+              p7 = gr.Button(size='lg', scale = 0, min_width = 100,value='',elem_classes='gradio-button',interactive=False)
+              p8 = gr.Button(size='lg', scale = 0, min_width = 100,value='',elem_classes='gradio-button',interactive=False)
+              p9 = gr.Button(size='lg', scale = 0, min_width = 100,value='',elem_classes='gradio-button',interactive=False)
+
+        n1 = gr.Number(value="1", visible=False)
+        n2 = gr.Number(value="2", visible=False)
+        n3 = gr.Number(value="3", visible=False)
+        n4 = gr.Number(value="4", visible=False)
+        n5 = gr.Number(value="5", visible=False)
+        n6 = gr.Number(value="6", visible=False)
+        n7 = gr.Number(value="7", visible=False)
+        n8 = gr.Number(value="8", visible=False)
+        n9 = gr.Number(value="9", visible=False)
+        temp_number = gr.Number(value="10", visible=False)
+        win_number = gr.Number(value="4", visible=False)
+        game_state = gr.Number(value="0", visible=False)
+
+        with gr.Column():
+          c1 = gr.Radio( ['X','O'],label='Jogar como')
+          clear_button = gr.Button(value='Resetar')
+
+
+      buttons = [p1, p2, p3, p4, p5, p6, p7, p8, p9,win_number]
+      renders_components = [p1, p2, p3, p4, p5, p6, p7, p8, p9, win_number] 
+      game_components = [p1, p2, p3, p4, p5, p6, p7, p8, p9, title,temp_number,win_number, c1]
+      only_buttons = [p1, p2, p3, p4, p5, p6, p7, p8, p9]
+      p1.click(fn=usr_move,inputs=[n1,p1], outputs = [p1,temp_number,win_number])
+      p2.click(fn=usr_move,inputs=[n2,p2], outputs = [p2,temp_number,win_number])
+      p3.click(fn=usr_move,inputs=[n3,p3], outputs = [p3,temp_number,win_number])
+      p4.click(fn=usr_move,inputs=[n4,p4], outputs = [p4,temp_number,win_number])
+      p5.click(fn=usr_move,inputs=[n5,p5], outputs = [p5,temp_number,win_number])
+      p6.click(fn=usr_move,inputs=[n6,p6], outputs = [p6,temp_number,win_number])
+      p7.click(fn=usr_move,inputs=[n7,p7], outputs = [p7,temp_number,win_number])
+      p8.click(fn=usr_move,inputs=[n8,p8], outputs = [p8,temp_number,win_number])
+      p9.click(fn=usr_move,inputs=[n9,p9], outputs = [p9,temp_number,win_number])
+
+
+      def update_buttons():
+        global game_over
+        game_over = True
+        return {p1: '', p2:'', p3:'', p4:'', p5:'', p6:'', p7:'', p8:'', p9:'', 
+                title:'Escolha uma peça',temp_number:10, win_number:4, c1: ''}
+      
+    
+            
+      c1.select(fn=set_col_visible, inputs= c1, outputs=buttons)
+
+
+      temp_number.change(fn=ia_move,outputs=renders_components)
+      win_number.change(fn=check, inputs=win_number, outputs=title)
+      clear_button.click(fn=update_buttons,outputs=game_components)
+      clear_button.click(fn=reset,outputs=only_buttons)
+
+
+
+  demo.launch()
+
+if __name__ == '__main__':
+    main()
+

requirements.txt

@@ -0,0 +1,3 @@
+gradio==4.4.1
+numpy==1.26.2
+tqdm==4.66.1