Getting Started

Installation

To install AlphaCube, open a terminal and run the following command:

pip install alphacube

Usage

Basic

Using AlphaCube in Python is as simple as this:

import alphacube

# Load a trained DNN
alphacube.load(model_id="small")  # the default model

# Solve the cube using a given scramble
result = alphacube.solve(
    scramble="D U F2 L2 U' B2 F2 D L2 U R' F' D R' F' U L D' F' D R2",
    beam_width=1024,
)
print(result)

Output

{
    'solutions': [
        "D L D2 R' U2 D B' D' U2 B U2 B' U' B2 D B2 D' B2 F2 U2 F2"
    ],
    'num_nodes': 19744,
    'time': 1.4068585219999659
}

Improving Quality

If you want even shorter solutions, simply increase the beam_width parameter:

alphacube.load()  # model_id="small"
result = alphacube.solve(
    scramble="D U F2 L2 U' B2 F2 D L2 U R' F' D R' F' U L D' F' D R2",
    beam_width=65536,
)
print(result)

Output

{
    'solutions': [
        "D' R' D2 F' L2 F' U B F D L D' L B D2 R2 F2 R2 F'",
        "D2 L2 R' D' B D2 B' D B2 R2 U2 L' U L' D' U2 R' F2 R'"
    ],
    'num_nodes': 968984,
    'time': 45.690575091997744
}

Allowing A Few Extra Moves

You may want to obtain not just the shortest algorithms but also slightly redundant ones. That way, you can reduce the risk of overlooking great algorithms.

alphacube.load()  # model_id="small"
result = alphacube.solve(
    scramble="D U F2 L2 U' B2 F2 D L2 U R' F' D R' F' U L D' F' D R2",
    beam_width=65536,
    extra_depths=1
)
print(result)

Output

{
    'solutions': [
        "D' R' D2 F' L2 F' U B F D L D' L B D2 R2 F2 R2 F'",
        "D2 L2 R' D' B D2 B' D B2 R2 U2 L' U L' D' U2 R' F2 R'",
        "D R F2 L' U2 R2 U2 R2 B2 U' F B2 D' F' D' R2 F2 U F2 L2",
        "L' D' R' D2 L B' U F2 U R' U' F B' R2 B R B2 F D2 B",
        "R' F L2 D R2 U' B' L' U2 F2 U L U B2 U2 R2 D' U B2 R2",
        "L' U' F' R' U D B2 L' B' R' B U2 B2 L2 D' R2 U' D R2 U2"
    ],
    'num_nodes': 1100056,
    'time': 92.809575091997744
}

Applying Ergonomic Bias

Ergonomic biases allow you to numerically specify the desirability of specific moves that feel faster & easier to execute. To apply ergonomic bias, provide a ergonomic_bias dictionary in the solve method. Each move (e.g., "U", "U'", "U2") is assigned a score, where higher scores indicate more ergonomic moves.

ergonomic_bias = {
    "U": 0.9,   "U'": 0.9,  "U2": 0.8,
    "R": 0.8,   "R'": 0.8,  "R2": 0.75,
    "L": 0.55,  "L'": 0.4,  "L2": 0.3,
    "F": 0.7,   "F'": 0.6,  "F2": 0.6,
    "D": 0.3,   "D'": 0.3,  "D2": 0.2,
    "B": 0.05,  "B'": 0.05, "B2": 0.01,
    "u": 0.45,  "u'": 0.45, "u2": 0.4,
    "r": 0.3,   "r'": 0.3,  "r2": 0.25,
    "l": 0.2,   "l'": 0.2,  "l2": 0.15,
    "f": 0.35,  "f'": 0.3,  "f2": 0.25,
    "d": 0.15,  "d'": 0.15, "d2": 0.1,
    "b": 0.03,  "b'": 0.03, "b2": 0.01
}

result = alphacube.solve(
    scramble="D U F2 L2 U' B2 F2 D L2 U R' F' D R' F' U L D' F' D R2",
    beam_width=65536,
    ergonomic_bias=ergonomic_bias
)
print(result)

Output

{
    'solutions': [
        "u' U' f' R2 U2 R' L' F' R D2 f2 R2 U2 R U L' U R L",
        "u' U' f' R2 U2 R' L' F' R D2 f2 R2 U2 R d F' U f F",
        "u' U' f' R2 U2 R' L' F' R u2 F2 R2 D2 R u f' l u U"
    ],
    'num_nodes': 1078054,
    'time': 56.13087955299852
}

GPU Acceleration

If you have a GPU, we highly recommend you select the largest model for the best possible performance:

alphacube.load(model_id="large")
result = alphacube.solve(
    scramble="D U F2 L2 U' B2 F2 D L2 U R' F' D R' F' U L D' F' D R2",
    beam_width=65536,
)
print(result)

Output

{
    'solutions': ["D F L' F' U2 B2 U F' L R2 B2 U D' F2 U2 R D'"],
    'num_nodes': 903448,
    'time': 20.46845487099995
}

Verbose Mode

Additionally, you may call alphacube.set_verbose() to keep track of the progress. It will display the current depth of search on your terminal.

Models & Trade-Off

AlphaCube offers the three largest models from the EfficientCube paper: "small", "base", and "large".

Although you may expect the "large" model to perform best (and "base" to perform better) due to their higher accuracies, this is practically not the case without a GPU.

In fact, without a GPU, the "small" model emerges as the optimal choice for a CPU runtime. This is because CPUs inherently spend a lot of time computing on DNN. The "small" model proves to be the most time-efficient in achieving a certain level of optimality.

Although it is less accurate than the larger models in predicting the next moves, the smaller model processes a batch of states much faster. Therefore, if you lack access to GPUs, opting for the 'small' model with a sufficiently wider beam width generally yields the best solutions within the same time frame.

On the other hand, as indicated in the figure below, the largest model ("large") exhibits the highest temporal efficiency when deployed on a GPU.

CLI Option

If you prefer using AlphaCube from command line interface (CLI), you can do so:

alphacube \
    --model_id large \
    --scramble "F U2 L2 B2 F U L2 U R2 D2 L' B L2 B' R2 U2" \
    --beam_width 100000 \
    --extra_depths 3 \
    --verbose

With abbreviated flags,

alphacube \
    -m large \
    -s "F U2 L2 B2 F U L2 U R2 D2 L' B L2 B' R2 U2" \
    -bw 100000 \
    -ex 3 \
    -v

Please find more details at API Reference > CLI.

Note: Please be aware that the CLI option involves loading (and unloading) the specified model for every request. Therefore, this CLI option would be best used for one-time execution of the package.