Partager via

Paramètres et constantes

  • Article

ParameterTensor{}

Crée un scalaire, un vecteur, une matrice ou un capteur de paramètres appris.

ParameterTensor {shape,
                 init='uniform'/*|heNormal|...*/, initOutputRank=1, initValueScale=1.0,
                 randomSeed=-1,
                 initValue=0.0, initFromFilePath='',
                 learningRateMultiplier=1.0}

Paramètres

  • shape: forme (dimensions) du paramètre en tant que tableau. Par exemple (13:42) , pour créer une matrice avec 13 lignes et 42 colonnes. Pour certaines opérations, les dimensions indiquées comme 0 sont déduites automatiquement (voir ici)
  • init (valeur par défaut « uniforme ») : spécifie l’initialisation aléatoire, par exemple init='heNormal'(voir ici)
  • initOutputRank (par défaut 1) : spécifie le nombre d’axes de fan out principaux. Si négatif, -number of trailing fan-out axes (voir ici)
  • initValueScale (par défaut 1) : facteur de mise à l’échelle supplémentaire appliqué aux valeurs d’initialisation aléatoire
  • randomSeed (valeur par défaut -1) : si positif, utilisez cette semence aléatoire pour l’initialisation aléatoire. Si négatif, utilisez un compteur qui est augmenté pour chacun d’eux ParameterTensor{}
  • initValue: spécifie l’initialisation avec une valeur constante, par exemple. initValue=0
  • initFromFilePath: spécifie l’initialisation en chargeant les valeurs initiales à partir d’un fichier. Par exemple, initFromFilePath="my_init_vals.txt"
  • learningRateMultiplier: le taux d’apprentissage système sera mis à l’échelle par ce (0 pour désactiver l’apprentissage) (voir ici)

Valeur renvoyée

Capteur de paramètres apprenants.

Description

Cette fonction de fabrique crée un scalaire, un vecteur, une matrice ou un capteur de paramètres appris, autrement dit un capteur reconnu par l’action comme contenant des paramètres qui doivent être mis à jour pendant l’entraînement "train" .

Les valeurs seront initialisées, selon le paramètre facultatif donné, à

  • nombres aléatoires, s’il init est donné;
  • une constante si initValue elle est donnée ; ou
  • un capteur lu à partir d’un fichier d’entrée externe s’il initFromFilePath est donné. Par défaut, il s’agit de init="uniform".

Pour créer un scalaire, vecteur, matrice ou tensoreur avec le shape rang>2, passez ce qui suit comme paramètre :

  • (1) pour un scalaire ;
  • (M) pour un vecteur de colonne avec M des éléments ;
  • (1:N) pour un vecteur de ligne avec N des éléments. Les vecteurs de ligne sont des matrices d’une ligne ;
  • (M:N) pour une matrice avec N des lignes et I des colonnes ;
  • (I:J:K...) pour unensoreur de classement>arbitraire 2 (note : le rang maximal autorisé est de 12); et
  • (W:H:C) pour un capteur qui correspond aux dimensions d’une [W x H] image avec C des canaux.

Inférence de dimension automatique

Lorsqu’un ParameterTensor est utilisé pour les poids comme entrée immédiate d’opérations spécifiques, il est autorisé à spécifier certaines dimensions comme Inferred. Par exemple, le produitParameterTensor{42:Inferred} * x) de matrice déduit automatiquement la deuxième dimension à être égale à la dimension de x.

Cela est extrêmement pratique pour les entrées de couches, car il libère le code BrainScript de l’utilisateur du fardeau de passer autour des dimensions d’entrée. En outre, dans certaines situations, il est très fastidieux de déterminer les dimensions d’entrée précises d’une couche, par exemple pour la première couche entièrement connectée au-dessus d’une pyramide de combinaisons convolution/pooling sans remplissage, où chaque opération de convolution et de regroupement peut supprimer des lignes ou des colonnes de pixels de limite et mettre à l’échelle les dimensions.

Cette fonctionnalité est ce qui permet aux couches prédéfinies de CNTK d’être spécifiées par leur dimension de sortie uniquement (par exempleDenseLayer{1024}).

Initialisation aléatoire

L’initialisation aléatoire est sélectionnée par le init paramètre, qui choisit entre une distribution uniforme et normale, où l’écart type/plage est calculé en fonction du ventilateur et du ventilateur :

Valeur de init distribution plage/écart type
'heNormal' normal sqrt (2 / fanIn)
'heUniform' uniforme sqrt (6 / fanIn)
'glorotNormal' normal sqrt (2 / (fanIn+fanOut))
'glorotUniform' uniforme sqrt (6 / (fanIn+fanOut))
'xavier' uniforme sqrt (3 / fanIn)
'uniform' uniforme 1/20
'gaussian' normal sqrt (0.04 / fanIn)
'zéro' n/a 0

