Démarrage

Installation

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

pip install alphacube

Utilisation

De base

Utiliser AlphaCube en Python est aussi simple que ceci :

import alphacube

# Charger un DNN entraîné
alphacube.load(model_id="small")  # le modèle par défaut

# Résoudre le cube en utilisant 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)

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
}

Améliorer la qualité

Si vous voulez des solutions encore plus courtes, augmentez simplement le paramètre beam_width :

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
}

Autoriser quelques mouvements supplémentaires

Vous voudrez peut-être obtenir non seulement les algorithmes les plus courts, mais aussi ceux légèrement redondants. De cette façon, vous pouvez réduire le risque de passer à côté d'excellents algorithmes.

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
}

Appliquer un biais ergonomique

Les biais ergonomiques vous permettent de spécifier numériquement la désirabilité de mouvements spécifiques qui semblent plus rapides et plus faciles à exécuter. Pour appliquer un biais ergonomique, fournissez un dictionnaire ergonomic_bias dans la méthode solve. Chaque mouvement (par exemple, "U", "U'", "U2") se voit attribuer un score, où des scores plus élevés indiquent des mouvements plus ergonomiques.

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
}

Accélération GPU

Si vous avez un GPU, nous vous recommandons fortement de sélectionner le plus grand modèle pour obtenir les meilleures performances possibles :

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
}

Mode verbeux

De plus, vous pouvez appeler alphacube.set_verbose() pour suivre la progression. Il affichera la profondeur actuelle de la recherche sur votre terminal.

Modèles et compromis

AlphaCube propose les trois plus grands modèles de l'article EfficientCube : "small", "base" et "large".

Bien que vous puissiez vous attendre à ce que le modèle "large" soit le plus performant (et "base" à être meilleur) en raison de leurs précisions plus élevées, ce n'est pratiquement pas le cas sans GPU.

En fait, sans GPU, le modèle "small" s'avère être le choix optimal pour un temps d'exécution CPU. C'est parce que les CPU passent intrinsèquement beaucoup de temps à calculer sur le DNN. Le modèle "small" s'avère être le plus efficace en termes de temps pour atteindre un certain niveau d'optimalité.

Bien qu'il soit moins précis que les modèles plus grands pour prédire les prochains mouvements, le modèle plus petit traite un lot d'états beaucoup plus rapidement. Par conséquent, si vous n'avez pas accès à des GPU, opter pour le modèle 'small' avec une largeur de faisceau suffisamment grande donne généralement les meilleures solutions dans le même laps de temps.

D'autre part, comme indiqué dans la figure ci-dessous, le plus grand modèle ("large") présente l'efficacité temporelle la plus élevée lorsqu'il est déployé sur un GPU.

Option CLI

Si vous préférez utiliser AlphaCube depuis l'interface de ligne de commande (CLI), vous pouvez le faire :

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 des drapeaux abrégés,

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 Référence de l'API > CLI.

Remarque : Veuillez noter que l'option CLI implique le chargement (et le déchargement) du modèle spécifié pour chaque requête. Par conséquent, cette option CLI serait mieux utilisée pour une exécution unique du package.