Mot clé : concept

Le concept mot clé définit un composant d’un cerveau qui doit être appris, importé ou programmé. Par exemple :

  • Contrôler un radiateur en fonction d’entrées de capteur, afin de maintenir le confort d’une pièce.
  • Déterminer la quantité de matières premières à commander pour répondre à une demande anticipée.
  • Équilibrer un mât sur un chariot mobile.
  • Choisissez la compétence appropriée à utiliser pour accomplir une tâche complexe avec un bras robotique.

Chaque concept représente une traduction d’une ou plusieurs entrées en une sortie.

Usage

L’instruction concept spécifie les sources d’entrée et un type de sortie. Le flux de données input du simulateur fait toujours office d’entrée initiale pour le graphique du concept.

concept AbstractConceptName(Antecedent1, Antecedent2): OutputType {
    # Concept definition omitted
}

Les types d’entrée ne sont pas requis car leurs types sont fournis dans leurs définitions. Le type de flux d’entrée est spécifié dans la définition graph, et les types de sortie d’autres concepts sont fournis dans leurs propres définitions.

Si votre code Inkling inclut plusieurs concepts, vous devez spécifier le concept qui générera la sortie du cerveau formé. Pour marquer le concept de sortie, ajoutez le mot clé output à la définition du concept. Par exemple :

output concept ControlTheSystem(PreviousConcept): ActionType

Des concepts peuvent être importés, appris ou programmés. Les sections suivantes fournissent des informations supplémentaires sur les différents types de concepts.

Concepts appris

Les concepts appris spécifient un curriculum qui définit le mode d’apprentissage de l’intelligence artificielle. Les concepts standard apprennent à générer une action en fonction de leurs entrées. Pour définir un concept appris, utilisez l’instruction curriculum comme suit :

concept Bar (input): Move {
  curriculum {
      # Curriculum definition goes here
  }
}

Concepts du sélecteur

Les sélecteurs apprennent à choisir un concept dans une liste d’options. La sortie du concept choisi devient la sortie du sélecteur. Les options représentent les compétences ou les stratégies qui doivent être appliquées dans différentes situations et le sélecteur apprend à choisir le plus approprié. Définissez un concept de sélecteur à l’aide du select mot clé comme suit :

concept PickOne(input): Action {
    select GoLeft
    select GoRight
    curriculum {
        # Curriculum definition goes here
    }
}

Les types de sortie des options doivent correspondre au type de sortie du concept de sélecteur.

Important

Les concepts sélectionnés ne doivent pas être inclus dans l' entrée du concept de sélecteur, sauf si les valeurs des actions doivent faire partie de la décision à sélectionner. Dans la plupart des cas, l’état de l’environnement est utilisé pour effectuer la sélection.

Options du sélecteur de masquage

Vous pouvez spécifier une condition pour activer ou désactiver les options du sélecteur en fonction de l’État. Empêcher le système de choisir les compétences que vous connaissez ne sont pas appropriées dans certaines situations peut accélérer l’apprentissage et rendre le résultat plus robuste. Spécifiez une mask fonction comme propriété de l' select instruction comme suit :

concept PickOne(input): Action {
    select GoLeft {
        mask function(s: BrainInputState): number {
            # return 1 if this option should be prohibited, 0 otherwise
            return s.is_going_left_clearly_a_bad_idea_now
        }
    }
    select GoStraight {
        # The mask function can be inline as above, or global like this:
        mask MaskGoingStraight
    }
    select GoRight  # if no mask function is specified, the option is always available.
    curriculum {
        # Curriculum definition goes here
    }
}

L’entrée to mask Functions est l’état d’entrée Brain. La sortie est un nombre qui est interprété comme une valeur booléenne. La valeur 0 signifie que l’option doit être autorisée. Toute autre valeur signifie que l’option n’est pas autorisée. Ces conditions seront utilisées lors de la formation et de l’évaluation, ainsi que dans la cerveau exportée.

Important

Il doit toujours y avoir au moins une option non masquée : si toutes les options sont masquées, le système signale une erreur d’exécution.

Concepts programmés