(Où zero est une alternative parfois pratique à la spécification initValue=0.) Pour la distribution uniforme, les paramètres sont initialisés de manière uniforme dans [-range, range]; pour la distribution normale, la moyenne est toujours nulle.

Notez que la valeur par défaut est inituniform utilisée ParameterTensor{} directement. Toutefois, la valeur par défaut est glorotUniform pour les couches qui contiennent des paramètres à l’intérieur, tels que DenseLayer{} et ConvolutionalLayer{}.

Fan-in et fan-out pour l’initialisation aléatoire

L’initialisation aléatoire suppose que les paramètres font partie d’une forme d’opération similaire à la matrice qui a un ventilateur bien défini et un ventilateur out, qui sont utilisés pour déterminer la mise à l’échelle des valeurs aléatoires par tableau ci-dessus. Par défaut, le premier axe est considéré comme fan-out, et les axes/axes restants sont des sémantiques correspondantes du produit de matrice régulière.

Le paramètre initOutputRank facultatif peut être utilisé pour spécifier le nombre d’axes principaux qui doivent être considérés comme fan-out. Par exemple, pour un produit de matrice dans l’interprétation étendue du tensor CNTK qui mappe un vecteur x -dimensionnel à un [I x J][K]objet de classement-2 dimensionnel peut être écrit comme Times (W, x, outputRank=2), où W a la forme .[I x J x K] Ici, spécifie que dans la mise à l’échelle des valeurs d’initialisation aléatoire, initOutputRank=2 le ventilateur est I*J et le ventilateur K.

Les valeurs négatives pour initOutputRank indiquer que les axes de ventilateur sont des axes de fin. Par exemple, le noyau de filtre de l’opération ConvolutionalLayer{} et l’opération sous-jacente Convolution() pour une configuration de traitement d’image classique a une forme [W x H x C x K], où K est le ventilateur, alors que le ventilateur est W*H*C. Ceci est spécifié par initOutputRank=-1.

Lecture des valeurs initiales à partir de fichiers

Les valeurs initiales peuvent être lues à partir d’un fichier texte. Pour ce faire, passez un chemin d’accès pour le paramètre initFromFilePathfacultatif . Le fichier texte doit se composer d’une ligne par ligne de matrice, qui se compose de nombres séparés par espace, un par colonne. Les dimensions de ligne et de colonne du fichier doivent correspondre shape.

Taux d’apprentissage spécifique au paramètre

Les taux d’apprentissage spécifiques aux paramètres peuvent être réalisés avec le paramètre facultatif learningRateMultiplier . Ce facteur est multiplié par le taux d’apprentissage réel lors de l’exécution des mises à jour des paramètres. Par exemple, si elle est spécifiée sous la forme 0, le paramètre n’est pas mis à jour, il est constant.

Exemples

Matrice de paramètres régulière qui sera initialisée comme heUniform (valeur par défaut heNormal) :

W = ParameterTensor {(outDim:inDim), init=`heUniform`}

Paramètre de biais normal qui sera initialisé comme zéro :

b = ParameterTensor {outDim, initValue=0}

Matrice incorporée qui doit être lue à partir d’un fichier et conservée constante :

E = ParameterTensor {(embedDim:vocabSize),
                     initFromFilePath='./EmbeddingMatrix.txt',
                     learningRateMultiplier=0}  # prevents learning

Paramètre de biais de la taille complète d’une [width x height]image de taille avec numChannels des plans de couleurs :

bFull = ParameterTensor {(width:height:numChannels)}

Constante{}

Créez un tensoriel constant.

Constant {scalarValue, rows=1, cols=1}

Paramètres

  • scalarValue: valeur de cette constante
  • rows (valeur par défaut : 1) : nombre de lignes, si la constante n’est pas une scalaire
  • cols (valeur par défaut : 1) : nombre de cols, si la constante n’est pas un scalaire

Valeur renvoyée

Constante, un scalaire ou un objet rank-1 ou rank-2 de dimension [rows x cols], où tous les éléments sont remplis scalarValue.

Description

Valeur constante. Il peut s’agir d’un objet scalaire, d’un objet rank-1 (vecteur) ou d’un objet rank-2 (matrice) initialisé avec une valeur unique (par exemple, 0). Notez que, étant donné que pour les constantes de vecteur et de matrice, toutes les valeurs sont identiques, les constantes utilisées conjointement avec les opérations basées sur les éléments peuvent souvent être spécifiées comme scalaires, tout en tirant parti de la diffusion.

Note d’implémentation :

A Constant() est un ParameterTensor{} avec learningRateMultiplier=0.

Exemples

Interpolation entre deux valeurs avec un poids alpha d’interpolation dans la plage 0..1 (« multiplexeur souple ») :

SoftMUX (x, y, alpha) = Constant (1-alpha) .* x + Constant (alpha) .* y

Perte hamming (cf. ici) :

HammingLoss (y, p) = ReduceSum (BS.Boolean.Xor (y, Greater (p, Constant(0.5))))
hl = HammingLoss (multiLabels, probabilities)