Tutoriel : Concepts du sélecteur

Le concept de sélecteur est des concepts appris qui produisent la sortie en sélectionnant et en retournant un résultat à partir de l’un des plusieurs concepts d’option. Le sélecteur choisit un résultat en fonction des informations d’état normales comme un concept appris.

Les sélecteurs sont utiles quand ce qui suit est vrai :

  • Vous savez que plusieurs compétences ou stratégies sont nécessaires pour résoudre un problème global.
  • Vous pouvez concevoir, programmer et entraîner chacune des compétences des composants séparément.
  • Vous souhaitez que l’IA apprenne à déterminer quand chaque compétence doit être utilisée.

Les sélecteurs doivent simplement choisir parmi les options disponibles, de sorte qu’ils sont souvent plus robustes et plus rapides à former qu’une seule stratégie qui apprend toutes les compétences pertinentes et quand les utiliser. Les sélecteurs vous permettent également de combiner des compétences programmées ou importées avec des concepts appris.

Dans ce tutoriel, vous allez apprendre à définir, entraîner et évaluer les concepts du sélecteur.

Étape 1 : Définir des compétences ou des stratégies que vous souhaitez sélectionner parmi

Dans cette étape, vous allez définir les concepts d’option du sélecteur à choisir. Tous les concepts d’option doivent produire le même type de sortie (action) afin que le sélecteur choisisse parmi les résultats de même structure.

Le code suivant est basé sur l’exemple Cartpole . Le problème du cartpole demande à l’IA de déplacer un chariot vers une région cible tout en conservant un pôle droit équilibré au centre du chariot. Au lieu de développer un concept appris pour résoudre le problème, vous allez créer deux concepts appris où l’IA apprend à passer séparément, puis utiliser un concept de sélecteur pour choisir parmi les deux options pour déplacer le panier.

Le GoLeft concept déplace le chariot à gauche tout en conservant le pôle droit :

    concept GoLeft(ComputeDelta): Action {
        curriculum {
            source CartpoleSim
            goal (state: SimState) {
                avoid FallOver:
                    Math.Abs(state.pole_angle) in Goal.RangeAbove(MaxPoleAngle)

                # There isn't a specific "close enough" threshold, so using
                # Goal.RangeBelow(0) to encourage the system to minimize as well as it can
                minimize DistToTarget:
                    Math.Abs(state.target_pole_position - state.cart_position) in Goal.RangeBelow(0)
            }
            training {
                EpisodeIterationLimit: 200,
            }
            lesson One {
                # Because we're using relative positions, just need to randomize initial position to be far and close to the target.
                # "GoLeft" starts the cart to the right of the target.
                scenario {
                    initial_cart_position: number<0 .. MaxPosition>,
                    target_pole_position: 0
                }
            }
        }
    }

Et le GoRight concept déplace le chariot à droite tout en maintenant le pôle droit :

    concept GoRight(ComputeDelta): Action {
        curriculum {
            source CartpoleSim
            goal (state: SimState) {
                avoid FallOver:
                    Math.Abs(state.pole_angle) in Goal.RangeAbove(MaxPoleAngle)

                # There isn't a specific "close enough" threshold, so using
                # Goal.RangeBelow(0) to encourage the system to minimize as well as it can
                minimize DistToTarget:
                    Math.Abs(state.target_pole_position - state.cart_position) in Goal.RangeBelow(0)
            }
            training {
                EpisodeIterationLimit: 200,
            }
            lesson One {
                # Because we're using relative positions, just need to randomize initial position to be far and close to the target.
                # "GoRight" starts the cart to the left of the target.
                scenario {
                    initial_cart_position: number<-MaxPosition .. 0>,
                    target_pole_position: 0
                }
            }
        }
    }

Étape 2 : Ajouter un sélecteur

Maintenant que les concepts d’option sont définis, vous devez définir le programme pour votre concept de sélecteur à l’aide de la syntaxe de concept standard :

    output concept PickOne(ComputeDelta): Action {
       select GoRight
       select GoLeft
       curriculum {
            source CartpoleSim
            training {
                EpisodeIterationLimit: 200,
                NoProgressIterationLimit: 1000000,
            }
            goal (state: SimState) {
                avoid FallOver: Math.Abs(state.pole_angle) in Goal.RangeAbove(MaxPoleAngle)
                minimize DistToTarget: Math.Abs(state.target_pole_position - state.cart_position) in Goal.RangeBelow(0)
            }
            lesson One {
                # Because we're using relative positions, just need to randomize initial position to be far and close to the target
                # "PickOne" starts at a random position within the full range.
                scenario {
                    initial_cart_position: number<-MaxPosition .. MaxPosition>,
                    target_pole_position: 0
                }
            }
       }

Notes

Si vous pouvez programmer directement une règle pour sélectionner le concept à utiliser, vous pouvez utiliser un concept programmé au lieu d’un sélecteur appris. Par exemple :

programmed function(state: LearningState, left_action: Action, right_action: Action) : Action {
 if state.distance_to_target > 0 { return right_action }     
 else { return left_action }
}

Étape 3 : Entraîner les concepts

Vous devez entraîner les concepts appris individuellement et évaluer les performances de chaque option pour vous assurer qu’elles fonctionnent avant d’entraîner le sélecteur.

La capture d’écran ci-dessous montre le fichier Inkling et le plan d’entraînement pour l’entraînement ComputeDelta, puis GoLeftGoRight, puis PickOne.

Bonsai Teaching UI

Capture d’écran de l’interface Bonsai utilisateur d’enseignement avec l’exemple de code Inkling dans le panneau de codage et un diagramme de formation qui affiche les concepts ComputeDelta, GoLeft, GoRight et PickOne dans l’ordre dans lequel ils seront formés.

Conseil

Si vous souhaitez modifier un concept, modifiez simplement Inkling et réentraînez le cerveau. Bonsai crée automatiquement une nouvelle version du cerveau et conserve toute progression d’entraînement pour les concepts non affectés par le changement. Par exemple, vous pouvez ajouter un StopCart concept à l’exemple cartpole, l’entraîner, puis l’ajouter select StopCart au sélecteur. Lorsque vous réentraînez le cerveau, il force le sélecteur à réentraîner, mais pas GoLeft ou GoRight.

Étape 4 : Évaluer

Utilisez des évaluations personnalisées pour examiner la façon dont le sélecteur apprend à l’aide du processus d’évaluation normal. L’évaluation des concepts du sélecteur vous montre le concept sélectionné ainsi que l’action résultante.

Pour en savoir plus sur l’évaluation, reportez-vous au didacticiel Évaluer les données d’évaluation du cerveau .