Primeros Pasos

Instalación

Para instalar AlphaCube, abre una terminal y ejecuta el siguiente comando:

pip install alphacube

Uso

Básico

Usar AlphaCube en Python es tan simple como esto:

import alphacube

# Cargar una DNN entrenada
alphacube.load(model_id="small")  # el modelo por defecto

# Resolver el cubo usando un scramble dado
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
}

Mejorando la Calidad

Si deseas soluciones aún más cortas, simplemente aumenta el parámetro 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
}

Permitiendo Algunos Movimientos Extra

Es posible que desees obtener no solo los algoritmos más cortos, sino también algunos ligeramente redundantes. De esa manera, puedes reducir el riesgo de pasar por alto grandes algoritmos.

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
}

Aplicando Sesgo Ergonómico

Los sesgos ergonómicos te permiten especificar numéricamente la deseabilidad de movimientos específicos que se sienten más rápidos y fáciles de ejecutar. Para aplicar sesgo ergonómico, proporciona un diccionario ergonomic_bias en el método solve. A cada movimiento (por ejemplo, "U", "U'", "U2") se le asigna una puntuación, donde puntuaciones más altas indican movimientos más ergonómicos.

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
}

Aceleración por GPU

Si tienes una GPU, te recomendamos encarecidamente que selecciones el modelo más grande para obtener el mejor rendimiento posible:

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
}

Modo Detallado

Además, puedes llamar a alphacube.set_verbose() para realizar un seguimiento del progreso. Mostrará la profundidad actual de búsqueda en tu terminal.

Modelos y Compensación

AlphaCube ofrece los tres modelos más grandes del artículo EfficientCube: "small", "base" y "large".

Aunque podrías esperar que el modelo "large" tenga el mejor rendimiento (y que "base" funcione mejor) debido a sus mayores precisiones, en la práctica este no es el caso sin una GPU.

De hecho, sin una GPU, el modelo "small" emerge como la opción óptima para un tiempo de ejecución en CPU. Esto se debe a que las CPU inherentemente pasan mucho tiempo computando en DNN. El modelo "small" demuestra ser el más eficiente en tiempo para lograr un cierto nivel de optimalidad.

Aunque es menos preciso que los modelos más grandes para predecir los siguientes movimientos, el modelo más pequeño procesa un lote de estados mucho más rápido. Por lo tanto, si no tienes acceso a GPUs, optar por el modelo 'small' con un ancho de haz suficientemente amplio generalmente produce las mejores soluciones dentro del mismo marco de tiempo.

Por otro lado, como se indica en la figura a continuación, el modelo más grande ("large") exhibe la mayor eficiencia temporal cuando se implementa en una GPU.

Opción CLI

Si prefieres usar AlphaCube desde la interfaz de línea de comandos (CLI), puedes hacerlo:

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

Con banderas abreviadas,

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

Por favor, encuentra más detalles en Referencia de API > CLI.

Nota: Ten en cuenta que la opción CLI implica cargar (y descargar) el modelo especificado para cada solicitud. Por lo tanto, esta opción CLI sería mejor usarla para una ejecución única del paquete.