Pulling this repo

.gitignore

@@ -1 +0,0 @@
-interface_experiment.py

README.md

@@ -11,5 +11,3 @@ license: cc-by-4.0
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-
-![Alt text](mermaid-diagram-2024-01-16-104433.png)

app.py

@@ -1,172 +1,4 @@
-
-import chess
-import random
 import streamlit as st
-from transformers import pipeline
-
-from game_database import GameDatabase
-from logger import Logger
-
-generator2 = pipeline('text-generation', model='BlueSunflower/gpt2-medium-chess')
-generator = pipeline('text-generation', model='gpt2')
-
-def cleanup_output(text, prompt):
-        section = text[len(prompt):len(prompt) + 7]
-        st.write("Proposed Move: " + section)
-        valid_letters = ['A','a','B','b','C','c','D','d','E','e','F','f','G','g','H','h']
-        valid_pieces = ['p','P','k','K','q','Q','r','R','b','B', 'n', 'N']
-        valid_numbers = ['1','2','3','4','5','6','7','8']
-
-        #if there are any syntatically moves in this string for pieces
-        countr = 0
-        while countr < 4:
-          if(section[countr] in valid_pieces and section[countr + 1] in valid_letters and section[countr + 2] in valid_numbers):
-            #print(section[countr:countr+3])
-            return ' ' + section[countr:countr+3]
-          countr+=1
-
-        #variant for capturing!
-        countr = 0
-        while countr < len(section) - 4:
-          if(section[countr] in valid_pieces and section[countr + 1] == 'x' and section[countr + 2] in valid_letters and section[countr + 3] in valid_numbers):
-            #print(section[countr:countr+3])
-            return ' ' + section[countr:countr+5]
-          countr+=1
-
-        #same as moves but for pawns
-        countr = 0
-        while countr < 5:
-          if(section[countr] in valid_letters and section[countr+1] in valid_numbers):
-            #print(section[countr:countr+2])
-            return ' ' + section[countr:countr+2]
-          countr+=1
-        
-        #variant for capturing!
-        countr = 0
-        while countr < len(section) -4:
-          if(section[countr] in valid_letters and section[countr+1] == 'x' and section[countr+2] in valid_letters and section[countr + 3] in valid_numbers):
-            #print(section[countr:countr+2])
-            return ' ' + section[countr:countr+4]
-          countr+=1
-
-        return ' e8'
-
-class AInstance:
-    def __init__(self, type, generator):
-        self.type = type
-        self.game_end = False
-        self.generator = generator        
-
-    #All this does it take the gamestate and add the ai-generated result to it
-    def move(self, game_state):
-        if(type == "BlueSunflower/gpt2-medium-chess"):
-            prompt = "1-0 2700 1350 " + game_state
-        else:
-            prompt = game_state
-        countr = 0
-        while True:
-            generated_text = self.generator(prompt, max_length=len(prompt) + 10, num_return_sequences=1)[0]['generated_text']
-            selected_move = cleanup_output(generated_text, prompt)
-
-            #if this move is valid then return it
-            proposed_board = game_state + selected_move
-            if(verify_move(proposed_board)):
-                return proposed_board, countr
-            countr+=1
-            #goes fifty times until the AInstance object flags itself as "ended" (fundamentally unable to make a valid move)
-            if(countr > 50):
-                self.game_end = True
-                break
-
-    def check_if_end(self):
-        return self.game_end
-
-def verify_move(string): #Given all moves so far, this checks if any moves are illegal.
-    board = chess.Board()
-    st.write("Board: " + string)
-    for move in string.split():
-      #if this move makes no sense it will return false and the game will try again to generate a good move
-      try:
-        board.push_san(move)
-      except:
-        st.write("Invalid Move\n")
-        return False
-    if(board.is_valid):
-      st.write("Valid Move\n")
-      return True
-    return False
-
-def check_mate(string): #Am confusion
-  #simulates mate idk
-    if(random.randrange(0,100) == 4):
-        st.write("H")
-        return True
-    return False
-
-def print_game(string):
-    st.write("Some kind of visualization for the chess board based on this string: " + string)
-
-def make_move(instance, game_state):
-    print("\n" + instance.type + "s's move")
-    return_state = game_state
-    return_state, countr = instance.move(game_state)
-    game_ongoing = True
-    if(instance.check_if_end()):
-        st.write("This player claims countr > 50: " + instance.type)
-        game_ongoing = False
-    if(check_mate(return_state)):
-        st.write("This player claims mates: " + instance.type)
-        game_ongoing = False
-    return(return_state, game_ongoing, countr)
-
-
-def main():
-    
-    player_1 = "gpt2"
-    player_2 = "gpt2-medium-chess"
-
-    if(random.randrange(0,1)):
-        white = AInstance(player_1, generator)
-        black = AInstance(player_2, generator2)
-        st.write("Gpt2 is White and Gpt2 Optimized is Black")
-    else:
-        white = AInstance(player_2, generator2)
-        black = AInstance(player_1, generator)
-        st.write("Gpt2 is Black and Gpt2 Optimized is White")
-
-    onetime_logger = Logger(white.type, black.type) #Logger.model_1 should be white and vice versa
-
-    game_state = "e4 e5"
-    game_ongoing = True
-
-    moves = 0
-    while game_ongoing:
-        game_state, game_ongoing, white_cheat_count = make_move(white, game_state)
-        for i in range(white_cheat_count):
-           onetime_logger.add_cheat()
-        onetime_logger.add_legal_move(game_state)
-        
-        if not game_ongoing:
-            print_game(game_state)
-            break
-        game_state, game_ongoing, black_cheat_count = make_move(black, game_state)
-        for i in range(black_cheat_count):
-           onetime_logger.add_cheat()
-        onetime_logger.add_legal_move(game_state)
-        if not game_ongoing:
-            print_game(game_state)
-            break
-        
-        #testing code
-        moves += 1
-        if moves >= 2:
-           break
-    
-    onetime_logger.add_checkmate(player_1) #here for testing purposes
-    finished_game = onetime_logger.return_formatted_game()
-    onetime_db = GameDatabase()
-    onetime_db.add_game(finished_game)
 
