Aller au contenu principal

env

Environnement du Rubik's Cube

Ce module définit la classe Cube3 représentant un Rubik's Cube 3x3x3 dans la métrique des demi-tours (Half-Turn Metric).

Classe : Cube3 : Une classe pour le Rubik's Cube 3x3x3 dans la métrique des demi-tours (Half-Turn Metric).

Cube3​

class Cube3()

Une classe pour le Rubik's Cube 3x3x3 dans la métrique des demi-tours (Half-Turn Metric, HTM).

Cette classe fournit des méthodes pour manipuler et résoudre un Rubik's Cube 3x3x3 en utilisant la métrique des demi-tours. Elle définit les états initial et résolu du cube, les mouvements disponibles et les méthodes de manipulation du cube.

Représentation :

Ordre des faces :

   0
 2 5 3 4
   1

Ordre des autocollants sur chaque face :

  2   5   8
  1   4   7
 [0]  3   6

Indices de l'état (chacun commençant par 9 * (n-1)) :

                2   5   8
                1   4   7
               [0]  3   6
  20  23  26   47  50  53  29  32  35  38  41  44
  19  22  25   46  49  52  28  31  34  37  40  43
 [18] 21  24  [45] 48  51 [27] 30  33 [36] 39  42
               11  14  17
               10  13  16
               [9] 12  15

Couleurs (indices // 9) :

                0   0   0
                0   0   0
                0   0   0
   2   2   2    5   5   5   3   3   3   4   4   4
   2   2   2    5   5   5   3   3   3   4   4   4
   2   2   2    5   5   5   3   3   3   4   4   4
                1   1   1
                1   1   1
                1   1   1

Attributs :

  • state ndarray - État actuel du cube représenté par un tableau des couleurs des autocollants.
  • GOAL ndarray - État résolu fixe représenté par un tableau des couleurs des autocollants.
  • moves list - Liste des mouvements possibles du cube (face et direction).
  • allow_wide bool - Indicateur précisant si les mouvements larges (wide moves) sont autorisés.
  • max_depth int - La profondeur de mélange maximale pour le générateur de données.
  • sticker_target dict - Un dictionnaire associant les chaînes de mouvements à des listes d'indices d'autocollants cibles.
  • sticker_source dict - Un dictionnaire associant les chaînes de mouvements à des listes d'indices d'autocollants sources.
  • sticker_target_ix ndarray - Un tableau numpy 2D associant les indices de mouvements aux indices d'autocollants cibles pour les mouvements normaux.
  • sticker_source_ix ndarray - Un tableau numpy 2D associant les indices de mouvements aux indices d'autocollants sources pour les mouvements normaux.
  • sticker_target_ix_wide ndarray - Un tableau numpy 2D associant les indices de mouvements aux indices d'autocollants cibles pour les mouvements larges.
  • sticker_source_ix_wide ndarray - Un tableau numpy 2D associant les indices de mouvements aux indices d'autocollants sources pour les mouvements larges.

show​

def show(
    flat=False,
    palette=["white", "yellow", "orange1", "red", "blue", "green"]
)

Affiche l'état actuel du cube.

Arguments :

  • flat bool - Indique s'il faut afficher l'état sous forme dépliée.
  • palette list - Liste de couleurs pour représenter les autocollants.

validate​

def validate(
    state=None,
    centered=True
)

Valide l'état et l'agencement du cube.

Arguments :

  • centered bool - Indique si les centres doivent être centrés ou non.

Lève :

  • ValueError - Si l'état ou l'agencement du cube est invalide.

reset​

def reset()

Réinitialise l'état du cube à l'état résolu.

reset_axes​

def reset_axes()

Réinitialise les indices de couleur en fonction des couleurs des centres données. Utile lorsque des mouvements larges (fat moves) sont appliqués ou lorsqu'une perspective inattendue est spécifiée.

is_solved​

def is_solved()

Vérifie si le cube est dans l'état résolu.

finger​

def finger(move)

Applique un seul mouvement à l'état du cube en utilisant une chaîne de caractères.

Arguments :

  • move str - Chaîne de mouvement en notation HTM.

finger_ix​

def finger_ix(ix)

Applique un seul mouvement en utilisant son indice pour une exécution plus rapide que .finger. Vérifie si l'indice du mouvement correspond à un mouvement normal (ix < 18) ou à un mouvement large et applique le changement d'état en utilisant des tableaux d'indices pré-calculés.

Arguments :

  • ix int - Indice du mouvement à appliquer.

apply_scramble​

def apply_scramble(scramble)

Applique une séquence de mouvements (mélange) à l'état du cube.

Arguments :

  • scramble str ou list - Séquence de mouvements en notation HTM ou sous forme de liste.

__iter__​

def __iter__()

Crée un générateur infini d'états mélangés et de séquences de solution.

Cette méthode est destinée à l'entraînement du modèle. À chaque itération, elle génère un nouveau mélange aléatoire de max_depth mouvements, en évitant les séquences de mouvements triviales. Elle produit (yields) l'historique des états et le mouvement correspondant qui a mené à chaque état.

Produit :

tuple[np.ndarray, np.ndarray]: Un tuple contenant :

  • X (np.ndarray): Un tableau (max_depth, 54) des états du cube.
  • y (np.ndarray): Un tableau (max_depth,) des indices de mouvements qui ont généré les états.

__vectorize_moves​

def __vectorize_moves()

Vectorise les opérations de remplacement de groupes d'autocollants pour un calcul plus rapide. Cette méthode définit self.sticker_target et self.sticker_source pour gérer les couleurs des autocollants (la cible est remplacée par la source). Ils définissent les indices des autocollants cibles et sources afin que les mouvements puissent être vectorisés.

Dataset​

class Dataset(torch.utils.data.Dataset)

Classe de pseudo-dataset pour produire (yield) à l'infini des mélanges aléatoires.

Exemple
batch_size = 1024
dl = get_dataloader(batch_size)
for i, (batch_x, batch_y) in zip(range(1000), dl):
    batch_x, batch_y = batch_x.to(device), batch_y.device().reshape(-1)

get_dataloader​

def get_dataloader(
    batch_size,
    num_workers=min(os.cpu_count(), 32), max_depth=20,
    **dl_kwargs
)

Crée une instance de DataLoader pour générer des mélanges de Rubik's Cube aléatoires.

Arguments :

  • batch_size int - Le nombre d'échantillons par lot.
  • num_workers int, optionnel - Le nombre de processus workers à utiliser pour le chargement des données. Par défaut, le nombre de cœurs CPU ou 32 (au-delà duquel le gain diminue), la plus petite de ces deux valeurs étant retenue.
  • max_depth int, optionnel - La profondeur maximale des mélanges. Par défaut, 20.
  • **dl_kwargs - Arguments mot-clé supplémentaires à passer au constructeur du DataLoader.

Retourne :

  • torch.utils.data.DataLoader - Une instance de DataLoader qui produit des lots de mélanges aléatoires.