Pour commencer

Installation

Pour installer AlphaCube, ouvrez un terminal et exécutez la commande suivante :

pip install -U alphacube

Utilisation

Utilisation de base

Utiliser AlphaCube en Python est simple. La première fois que alphacube.load() est appelée, les données du modèle requises seront téléchargées et mises en cache.

import alphacube

# Charger un modèle pré-entraîné
# Par défaut "small" sur CPU, "large" sur GPU
alphacube.load()

# Résoudre le cube à partir d'un mélange donné
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)

Sortie

{
    '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,        # Nœuds de recherche totaux explorés
    'time': 1.4068585219999659 # Temps en secondes
}

Améliorer la qualité de la solution

Si vous souhaitez des solutions plus courtes, augmentez le paramètre beam_width. Cela rend la recherche plus exhaustive au prix d'un temps de calcul plus élevé.

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)

Sortie

{
    '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
}

Autoriser quelques mouvements supplémentaires

Vous pouvez obtenir non seulement les solutions les plus courtes, mais aussi des solutions légèrement plus longues, en utilisant le paramètre extra_depths. Cela indique au solveur de continuer la recherche après la découverte de la première solution.

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)

Sortie

{
    '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",  # supplémentaire
        "L' D' R' D2 L B' U F2 U R' U' F B' R2 B R B2 F D2 B",      # supplémentaire
        "R' F L2 D R2 U' B' L' U2 F2 U L U B2 U2 R2 D' U B2 R2",    # supplémentaire
        "L' U' F' R' U D B2 L' B' R' B U2 B2 L2 D' R2 U' D R2 U2"   # supplémentaire
    ],
    'num_nodes': 1100056,
    'time': 92.809575091997744
}

Accélération GPU

Si vous disposez d'un GPU compatible ou d'un Mac, vous pouvez obtenir une accélération significative en chargeant un modèle large.

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)

Sortie

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

Appliquer un biais ergonomique

Pour trouver des solutions plus faciles à exécuter manuellement, fournissez un dictionnaire ergonomic_bias à la méthode solve. Chaque mouvement se voit attribuer un score, où les scores plus élevés indiquent des mouvements plus désirables. Cela active également les mouvements larges comme u et r.

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)

Sortie

{
    '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
}

Modèles et compromis

AlphaCube propose trois modèles entraînés de manière optimale en termes de calcul, issus de l'article original : "small", "base" et "large".

Bien que les modèles plus grands soient plus précis, le meilleur choix dépend de votre matériel.

• Sur un CPU, le modèle "small" est souvent le choix le plus efficace en termes de temps.
• Sur un GPU, le modèle "large" affiche les meilleures performances et trouve les meilleures solutions dans le temps le plus court.

Option CLI

Si vous préférez utiliser alphacube depuis la ligne de commande, vous pouvez le faire ainsi :

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

Avec les options abrégées,

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

Veuillez trouver plus de détails dans la Référence API > CLI.

Note : La CLI charge le modèle spécifié à chaque exécution, ce qui la rend plus adaptée aux commandes à usage unique qu'à la résolution répétée dans un script.