Chessora V1 Lite

Chessora V1 Lite is a custom neural chess policy/value network. Given a chess position, it scores candidate moves and predicts win/draw/loss logits. It is designed to work with the matching Chess-Engine project, which handles legal moves and can add search on top of the network. It is not a Transformers model and does not currently provide a Hugging Face inference widget.

Model details

  • Checkpoint: chess-model5.safetensors
  • Architecture: custom convolutional residual network (ChessNet), with a policy adapter
  • Parameters: 25.47 million
  • Input: 18 planes encoding pieces, side to move, castling rights, and the en-passant square
  • Policy output: logits for the model's move classes; select among legal moves only
  • Value output: three logits for win, draw, and loss
  • Format: Safetensors weights; architecture configuration is stored in the file metadata

Download

from huggingface_hub import hf_hub_download

checkpoint_path = hf_hub_download(
    repo_id="aivora-ai/chessora-v1-lite",
    filename="chess-model5.safetensors",
)
print(checkpoint_path)

Load with Chess-Engine

Install the Chess-Engine project dependencies, including safetensors, then load the weights and model configuration:

import json
from pathlib import Path

import chess
import torch
from safetensors import safe_open

from chess_engine.engine import choose_move, get_device
from chess_engine.model import ChessNet

device = get_device("auto")
checkpoint_path = Path("chess-model5.safetensors")

with safe_open(str(checkpoint_path), framework="np") as checkpoint:
    metadata = checkpoint.metadata() or {}
    config_json = metadata.get("model_config")
    if config_json is None:
        raise ValueError("The checkpoint is missing its model_config metadata.")
    model_config = json.loads(config_json)
    state_dict = {
        name: torch.from_numpy(checkpoint.get_tensor(name).copy())
        for name in checkpoint.keys()
    }

model = ChessNet(**model_config)
model.load_state_dict(state_dict)
model.to(device)
model.eval()

board = chess.Board()
move = choose_move(board, depth=3, model=model, device=device)
print(board.san(move))

Limitations

  • No independently verified Elo rating or benchmark result is claimed.
  • Playing strength depends on the search depth, time control, and evaluation used by the surrounding engine.
  • The model's move scores are not chess moves by themselves; always restrict selection to legal moves.
  • This custom chess task is tagged other because the Hub does not provide a dedicated chess-move-prediction pipeline task.

License

This repository is marked as MIT-licensed. Check the project and dataset terms before redistributing a combined package or training data.

Downloads last month

-

Downloads are not tracked for this model. How to track
Inference Providers NEW
This model isn't deployed by any Inference Provider. ๐Ÿ™‹ Ask for provider support