Les concepts programmés sont définis à l’aide du mot clé programmed suivi d’une définition de fonction ou d’une référence. Les paramètres de fonction doivent correspondre à l’ordre et aux types des entrées du concept, et le type de sortie de la fonction doit correspondre au type de sortie du concept.

La fonction peut être spécifiée inline, ou définie et nommée comme une fonction de niveau supérieur. Fonction de niveau supérieur :

type State {x: number, y: number}
type Move {speed: number<0..10>}

function computeMove(State: StateType): Move {
     var distance = Math.Hypot(State.x, State.y)
     return {speed: distance * 0.2}
  }

concept Bar (input): Move {
  programmed computeMove
}

Fonction inline :

concept Bar (input): Move {
  programmed function(State: StateType): Move {
     var distance = Math.Hypot(State.x, State.y)
     return {speed: distance * 0.2}
  }
}

Concepts importés

Les concepts importés vous permettent d’utiliser des modèles compatibles TensorFlow v 1.15.2 formés sur d’autres plateformes pour former Bonsai un cerveau. Bonsai prend actuellement en charge les formats TensorFlow compatibles suivants pour les concepts importés :

Pour utiliser des concepts importés, importez le modèle et utilisez le mot clé import :

concept ImportedConcept(input): Action { 
  import { Model: "MLModelName" }
} 

Important

Les concepts importés :

  • ne peuvent avoir qu’une seule entrée ;
  • ne peuvent pas utiliser d’entrées d’images ;
  • doivent avoir un état d’entrée avec les mêmes dimensions que l’objet Inkling auquel ils mappent.

Si vous préférez ne pas nommer le modèle explicitement dans la définition de votre concept, vous pouvez définir le modèle ML en tant que constante et importer la constante à la place :

const ExternalModel = {
    import { Model: "MLModelName" }
}

graph (input: SimState): Action {
    concept ConceptA(input): Action {
        import ExternalModel
    }
    output ConceptA
}

Conseil

L’utilisation de fonctions nommées vous permet de les déboguer à l’aide de l’Console de débogage INKLING dans l' Bonsai interface utilisateur.

Validation et interprétation des entrées et des sorties

Le compilateur d’Inkling vérifie que les types de graphique, de concept et de simulateur dans un graphique de concept sont tous cohérents. En outre, le système vérifie que les états envoyés au cerveau pendant l’apprentissage ou après l’exportation correspondent au type d’entrée du graphique. Si des champs sont manquants ou contiennent des valeurs non compatibles avec le type spécifié, le système signale une erreur.

Pour les concepts appris, le type de la sortie détermine si le problème d’apprentissage est traité comme une régression ou une classification, ainsi que la manière dont la valeur de sortie doit être arrondie. En outre, la sortie d’un concept appris ne peut pas contenir une combinaison de types nominaux et non nominaux. Si le type de sortie d’un concept appris contient une variable nominale (catégorique), toutes les variables de la structure de sortie doivent être nominales.

Contrainte number Exemple Interprétation Utilisation en entrée Utilisation en sortie
aucun number Continue Scalaire à virgule flottante Régression. Arrondie à l’entier le plus proche
range number<1..7> Continue Scalaire à virgule flottante Régression. Arrondie à la valeur la plus proche dans la plage
plage d’étapes number<1..7 step 1> Ordinal Scalaire à virgule flottante Régression. Arrondie à la valeur la plus proche (en respectant l’étape)
énumération sans nom number<1,3,5> Ordinal Scalaire à virgule flottante Régression. Arrondie à la valeur énumérée la plus proche
énumération nommée number<Left=0, Right=1> Nominale Catégorique Classification.

Important

Le choix des types de variables appropriés est une partie importante de la modélisation de votre problème qui affecte les opérations statistiques effectuées par un cerveau à mesure qu’il apprend :

  • Utilisez des variables continues dans les actions et les États qui peuvent changer en douceur dans une plage de valeurs. Par exemple, power_consumption: number<0..2500> peut être n’importe quelle valeur à virgule flottante dans la plage comprise entre 0 et 2500 .
  • Utilisez des variables ordinales dans les actions et les États qui ont des valeurs discrètes avec un classement clair. Par exemple, transmission_gear: number<1, 2, 3, 4> peut être l’un des quatre choix discrets (1er, 2e, 3e ou 4e engrenage) pour des vitesses de plus en plus élevées.
  • Utilisez des variables nominales (catégoriques) dans les actions et les États qui sont des options distinctes sans ordre clair. Par exemple, paint_color: number<Blue=0, Red=1, Green=2, Yellow=3> peut être l’un des choix de couleurs fournis, mais les valeurs numériques assignées à chaque choix sont arbitraires. Le fait que le jaune soit 3 et le bleu 0 ne signifie pas que le jaune est « supérieur à » bleu.