-    onetime_db.display_game(0)
-if __name__ == "__main__":
-   main()
+x = st.slider('Select a value')
+st.write(x, 'squared is', x * x)

architecture_diagram.md

@@ -1,25 +0,0 @@
-```mermaid
----
-config:
-    flowchart:
-        defaultRenderer: elk
----
-flowchart LR
-interface(Model \n Interface)
-model(Chosen Model)
-logger("Logger\nget_stockfish_results()")
-coordinator(Game \n Coordinator)
-database("Game Database \n display_analytics()")
-
-coordinator --model_vs_model(model_1: str, model_2:str)-->interface
-coordinator --human_vs_model(model name: str) -->interface
-
-interface --send_move(model_name, UCI_notation) \n returns response-->model
-
-interface --create(model_1: str, model_2: str) \n creates a few logger for each game--> logger
-interface --add_legal_move(UCI_notation_of_game: str)-->logger
-interface--add_cheat(cheater_name: str)-->logger
-interface--add_checkmate(winner_name: str)-->logger
-
-logger --return_formatted_game(game_in_UCI: str, cheat_log: [int])-->database
-```

game_database.py

@@ -1,101 +0,0 @@
-import chess
-import matplotlib.pyplot as plt
-import pandas as pd
-import streamlit as st
-from typing import Dict
-from logger import Logger
-import time
-import numpy as np
-
-class GameDatabase:
-    def __init__(self):
-        self.db = []
-        pass
-    
-    def add_game(self, game: Dict[str, str]):
-        self.db.append(game)
-
-    def display_game(self, game_num: int): #Displays analytics for a specific game
-        game = self.db[game_num]
-
-        fig, axs = plt.subplots(2,2)
-        fig.tight_layout()
-        width = 0.4
-
-        def list_sets_graph(data_list: [], axs_pos: [], title, width = 0.4):
-            white_data = data_list[::2]
-            black_data = data_list[1::2]
-            x_w = np.arange(len(white_data))
-            x_b = np.arange(len(black_data))
-
-            axs[axs_pos[0], axs_pos[1]].set_xticks(x_w, [x for x in range(len(white_data))])
-            axs[axs_pos[0], axs_pos[1]].bar(x_w - (width/2), white_data, width, color = "navajowhite")
-            axs[axs_pos[0], axs_pos[1]].bar(x_b + (width/2), black_data, width, color = "saddlebrown")
-            axs[axs_pos[0], axs_pos[1]].legend(["White", "Black"]) 
-            axs[axs_pos[0], axs_pos[1]].set_title(title)
-
-
-
-        #plot time per move, with data for each model
-        time_title = "Seconds Per Move"
-        list_sets_graph(game[time_title], axs_pos=[0,0], title=time_title)
-
-        #plot cheating per model
-        cheat_title = "Cheat Attempts Per Move"
-        list_sets_graph(game["Cheat Attempts"], axs_pos=[1,0], title = cheat_title)
-
-        #stockfish analysis of each player over time
-
-
-        #plt.show()
-        st.pyplot(fig)
-
-
-    def display_tournament(self): #Displays analytics for the entire tournament
-
-        df = pd.DataFrame(self.db)
-
-        #heatmap of tournament winrates
-        
-        #bar chart of tournament winrates
-        win_results = df["Winner"].value_counts()
-        print(win_results.rank())
-
-        names = ["steve", "bob", "emily"]
-        nums = [1,2,3]
-
-        fig, axs = plt.subplots(2,1)
-        axs[0].plot(win_results)
-        axs[1].bar(names, nums)
-
-        st.pyplot(fig)
-        
-        
-
-if __name__ == "__main__":
-    test_logger = Logger("ChessGPT", "ChatGPT")
-    test_logger.add_cheat()
-    time.sleep(1)
-    test_logger.add_legal_move("e4")
-    time.sleep(1)
-    test_logger.add_legal_move("e4 e6")
-    time.sleep(2)
-    test_logger.add_legal_move("e4 e6 Nf3")
-    test_logger.add_checkmate("ChessGPT")
-    #test_logger.add_legal_move("e4 e5")
-    formatted = test_logger.return_formatted_game()
-
-    test_logger_2 = Logger("ChessGPT", "BERT")
-    test_logger_2.add_checkmate("BERT")
-    formatted_2 = test_logger_2.return_formatted_game()
-
-    test_logger_3 = Logger("ChessGPT", "BERT")
-    test_logger_3.add_checkmate("ChessGPT")
-    formatted_3 = test_logger_3.return_formatted_game()
-
-    db = GameDatabase()
-    db.add_game(formatted)
-    db.add_game(formatted_2)
-    db.add_game(formatted_3)
-
-    db.display_game(0)

