maia2 0.1__tar.gz

maia2-0.1/.gitignore

@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

maia2-0.1/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2024, CSSLab
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

maia2-0.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: maia2
+Version: 0.1
+Summary: An amazing sample package for maia2.
+Author-email: csslab <josephtang@cs.toronto.edu>
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Project-URL: Home, https://github.com/CSSLab/maia2
+
+# maia2

maia2-0.1/README.md

@@ -0,0 +1 @@
+# maia2

maia2-0.1/maia2/__init__.py

@@ -0,0 +1,3 @@
+"""An amazing sample package for maia2."""
+
+__version__ = "0.1"

maia2-0.1/maia2/fetch_data.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# Loop over each year
+for year in {2018..2023}; do
+    # Loop over each month
+    for month in {05..12}; do
+        # Form the URL
+        url="https://database.lichess.org/standard/lichess_db_standard_rated_${year}-${month}.pgn.zst"
+
+        # Check if the URL exists
+        if wget --spider $url 2>/dev/null; then
+            # Download the file
+            wget "$url"
+
+            # The downloaded file name
+            filename="lichess_db_standard_rated_${year}-${month}.pgn.zst"
+
+        else
+            echo "File for ${year}-${month} does not exist."
+        fi
+
+        # Stop the loop if we've reached October 2023
+        if [ "$year" -eq 2023 ] && [ "$month" = "10" ]; then
+            break
+        fi
+    done
+
+done

maia2-0.1/maia2/inference.py

@@ -0,0 +1,154 @@
+from utils import *
+from main import *
+
+
+class TestDataset(torch.utils.data.Dataset):
+    
+    def __init__(self, data, all_moves_dict, elo_dict):
+        
+        self.all_moves_dict = all_moves_dict
+        self.data = data.values.tolist()
+        self.elo_dict = elo_dict
+    
+    def __len__(self):
+        
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        
+        fen, move, elo_self, elo_oppo = self.data[idx]
+
+        if fen.split(' ')[1] == 'w':
+            board = chess.Board(fen)
+        elif fen.split(' ')[1] == 'b':
+            board = chess.Board(fen).mirror()
+            move = mirror_move(move)
+        else:
+            raise ValueError(f"Invalid fen: {fen}")
+            
+        board_input = board_to_tensor(board)
+        
+        elo_self = map_to_category(elo_self, self.elo_dict)
+        elo_oppo = map_to_category(elo_oppo, self.elo_dict)
+        
+        legal_moves, _ = get_side_info(board, move, self.all_moves_dict)
+        
+        return fen, board_input, elo_self, elo_oppo, legal_moves
+
+
+def get_preds(model, dataloader, all_moves_dict_reversed, cfg_inference):
+    
+    all_probs = []
+    predicted_move_probs = []
+    predicted_moves = []
+    predicted_win_probs = []
+    
+    model.eval()
+    with torch.no_grad():
+        
+        for fens, boards, elos_self, elos_oppo, legal_moves in dataloader:
+            
+            if cfg_inference.gpu:
+                boards = boards.cuda()
+                elos_self = elos_self.cuda()
+                elos_oppo = elos_oppo.cuda()
+                legal_moves = legal_moves.cuda()
+
+            logits_maia, _, logits_value = model(boards, elos_self, elos_oppo)
+            logits_maia_legal = logits_maia * legal_moves
+            probs = logits_maia_legal.softmax(dim=-1)
+
+            all_probs.append(probs.cpu())
+            predicted_move_probs.append(probs.max(dim=-1).values.cpu())
+            predicted_move_indices = probs.argmax(dim=-1)
+            for i in range(len(fens)):
+                fen = fens[i]
+                predicted_move = all_moves_dict_reversed[predicted_move_indices[i].item()]
+                if fen.split(' ')[1] == 'b':
+                    predicted_move = mirror_move(predicted_move)
+                predicted_moves.append(predicted_move)
+
+            predicted_win_probs.append((logits_value / 2 + 0.5).cpu())
+    
+    all_probs = torch.cat(all_probs).cpu().numpy()
+    predicted_move_probs = torch.cat(predicted_move_probs).numpy()
+    predicted_win_probs = torch.cat(predicted_win_probs).numpy()
+    
+    return all_probs, predicted_move_probs, predicted_moves, predicted_win_probs
+
+
+def inference_batch(data):
+    
+    cfg = parse_args()
+    cfg_inference = parse_inference_args()
+    if cfg_inference.verbose:
+        show_cfg(cfg_inference)
+
+    all_moves = get_all_possible_moves()
+    all_moves_dict = {move: i for i, move in enumerate(all_moves)}
+    elo_dict = create_elo_dict()
+
+    model = MAIA2Model(len(all_moves), elo_dict, cfg)
+    model = nn.DataParallel(model)
+    
+    checkpoint = torch.load(cfg_inference.model_path, map_location='cpu')
+    model.load_state_dict(checkpoint['model_state_dict'])
+    model = model.module
+    
+    if cfg_inference.gpu:
+        model = model.cuda()
+    
+    all_moves_dict_reversed = {v: k for k, v in all_moves_dict.items()}
+    dataset = TestDataset(data, all_moves_dict, elo_dict)
+    dataloader = torch.utils.data.DataLoader(dataset, 
+                                            batch_size=cfg_inference.batch_size, 
+                                            shuffle=False, 
+                                            drop_last=False,
+                                            num_workers=cfg_inference.num_workers)
+    if cfg_inference.verbose:
+        dataloader = tqdm.tqdm(dataloader)
+    all_probs, predicted_move_probs, predicted_moves, predicted_win_probs = get_preds(model, dataloader, all_moves_dict_reversed, cfg_inference)
+    
+    data['predicted_move'] = predicted_moves
+    data['predicted_move_prob'] = predicted_move_probs
+    data['predicted_win_prob'] = predicted_win_probs
+    data['all_probs'] = all_probs.tolist()
+    
+    return data
+
+def parse_inference_args(args=None):
+
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('--verbose', default=1, type=int)
+    parser.add_argument('--batch_size', default=2048, type=int)
+    parser.add_argument('--num_workers', default=16, type=int)
+    parser.add_argument('--model_path', default='your_model_path', type=str)
+    parser.add_argument('--gpu', default=True, type=bool)
+
+    return parser.parse_args(args)
+
+def show_cfg(cfg):
+    print('Configurations:', flush=True)
+    for arg in vars(cfg):
+        print(f'\t{arg}: {getattr(cfg, arg)}', flush=True)
+
+
+if __name__ == '__main__':
+    
+    data = pd.read_csv('../data/all_reduced_rapid.csv')
+    data = data[data.move_ply > 10]
+    
+    data_novice = data[data['rounded_elo'] <= 1500][['board', 'move', 'active_elo', 'opponent_elo']]
+    data_intermediate = data[(data['rounded_elo'] > 1500) & (data['rounded_elo'] < 2000)][['board', 'move', 'active_elo', 'opponent_elo']]
+    data_advanced = data[data['rounded_elo'] >= 2000][['board', 'move', 'active_elo', 'opponent_elo']]
+    print(f'lens: {len(data_novice)}, {len(data_intermediate)}, {len(data_advanced)}', flush=True)
+    
+    results = []
+    for split in [data_novice, data_intermediate, data_advanced]:
+        inference_batch(split)
+        print(round(len(split[split['predicted_move'] == split['move']]) / len(split), 4))
+    
+    
+    
+