Zelfstudie: Selectorconcepten

Selectorconcepten zijn concepten die uitvoer produceren door een resultaat uit een van de verschillende optieconcepten te selecteren en te retourneren. De selector kiest een resultaat op basis van normale statusinformatie, net als bij een geleerd concept.

Selectors zijn handig wanneer het volgende waar is:

• U weet dat er verschillende vaardigheden of strategieën nodig zijn om een algemeen probleem op te lossen.
• U kunt elk onderdeelvaardigheden afzonderlijk ontwerpen, programmeren en trainen.
• U wilt dat de AI leert hoe u kunt bepalen wanneer elke vaardigheid moet worden gebruikt.

Selectors hoeven alleen maar uit de beschikbare opties te kiezen, zodat ze vaak robuuster en sneller zijn om te trainen dan één beleid dat alle relevante vaardigheden leert en wanneer ze moeten worden gebruikt. Met selectors kunt u ook geprogrammeerde of geïmporteerde vaardigheden combineren met geleerde concepten.

In deze zelfstudie leert u hoe u selectorconcepten definieert, traint en evalueert.

Stap 1: definieer vaardigheden of strategieën die u wilt selecteren

In deze stap definieert u de optieconcepten waar de selector uit kan kiezen. Alle optieconcepten moeten hetzelfde uitvoertype (actie) produceren, zodat de selector een keuze maakt uit vergelijkbare gestructureerde resultaten.

De volgende code is gebaseerd op het Cartpole-voorbeeld. Het cartpole-probleem vraagt de AI om een winkelwagen naar een doelregio te verplaatsen terwijl een carpool in het midden van de winkelwagen in balans blijft. In plaats van één geleerd concept te ontwikkelen om het probleem op te lossen, maakt u twee geleerde concepten waarbij de AI leert om afzonderlijk naar rechts en links te gaan en vervolgens een selectorconcept gebruikt om te kiezen uit de twee opties om de winkelwagen te verplaatsen.

Met GoLeft het concept wordt de winkelwagen naar links verplaatst terwijl de pool het volgende doet:

    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
                }
            }
        }
    }

En met GoRight het concept wordt de winkelwagen naar rechts verplaatst terwijl de pool het goed doet:

    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
                }
            }
        }
    }

Stap 2: een selector toevoegen

Nu de optieconcepten zijn gedefinieerd, moet u het curriculum voor uw selectorconcept definiëren met behulp van de standaardconceptsyntaxis:

    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
                }
            }
       }

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

Stap 3: de concepten trainen

U moet de geleerde concepten afzonderlijk trainen en de prestaties van elke optie beoordelen om ervoor te zorgen dat ze werken voordat u de selector traint.

In de onderstaande schermopname ziet u het Inkling-bestand en het trainingsplan voor training ComputeDelta en GoLeft vervolgens GoRightPickOne .

Bonsai Teaching UI" aria-describedby="153-0" data-linktype="relative-path">

Stap 4: Evalueren

Gebruik aangepaste evaluaties om te onderzoeken hoe de selector leert met behulp van het normale beoordelingsproces. Als u selectorconcepten evalueert, ziet u het geselecteerde concept en de resulterende actie.

Raadpleeg de zelfstudie Beoordelingsgegevens van het brein evalueren voor meer informatie over evaluatie.