interface_experiment.py

@@ -1,13 +0,0 @@
-import transformers
-
-model_id = "BlueSunflower/gpt2-medium-chess"
-text_generator = transformers.pipeline("text-generation", model = model_id)
-input_text = "1-0 2995 3110 1.e4 e5 2.Nf3 Nc6"
-
-for i in range(5):
-    generated = text_generator(input_text, max_new_tokens = 10)[0]["generated_text"]
-    new_string = str(generated).replace(input_text, "")
-    move = new_string.split(" ", maxsplit=1)[1]
-    input_text += move
-    print(input_text)
-

logger.py

@@ -1,95 +0,0 @@
-import requests
-import re
-import time
-
-class Logger:
-    def __init__(self, model_1: str, model_2: str): #Model 1 should be white
-        self.model_1 = model_1
-        self.model_2 = model_2
-        self.current_moves = ""
-
-        self.cheat_attempts = [0]
-
-        self.winner = ""
-        self.checkmate = False
-
-        self.seconds_per_move = []
-        self.prev_end_time = time.time()
-
-        self.stockfish_results = []
-
-    #Interface with the Model Interface
-    def add_legal_move(self, current_moves: str): #current_moves should be all moves so far, in UCI notation
-        if self.checkmate:
-            raise RuntimeError("This game has already reached checkmate")
-        else: 
-            self.current_moves = current_moves
-            self.cheat_attempts.append(0)
-
-            current_time = time.time()
-            self.seconds_per_move.append(current_time - self.prev_end_time)
-            self.prev_end_time = current_time
-            
-    def add_cheat(self):
-        if self.checkmate:
-            raise RuntimeError("This game has already reached checkmate")
-        else: 
-            self.cheat_attempts[-1] += 1
-
-    def add_checkmate(self, winner_name: str):
-        if winner_name != self.model_1 and winner_name != self.model_2:
-            raise RuntimeError("Not a valid winner for this logger")
-        else: 
-            self.winner = winner_name
-            self.checkmate = True
-
-
-
-    #Internal Work
-    def get_stockfish_results(self, prev_state: str, current_state: str, depth: int = 5) -> float: #Takes current and previous FEN states. Can be refactored to only need one UCI current state
-        #returns the stockfish analysis of the last move as a positive float
-        #Example URL: https://stockfish.online/api/stockfish.php?fen=r2q1rk1/ppp2ppp/3bbn2/3p4/8/1B1P4/PPP2PPP/RNB1QRK1 w - - 5 11&depth=5&mode=eval
-        current_FEN = "?fen=" + current_state
-        prev_FEN = "?fen=" + prev_state
-        
-        endpoint = "https://stockfish.online/api/stockfish.php"
-        current_extra = current_FEN + "&depth=" + str(depth) + "&mode=eval"
-        prev_extra = prev_FEN + "&depth=" + str(depth) + "&mode=eval"
-        current_response = requests.get(endpoint + current_extra)
-        prev_response = requests.get(endpoint + prev_extra)
-
-        current_string = str(current_response.json())
-        prev_string = str(prev_response.json())
-
-        current_score = float(re.findall(r"-?\d*\.*\d+", current_string)[0]) #Positive means white is winning and vice versa
-        prev_score = float(re.findall(r"-?\d*\.*\d+", prev_string)[0])
-        #Add something to make sure it's that player's turn to make the move?
-        
-        return abs(current_score) - abs(prev_score) #Positive numbers mean the player that made the move is better off
-    def format_game(self):
-        pass
-
-    #Interface with game_database
-    def return_formatted_game(self):
-        
-        if self.winner == "":
-            raise RuntimeError("Game is not yet completed")
-            pass
-
-        else:
-            game = {"Model 1": self.model_1, 
-                    "Model 2": self.model_2, 
-                    "Winner": self.winner, 
-                    "UCI": self.current_moves, 
-                    "Cheat Attempts": self.cheat_attempts,
-                    "Seconds Per Move": self.seconds_per_move,
-                    "Stockfish Results": self.stockfish_results}
-            return game
-    
-#Testing section
-if __name__ == "__main__":
-    new_logger = Logger("ChessGPT", "ChatGPT")
-    current_board = "r2q1rk1/1pp2ppp/3bbn2/p2p4/8/1B1P4/PPP2PPP/RNB1QRK1 w - - 5 11" #make sure to include the additional notation at the end
-    prev_board = "r2q1rk1/ppp2ppp/3bbn2/3p4/8/1B1P4/PPP2PPP/RNB1QRK1 w - - 5 11"
-    print(str(new_logger.get_stockfish_results(prev_board, current_board)))
-    

requirements.txt

@@ -1,7 +0,0 @@
-#To download requirements, use 'python -m pip install -r requirements.txt'
-python-chess==1.1.0
-matplotlib==3.8.2
-requests==2.28.2
-pandas==1.5.3
-transformers==4.36.2
-torch==2.1.2