Exemples

Supposons que vous disposiez d’une formation d’intelligence dont vous effectuez l’apprentissage pour obtenir un score élevé dans un jeu. Pour obtenir un score élevé, l’intelligence artificielle doit agir sur l’état actuel du jeu et décider d’un déplacement approprié.

Les exemples suivants définissent un concept GetHighScore qui prend l’état actuel du jeu comme entrée (input) et génère en sortie un déplacement valide (PlayerMove). Le premier exemple est appris, et le deuxième implémente une méthode heuristique programmée simple.

Exemple 1 : concept appris

# A learned concept that will learn to play the game

type State {x: number, y: number}
type Move {speed: number<0..10>}

graph(input: State) {
    concept GetHighScore (input): Move {
        curriculum {
            source simulator GameSim(action: Move): State {}
            goal(s: State) { ... }  # Goal details omitted
        }
    }
}

Exemple 2 : concept programmé

# A programmed concept that implements a simple heuristic

type State {x: number, y: number}
type Move {speed: number<0..10>}

function computeMove(State: StateType): Move {
     var distance = Math.Hypot(State.x, State.y)
     return {speed: distance * 0.2}
  }

graph(input: State) {
    concept GetHighScore(input): Move {
      programmed computeMove
    }
}

Exemple 3 : transformer une entrée de cerveau avant l’apprentissage

inkling "2.0"
using Goal

type State {x: number, y: number}
type Action {speed: number<0..10>}

function transformInput(State: StateType): number {
     var distance = Math.Hypot(State.x, State.y)
     return distance
  }

graph(input: State) {
    concept TransformInput(input): Move {
      programmed transformInput
    }

    output concept ControlTheSystem(State: number): Action {
       curriculum {
            # Note that the simulator state output must match the overall graph input, not the 
            # concept input.
            source simulator SystemSim(action: number): State {}
            goal(s: number) { ... }  # Goal details omitted
        }
    }
}

Exemple 4 : heuristique programmée pour sélectionner l’une des actions proposées

# Control a system one way when particles are small, and differently when they're large
inkling "2.0"
using Goal

type State {
    particleSizes: number[3],
    conveyorSpeed: number,
    throughput: number,
}

type Action {
    conveyorSpeed: number<1..10>,
    gap: number<45..145>
}

type SimConfig {
    bigParticles: number,
    smallParticles: number
}

simulator EnvSim(action: Action, config: SimConfig): State {
}

function selectionStrategy(state: State, smallAction: Action, largeAction: Action) {
    # a programmed rule specifying when to use each strategy.
    var meanSize = (state.particleSizes[0] + state.particleSizes[1] + state.particleSizes[2])/3
    # If particles are small, use strategy one. Otherwise, use strategy two.
    if meanSize < 10 {
        return smallAction
    }
    return largeAction
}

graph (input: State) {

    concept SmallParticleStrategy(input): Action {
        curriculum {
            source EnvSim
            goal (s: State) {
                maximize Throughput: s.throughput in Goal.RangeAbove(20)
            }
            lesson One {
                scenario {
                    # Learn how to act when most particles are small
                    bigParticles: 10,
                    smallParticles: 100
                }
            }
        }
    }

    concept LargeParticleStrategy(input): Action {
        curriculum {
            source EnvSim
            goal (s: State) {
                maximize Throughput: s.throughput in Goal.RangeAbove(20)
            }
            lesson One {
                scenario {
                    # Learn how to act when most particles are large
                    bigParticles: 100,
                    smallParticles: 10
                }
            }
        }
    }

    output concept ChooseStrategy(input, SmallParticleStrategy, LargeParticleStrategy): Action {
        programmed selectionStrategy   
    }
}

