Anahtar Sözcük: Maske

Eylem maskeleri, öğrenilen bir kavramın seçebileceği eylem kümesini geçerli duruma göre kısıtlar. Maskeleme, geçerli eylemler kümesinin her zaman aynı olmadığı uygulamalarda kullanışlıdır. Örneğin, beynin işi bakım için kapalı olan bir ekipmana yönlendirmesine izin verilmemelidir.

Eylem maskeleri, gibi type Action {cmd: number<Up=0, Down=1, Left=2, Right=3>}nominal eylem türleri için desteklenir.

Kullanım

Maske belirtmek için bir maske işlevi yazın ve bir kavram için müfredatın içindeki anahtar sözcüğüyle mask buna başvurun. Örneğin:

function MaskFunction(s: ObservableState) {
   # The mask function takes the input to the concept graph 
   # and returns a dynamic constraint on the Action type for a concept.
   return constraint Action <Dynamic Type Expression>
}

graph(input: ObservableState): ActionType {
    concept AConcept(input): ActionType {
       curriculum {
          mask MaskFunction
          ... # other curriculum elements here
       }
    }
}

Maske işlevleri

Maske işlevleri, anahtar sözcükle belirtildiği gibi beyinle graph aynı girişi alır. İşlev, kavram için temel eylem türünü sınırlayan bir dinamik tür kısıtlaması döndürmelidir.

function MaskFunction(s: ObservableState) {
   # Mask functions can use control flow, variables, etc.

   # Here, we'll restrict the bin in which to place an object based on its size
   if s.object_size < SmallSizeThreshold {
       return constraint Action {bin: number<in s.available_small_bins>}
   } else if s.object_size > LargeSizeThreshold {
       return constraint Action {bin: number<in s.available_large_bins>}
   } else {
       # No constraint
       return constraint Action {}
   }
}

Maske işlevinin dönüş türü, statik türün kısıtlanmış olmasıyla parametreleştirilir: Type.DynamicType<Action>. Mürekkep Oluşturma derleyicisi genellikle gerekli türü çıkarsayabilir, bu nedenle türü açıkça tanımlamanız gerekmez. Tüm dönüş yolları aynı parametreli türü döndürmelidir.

Dinamik tür kısıtlamaları

Dinamik kısıtlama ifadeleri anahtar sözcüğüyle constraint başlar ve ardından iki tür ifade izler:

  • statik (kısıtlanmamış) türü ve
  • birinci türe uygulanan dinamik kısıtlama.

Dinamik tür ifadesi mevcut tür ifadesinin söz dizimini kullanır, ancak bazı alt ifadelerin statik yerine dinamik olmasına izin verir. Örneğin, {choice: number<in s.valid_choices>}veya {fruit: number<mask observable_state.fruit_mask>}

Nominal numaralandırmalarda in iki tür dinamik kısıtlama vardır ve mask:

Kısıtlama Açıklama Örnek Ayrıntılar
in Numaralandırmadan belirtilen değerleri ekle number<in obs.allowedValues> Numaralandırmada olmayan değerler yoksayılır.
mask Her sabit listesi öğesi için Boole değeri number<mask obs.actionMask> Dizi boyutu numaralandırma boyutuyla eşleşmelidir.

İpucu

Kısıtlama uygulamamak için kullanın {}.

Çok boyutlu eylem türleri için kısıtlamalar alan başına uygulanır. Örneğin, eylem türü:

type Action {
    a: number<A=1,B=2,C=3>,
    b: number<X=1,Y=2>
}

ve kısıtlama şu şekildedir:

constraint Action {a: number<in [1,2]>, b: number<in [2]>}

geçerli eylemler ve {a:2, b:2}olacaktır{a: 1, b: 2}.

Önemli

Maske kısıtlaması her zaman null olmayan bir numaralandırmaya neden olmalıdır. Tüm seçenekler maskelenirse, beyin çalışma zamanı hatası döndürür.

Örnekler

Anahtar sözcük kullanarak mask kısıtlama

type Action {cmd: number<Up=0, Down=1, Left=2, Right=3>}

type ObservableState {
   x: number,
   y: number,
   # Booleans. If there's a wall, can't move in that direction
   wallAbove: number<0,1,>,  
   wallBelow: number<0,1,>,
   wallLeft: number<0,1,>
   wallRight: number<0,1,>,
}

function MaskFunction(s: ObservableState) {
    # Only move in allowed directions.
    # Note: simulator (and real world) need to ensure that at least one direction is available.

    # 1 means that action is allowed. Enumeration order in Action type is Up, Down, Left, Right.
    return constraint Action {cmd: number<mask [not s.wallAbove, not s.wallBelow, not s.wallLeft, not s.wallRight]>}
}

Kullanan kısıtlama in

type Action {cmd: number<Up=0, Down=1, Left=2, Right=3>}

type ObservableState {
   x: number,
   y: number,
   # Array of allowed directions, with -1 for unused entries
   allowedDirections: number<0..3 step 1>[4]
}

function MaskFunction(s: ObservableState) {
    # Only move in allowed directions.
    # Note: simulator (and real world) need to ensure that at least one direction is available.
    var UpOk = 1-wallAbove

    # s.allowedDirections should be an array of valid action values or placeholders
    # e.g.
    # [0,1,2,3,4] -- all allowed
    # [0,1, -1, -1] -- only Up (0) and Down (1) allowed
    return constraint Action {cmd: number<in s.allowedDirections>}
}

Maskede durum değişkenlerini kullanma ama öğrenme için kullanma

Bazen maske için gereken bilgiler öğrenmeyle ilgili değildir. Örneğin, bir fabrikadaki birkaç makineden birine iş göndermeye yönelik bir yönlendirme kararı düşünün. Bir makine kapalıysa, makineye hiçbir iş gönderilmemelidir, ancak hizmet dışı makinelerden kaçınmanın açık bir kavram olarak öğrenilmesi gerekmez. Bunun yerine, beyin hangi makinelerin en iyi olacağını seçmeyi öğrenebilir ve maske yalnızca çalışan makinelerin seçilmesini sağlar.


type Action {
    machine: number<A=1,B=2,C=3,D=4>
}

# Mask isn't needed for learning, so leave it out
type LearningState {
   # info about the job to be done by one of the machines
   job_property_a: number,
   job_property_b: number

   # machine properties that should be used to decide which is best to use
   machine_speeds: number<1..100 step 1>[4],
   machine_costs: number<0..1>[4],
}

# Add the mask info to get the full state that will be passed to the brain
type ObservableState extends LearningState {
   # array of 4 bools: 1 if machine is available, 0 otherwise
   available_machine_mask: number<0,1,>[4],
}

graph (input: ObservableState) {
    concept RemoveMask(input): LearningState {
        programmed function(s: ObservableState): LearningState {
            # use cast to avoid writing out all the fields one by one -- works if LearningState is a subset of ObservableState
            return LearningState(ObservableState)
        }
    }

    concept ChooseMachine(RemoveMask): Action {
        mask function(s: ObservableState) {
            return constraint Action {machine: number<mask s.available_machine_mask>}
        }
        ... # rest of curriculum definition
    }
}