Partager via

Clone, fonction

  • Article

Copie une partie du réseau d’un modèle dans une fonction BrainScript.

BS.Network.CloneFunction (inputNodes, outputNodes,
                          parameters="learnable" /*|"constant"|"shared"*/)

Paramètres

  • inputNodes est un tableau de 1 ou plusieurs entrées. Il répertorie les nœuds du réseau d’origine qui sont les entrées de la fonction à extraire. Lors de l’appel de la fonction BrainScript résultante, les paramètres de la fonction cloné sont remplacés par ces nœuds.
  • outputNodes est soit un nœud de sortie unique, soit un enregistrement de plusieurs nœuds de sortie. Ceux-ci indiquent quels nœuds du réseau d’origine sont la sortie de la fonction clonées. La fonction BrainScript résultante retourne ces éléments.
  • parameters détermine comment les paramètres appris à l’intérieur de la section clonée doivent être traités. Les valeurs suivantes sont comprises :
    • "learnable": chaque paramètre appris dans la fonction cloné obtient sa propre copie, qui est désormais mise à jour par l’entraînement comme n’importe quel autre paramètre. Il s’agit de la valeur par défaut.
    • "constant": les paramètres appris sont copiés, mais ensuite figés. La fonction cloné n’obtient aucune mise à jour lors de l’entraînement suivant, par exemple si vous souhaitez utiliser un extracteur de fonctionnalités entraîné sur un jeu d’entraînement standard volumineux dans une formation ultérieure sur un ensemble personnalisé plus petit.
    • "shared": les paramètres appris originaux continueront d’être utilisés de manière partagée. Ils seront mis à jour lors de la formation suivante à partir de leur utilisation d’origine et de l’utilisation cloné. Si la fonction BrainScript retournée par CloneFunction() est appelée plusieurs fois, tous les clones partagent des paramètres.

Valeur de retour

La fonction BrainScript qui accepte autant d’arguments d’entrée que inputNodeset retourne une scalaire si outputNodes est scalaire, ou un enregistrement si outputNodes est un enregistrement, avec des noms correspondants.

Description

CloneFunction() est une fonction à utiliser dans modification et la création de modèles. Il copie une partie du réseau d’un modèle dans une fonction BrainScript, afin que cette partie du réseau puisse être réutilisée. Le résultat est une fonction BrainScript qui peut être utilisée comme si cette section du réseau avait été définie à l’intérieur d’une fonction BrainScript normale.

Le réseau d’origine peut être un réseau distinct. Cela permet d’importer (partie de) un réseau externe qui a été formé sur différentes données. CloneFunction() permet de figer les paramètres de modèle du clone. Cela permet à un réseau externe d’être utilisé comme extracteur de fonctionnalités fixes ou d’agir en tant que normaliseur dans un paramètre d’adaptation.

Le réseau d’origine peut également être une section de celle qui est définie actuellement, et le clone peut partager ses paramètres avec l’original. Cela permet plusieurs chemins identiques via le réseau fonctionnant sur des données différentes, par exemple pour les configurations qui comparent symétrie la similarité de deux entrées, où les couches d’extraction de caractéristiques sont partagées (et apprises conjointement) pour les deux entrées. Cela ne fonctionne actuellement pas, toutefois, si la section réseau d’origine contient une boucle récurrente.

La section à copier est définie par ses nœuds d’entrée et de sortie. Imaginez un tracé réseau dans lequel une ligne est dessinée autour de la sous-section à cloner. Cette section indiquée par la ligne est ensuite spécifiée en passant toutes les connexions qui traversent la ligne pour entrer la zone marquée comme paramètre inputNodes, et toutes celles qui sortent en tant que outputNodes. CloneFunction() extrayez cette section dans une fonction BrainScript avec un nombre de paramètres égal au nombre de inputNodes, et la sortie étant un nœud unique ou un dictionnaire de nœuds.

Il est également possible de désigner des paramètres appris comme inputNodes. Dans ce cas, vous pouvez substituer de nouveaux paramètres en tant qu’arguments à la fonction BrainScript qui CloneFunction() crée. Procédez ainsi si vous souhaitez copier une fonction, mais découvrez les paramètres à partir de zéro. Dans ce cas, il est également possible de modifier les dimensions.

Exemples de cas d’usage :

  • adaptation (KL) : une copie en lecture seule figée du modèle de départ est utilisée comme KL-regularizer
  • adaptation (RGPR) : une transformation d’entrée injectée est entraînée pendant que le réseau est fixe
  • image : les couches inférieures des réseaux ImageNet servent d’extracteurs de fonctionnalités immuables pour une autre tâche d’image
  • DSSM : application de la même sous-section réseau à deux entrées

Problèmes liés aux noms de nœuds avec .[ et ]

Pour référencer un nœud dans un réseau qui contient . ou [ ou ], remplacez ces caractères par _. Par exemple, si network contient un nœud appelé result.z, network.result.z échoue ; au lieu de cela, dites network.result_z.

Note d’implémentation

CloneFunction() ne crée pas réellement de code BrainScript sous le capot. Au lieu de cela, il crée un objet C++ qui se comporte comme une fonction BrainScript. CloneFunction() elle-même ne clone pas le réseau d’origine. Elle contient uniquement une référence. Le clonage réel se produit lorsque la fonction qui CloneFunction() retourne est appelée.

Exemples

Utilisation de base :

# create a BS function by copying a piece of an existing network loaded from disk
network = BS.Network.Load ("some.dnn")
net = BS.Network.CloneFunction (network.features, network.logP)
# apply the copy to a new input
out = net (myFeatures)
# This will create a copy of the subsection from network.features to network.logP
# where all links to network.features get replaced by links to myFeatures.

Exemple avec plusieurs nœuds d’entrée et de sortie :

# This specific example passes two input nodes --> the resulting BS function will have 2 inputs;
# and it passes a record of output nodes --> the BS function will return a record with the same member names
network = BS.Network.Load ("some.dnn")
net = BS.Network.CloneFunction ((network.features:network.labels), [ ce = network.ce ; errs = network.errs ])
# 'net' is now a BrainScript function with this signature:
#   CloneFunction (input1, input2) --> [ ce = ... ; errs = ... ]

# now create a network from the BS function
myFeatures = Input (13)
myLabels = Input (42)
out = net (myFeatures, myLabels) # e.g. myFeatures substitutes the original 'features' node
criterionNodes = (out.ce)        # and the return value is a record with members 'ce' and 'errs'
evaluationNodes = (out.errs)

Exemple spécifique : Adaptation d’un réseau, lors de l’utilisation du réseau d’origine en tant que normaliseur (KLD) :

# load network
network = BS.Network.Load ("some.dnn")
# create a trainable clone and a read-only reference clone
adaptNet = BS.Network.CloneFunction (network.features, [ z = network.z ], parameters="learnable")
refNet   = BS.Network.CloneFunction (network.features, [ z = network.z ], parameters="constant")

# create the main network
features = Input (42)
labels = Input (9000)
z    = adaptNet (features).z
zRef = refNet   (features).z
# training criterion
# In KL adaptation, labels are a linear interpolation of the one-hot targets
# and the posteriors produced by the reference network.
refWeight = 0.9
kldLabels = labels * (1-refWeight) + Softmax (zRef) * refWeight  # interpolate with ref output
ce = CrossEntropyWithSoftmax (kldLabels, z) # the CE criterion is taken against these interpolated soft labels
errs = ErrorPrediction (labels, z)          # errors are of course still counted against the actual labels 
criterionNodes = (ce)
evaluationNodes = (errs)