Exemple 5 : sélecteur appris à choisir parmi plusieurs actions proposées

# Control a system one way when particles are small, and differently when they're large
inkling "2.0"
using Goal

type State {
    particleSizes: number[3],
    conveyorSpeed: number,
    throughput: number,
}

type Action {
    conveyorSpeed: number<1..10>,
    gap: number<45..145>
}

type SimConfig {
    bigParticles: number,
    smallParticles: number
}

simulator EnvSim(action: Action, config: SimConfig): State {
}

graph (input: State) {

    concept SmallParticleStrategy(input): Action {
        curriculum {
            source EnvSim
            goal (s: State) {
                maximize Throughput: s.throughput in Goal.RangeAbove(20)
            }
            lesson One {
                # Learn how to act when most particles are small
                scenario {
                    bigParticles: 10,
                    smallParticles: 100
                }
            }
        }
    }

    concept LargeParticleStrategy(input): Action {
        curriculum {
            source EnvSim
            goal (s: State) {
                maximize Throughput: s.throughput in Goal.RangeAbove(20)
            }
            lesson One {
                # Learn how to act when most particles are big
                scenario {
                    bigParticles: 100,
                    smallParticles: 10
                }
            }
        }
    }

    output concept selectStrategy(input): Action {
        select SmallParticleStrategy
        select LargeParticleStrategy
        curriculum {
            source EnvSim
            goal (s: State) {
                maximize Throughput: s.throughput in Goal.RangeAbove(20)
            }
            lesson One {
                scenario {
                    # The selector needs to learn to act across any mix of particles
                    bigParticles: number<10..100>,
                    smallParticles: number<10..100>
                }
            }
        }
    }
}

Exemple 6 : sélecteur appris à choisir l’une des actions suivantes, avec masquage

# Control a system one way when particles are small, and differently when they're large
# Use selector concept masking to learn the fuzzy boundary in between.

inkling "2.0"
using Goal

type State {
    particleSizes: number[3],
    conveyorSpeed: number,
    throughput: number,
}

# smaller than this: definitely small
const smallSizeLimit = 10

# larger than this: definitely big
const largeSizeLimit = 40

type Action {
    conveyorSpeed: number<1..10>,
    gap: number<45..145>
}

type SimConfig {
    bigParticles: number,
    smallParticles: number
}

simulator EnvSim(action: Action, config: SimConfig): State {
}

function DisallowSmallParticleStrategy(s: State): number {
    # If particles are too big, don't use this strategy
    var particlesAreTooBig = (s.particleSizes[0] > largeSizeLimit)
    return particlesAreTooBig
}

graph (input: State) {

    concept SmallParticleStrategy(input): Action {
        curriculum {
            source EnvSim
            goal (s: State) {
                maximize Throughput: s.throughput in Goal.RangeAbove(20)
            }
            lesson One {
                # Learn how to act when most particles are small
                scenario {
                    bigParticles: 10,
                    smallParticles: 100
                }
            }
        }
    }

    concept LargeParticleStrategy(input): Action {
        curriculum {
            source EnvSim
            goal (s: State) {
                maximize Throughput: s.throughput in Goal.RangeAbove(20)
            }
            lesson One {
                # Learn how to act when most particles are big
                scenario {
                    bigParticles: 100,
                    smallParticles: 10
                }
            }
        }
    }

    output concept selectStrategy(input): Action {
        select SmallParticleStrategy {
            # reference a global mask function
            mask DisallowSmallParticleStrategy
        }
        select LargeParticleStrategy {
            # define an inline mask function
            mask function(s: State): number {
                # If particles are too small, don't use this strategy
                var particlesAreTooSmall = (s.particleSizes[0] < smallSizeLimit)
                return particlesAreTooSmall
            }
        }
        curriculum {
            source EnvSim
            goal (s: State) {
                maximize Throughput: s.throughput in Goal.RangeAbove(20)
            }
            lesson One {
                scenario {
                    # The selector needs to learn to act across any mix of particles
                    bigParticles: number<10..100>,
                    smallParticles: number<10..100>
                }
            }
        }
    }
}