Przejdź do głównej zawartości

Pierwsze kroki

Instalacja​

Aby zainstalować AlphaCube, otwórz terminal i uruchom następujące polecenie:

pip install alphacube

Użycie​

Podstawy​

Używanie AlphaCube w Pythonie jest tak proste, jak to:

import alphacube

# Załaduj wytrenowaną sieć DNN
alphacube.load(model_id="small")  # domyślny model

# Rozwiąż kostkę używając danego pomieszania
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)
Wynik
{
    '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
}

Poprawa jakości​

Jeśli chcesz jeszcze krótszych rozwiązań, po prostu zwiększ parametr 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)
Wynik
{
    '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
}

Dopuszczanie kilku dodatkowych ruchów​

Możesz chcieć uzyskać nie tylko najkrótsze algorytmy, ale także nieco nadmiarowe. W ten sposób możesz zmniejszyć ryzyko przeoczenia świetnych algorytmów.

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

Zastosowanie ergonomicznego obciążenia​

Ergonomiczne obciążenia pozwalają numerycznie określić pożądane konkretne ruchy, które wydają się szybsze i łatwiejsze do wykonania. Aby zastosować ergonomiczne obciążenie, podaj słownik ergonomic_bias w metodzie solve. Każdemu ruchowi (np. "U", "U'", "U2") przypisywany jest wynik, gdzie wyższe wyniki wskazują na bardziej ergonomiczne ruchy.

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

Przyspieszenie GPU​

Jeśli masz GPU, zdecydowanie zalecamy wybranie największego modelu, aby uzyskać najlepszą możliwą wydajność:

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)
Wynik
{
    'solutions': ["D F L' F' U2 B2 U F' L R2 B2 U D' F2 U2 R D'"],
    'num_nodes': 903448,
    'time': 20.46845487099995
}

Tryb szczegółowy​

Dodatkowo możesz wywołać alphacube.set_verbose(), aby śledzić postęp. Wyświetli to aktualną głębokość wyszukiwania w Twoim terminalu.

Modele i kompromisy​

AlphaCube oferuje trzy największe modele z artykułu EfficientCube: "small", "base" i "large".

Chociaż możesz oczekiwać, że model "large" będzie działał najlepiej (a "base" lepiej) ze względu na ich wyższą dokładność, w praktyce nie jest to przypadek bez GPU.

W rzeczywistości, bez GPU, model "small" okazuje się optymalnym wyborem dla czasu działania CPU. Dzieje się tak, ponieważ procesory CPU z natury spędzają dużo czasu na obliczeniach na DNN. Model "small" okazuje się być najbardziej czasowo efektywny w osiąganiu pewnego poziomu optymalności.

Kompromis między ilością obliczeń a jakością rozwiązania na CPU

Chociaż jest mniej dokładny niż większe modele w przewidywaniu następnych ruchów, mniejszy model przetwarza partię stanów znacznie szybciej. Dlatego, jeśli nie masz dostępu do GPU, wybór modelu 'small' z wystarczająco szeroką szerokością wiązki zazwyczaj daje najlepsze rozwiązania w tym samym przedziale czasowym.

Z drugiej strony, jak pokazano na poniższym rysunku, największy model ("large") wykazuje najwyższą efektywność czasową po wdrożeniu na GPU.

Kompromis między ilością obliczeń a jakością rozwiązania na GPU

Opcja CLI​

Jeśli wolisz używać AlphaCube z interfejsu wiersza poleceń (CLI), możesz to zrobić:

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

Ze skróconymi flagami,

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

Więcej szczegółów znajdziesz w Dokumentacji API > CLI.

Uwaga: Pamiętaj, że opcja CLI wiąże się z ładowaniem (i rozładowywaniem) określonego modelu dla każdego żądania. Dlatego ta opcja CLI byłaby najlepiej używana do jednorazowego wykonania pakietu.