Nyckelord: Lektion

Lektioner är ett mellansteg för att lära ut ett begrepp. Mellanlagring av en läroplan är användbar för:

  • manuell läroplanstillväxt: AI börjar med enklare uppgifter och kommer så småningom upp till svårare uppgifter.
  • domän randomisering: startvillkoren för AI är slumpmässiga per avsnitt.

Välstrukturerade lektioner kan minska den totala tid det tar att träna din AI på ett koncept.

Användning

Du kan använda flera lektioner i en läroplan. När en läroplan innehåller mer än en lektion utförs lektionerna i den ordning de deklareras.

En scenario -sats kan användas för att begränsa simulatorn för den associerade lektionen. scenario När satsen används bör efterföljande lektioner inkrementellt minska begränsningarna så att utforskningsutrymmet blir större och det associerade konceptet svårare att bemästra.

Till exempel ska en intervallbegränsning som används i ett visst lektionsscenario vara lika med, eller mindre restriktiv än, motsvarande scenariobegränsning som användes i en föregående lektion.

Träningsparametrar för lektion

Du kan justera följande träningsparametrar för lektionen med -satsen training :

Parameter Värden Standardvärde Beskrivning
LessonRewardThreshold number Ingen Minsta belöning som räknas som lyckad.
LessonSuccessThreshold number<0 .. 1> 0.90 (90%) Minsta slutförandefrekvens för att slutföra lektionen.
LessonAssessmentWindow Number.UInt32 30 Antal avsnitt per utvärdering. Används för att beräkna LessonRewardThreshold och LessonSuccessThreshold.

Parametervärden som anges på lektionsnivå åsidosätter alla värden som kan ha angetts på läroplansnivå.

Till exempel:

concept MyConcept(input: SimState): BrainAction {
  curriculum {
    training {
      EpisodeIterationLimit: 250,
      TotalIterationLimit: 100000
    }

    ...

    lesson MyLesson {
      training {
        LessonRewardThreshold: 120
      }
    }
  }
}

LessonRewardThreshold

Stöds endast för belönings- och terminalfunktionsbaserad läroplan.

När en tillräcklig del av testavsnitten i en utvärdering ( LessonSuccessThresholdsom anges av ) LessonRewardThreshold har en kumulativ belöning som uppfyller eller överskrider värdet, tar träningsmotorn hänsyn till att lektionen är slutförd och går vidare till nästa lektion i läroplanen.

Om lektionsdefinitionen inte innehåller ett tröskelvärde för belöning använder träningsmotorn ett allmänt konvergenstest för att avgöra när lektionen är klar.

LessonSuccessThreshold

När frekvensen för lyckade avsnitt i en LessonSuccessThreshold utvärdering överskrider värdet tar träningsmotorn hänsyn till att lektionen är slutförd och går vidare till nästa lektion i läroplanen.

Värdet måste vara mellan 0 och 1 och representerar ett målvärde.

LessonAssessmentWindow

Anger antalet testavsnitt per utvärdering. Utvärderingar är grupper av testavsnitt som körs regelbundet för att utvärdera AI under träningen. Lektionsövergångar baserade på LessonSuccessThreshold parametrarna LessonRewardThreshold och utvärderas efter varje utvärdering. Automatisk avslutning av träningen (se NoProgressIterationLimit) baseras också på utvärderingsprestanda.

Exempel på flera lektioner

I det här exemplet bryter lektionerna uppgiften att styra en kula på en Moab-tavla i två steg:

  • RandomizedStartLowVelocity: tränar AI med låg hastighet som varierar.
  • RandomizedStartMediumVelocity: tränar AI med en medelhög hastighet som varierar.

Den typ som anges efter nyckelordet scenario i exemplet måste vara kompatibel med konfigurationstypen som definierats i simulatordeklarationen (ObservableState).

# Distances measured in meters
const RadiusOfPlate = 0.1125 # m

# Velocities measured in meters per sec.
const MaxVelocity = 6.0
const MaxInitialVelocity = 1.0

# Default time delta between simulation steps (s)
const DefaultTimeDelta = 0.045

# Maximum distance per step in meters
const MaxDistancePerStep = DefaultTimeDelta * MaxVelocity

# State received from the simulator after each iteration
type ObservableState {
    # Ball X,Y position
    ball_x: number<-MaxDistancePerStep - RadiusOfPlate .. RadiusOfPlate + MaxDistancePerStep>,
    ball_y: number<-MaxDistancePerStep - RadiusOfPlate .. RadiusOfPlate + MaxDistancePerStep>,

    # Ball X,Y velocity
    ball_vel_x: number<-MaxVelocity .. MaxVelocity>,
    ball_vel_y: number<-MaxVelocity .. MaxVelocity>,

# Define a concept graph with a single concept
graph (input: ObservableState) {
    concept MoveToCenter(input): SimAction {
        curriculum {
            # The source of training for this concept is a simulator that
            #  - can be configured for each episode using fields defined in SimConfig,
            #  - accepts per-iteration actions defined in SimAction, and
            #  - outputs states with the fields defined in SimState.
            source simulator MoabSim(Action: SimAction, Config: SimConfig): ObservableState {
                # Automatically launch the simulator with this
                # registered package name.
                package "Moab"
            }

            training {
                # Limit episodes to 250 iterations instead of the default 1000.
                EpisodeIterationLimit: 250
            }

            # The objective of training is expressed as a goal with two
            # subgoals: don't let the ball fall off the plate, and drive
            # the ball to the center of the plate.
            goal (State: ObservableState) {
                avoid `Fall Off Plate`:
                    Math.Hypot(State.ball_x, State.ball_y)
                    in Goal.RangeAbove(RadiusOfPlate * 0.8)
                drive `Center Of Plate`:
                    [State.ball_x, State.ball_y]
                    in Goal.Sphere([0, 0], CloseEnough)
            }

            lesson RandomizedStartLowVelocity {
                # Specify the configuration parameters that should be varied
                # from one episode to the next during this lesson.
                scenario {
                    initial_x: number<-RadiusOfPlate * 0.5 .. RadiusOfPlate * 0.5>,
                    initial_y: number<-RadiusOfPlate * 0.5 .. RadiusOfPlate * 0.5>,

                    initial_vel_x: number<-MaxVelocity * 0.02 .. MaxVelocity * 0.02>,
                    initial_vel_y: number<-MaxVelocity * 0.02 .. MaxVelocity * 0.02>,

                    initial_pitch: number<-0.2 .. 0.2>,
                    initial_roll: number<-0.2 .. 0.2>,
                }
            }
            lesson RandomizedStartMediumVelocity {
                # Specify the configuration parameters that should be varied
                # from one episode to the next during this lesson.
                scenario {
                    initial_x: number<-RadiusOfPlate * 0.5 .. RadiusOfPlate * 0.5>,
                    initial_y: number<-RadiusOfPlate * 0.5 .. RadiusOfPlate * 0.5>,

                    initial_vel_x: number<-MaxVelocity * 0.4 .. MaxVelocity * 0.4>,
                    initial_vel_y: number<-MaxVelocity * 0.4 .. MaxVelocity * 0.4>,

                    initial_pitch: number<-0.2 .. 0.2>,
                    initial_roll: number<-0.2 .. 0.2>,
                }
            }
        }
    }
}