Partager via

API C# de la bibliothèque CNTK

  • Article

L’API managée de bibliothèque CNTK est implémentée en C#, et peut être consommée par C# et d’autres langages .NET. La page Using the CNTK Library Managed API and Using CNTK with C# présente comment utiliser cette API dans votre application. Les sections suivantes décrivent les classes et méthodes de l’API Eval gérée par la bibliothèque CNTK.

classe CNTKLib

Il s’agit d’une classe statique contenant de nombreuses opérations, initialisation et de nombreuses méthodes diverses.

public static Function Negate(Variable operand, string name = "");

Créez une instance de l’CNTK opération intégrée de négation d’élément avec l’opérande d’entrée spécifié. Paramètres :

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Sigmoid(Variable operand, string name = "")

Opération sigmoid. Il prend une variable d’entrée et applique l’opération Sigmoid à celle-ci.

Paramètres :

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Tanh(Variable operand, string name)

Activation tanh. Il prend une variable d’entrée et applique l’opération Tanh à celle-ci.

Paramètres :

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Asin(Variable operand, string name = "");

Créez une instance de l’CNTK opération intégrée asin avec l’opérande d’entrée spécifié.

Paramètres :

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Sin(Variable operand, string name = "");

Créez une instance de l’CNTK opération deine intégrée dans le sens des éléments avec l’opérande d’entrée spécifié. Paramètres :

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Acos(Variable operand, string name = "");

Créez une instance du CNTK opération intégrée d’acos dans le sens des éléments avec l’opérande d’entrée spécifié.

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Cos(Variable operand, string name = "");

Créez une instance de l’CNTK opération de cosine intégrée avec l’opérande d’entrée spécifié.

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Cosh(Variable operand, string name = "");

Créez une instance de l’opération cosh intégrée CNTK avec l’opérande d’entrée spécifié.

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Sinh(Variable operand, string name = "");

Créez une instance du CNTK opération sinh intégrée dans le sens de l’élément avec l’opérande d’entrée spécifié.

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function ReLU(Variable operand, string name = "")

Activation linéaire de redresseur. Il prend une variable d’entrée et applique l’opération d’activation linéaire à celle-ci.

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Exp(Variable operand, string name = "");

Créez une instance du CNTK opération d’exp intégrée dans le sens de l’élément avec l’opérande d’entrée spécifié.

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Log(Variable operand, string name = "");

Créez une instance du CNTK opération de journal intégrée dans le journal des éléments avec l’opérande d’entrée spécifié.

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Square(Variable operand, string name = "");

Créez une instance du CNTK opération carrée intégrée au niveau de l’élément avec l’opérande d’entrée spécifié.

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Sqrt(Variable operand, string name = "");

Créez une instance du CNTK opération de racine carrée intégrée avec l’opérande d’entrée spécifié.

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Softmax(Variable operand, Axis axis, string name = "")

Créez une instance du CNTK opération softmax intégrée sur l’axe spécifié sur un opérande d’entrée tensor spécifié :

  • operand: variable d’entrée de l’opération. Il peut s’agir de l’ouput d’une autre fonction.
  • axis: Axe à appliquer l’opération softmax
  • name: nom de l’opération.
public static Function Hardmax(Variable operand, string name = "");

Créer une instance du CNTK opération hardmax intégrée sur l’opérande d’entrée tensor spécifiée

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Transpose(Variable operand, string name = "");

Créez une instance du CNTK opération de transpose intégrée sur l’opérande d’entrée 1D ou 2D spécifié

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Dropout(Variable operand, dropoutRate, uint seed, string name = "");

Créer une instance de l’opération de suppression sur l’opérande d’entrée tensor spécifiée

  • operand: Variables d’entrée. Il peut s’agir de l’ouput d’une autre fonction.
  • dropoutRate:
  • seed:
  • name: nom de l’opération.
public static Function Reshape(Variable operand, NDShape replacementShape, Axis beginAxis, Axis endAxis, string name = "");

Créer une instance de l’opération de remodelage sur l’opérande d’entrée tensor spécifiée

public static Function Times(Variable leftOperand, Variable rightOperand, string name = "");

Créez une instance du CNTK opération de multiplication tensor intégrée avec les opérandes d’entrée spécifiés.

public static Function TransposeTimes(Variable leftOperand, Variable rightOperand, uint outputRank, string name = "");

Créez une instance du CNTK opération de multiplication de matrice intégrée avec la transpose de l’opérande d’entrée gauche et l’opérande droit spécifié. Accepte uniquement les opérandes de gauche des rangs 1 ou 2.

public static Function Plus(Variable leftOperand, Variable rightOperand, string name = "")

Opération d’ajout d’élément binaire. Paramètres :

  • leftOperand: variable gauche de l’opération plus. Il peut s’agir de l’ouput d’une autre fonction.
  • rightOperand: variable gauche de l’opération plus. Il peut s’agir de l’ouput d’une autre fonction.
  • name: nom de l’opération.
public static Function Minus(Variable leftOperand, Variable rightOperand, string name = "");

Créez une instance du CNTK opération de soustraction tensor intégrée avec les opérandes d’entrée spécifiés.

public static Function LogAddExp(Variable leftOperand, Variable rightOperand, string name = "");

Créez une instance du CNTK opération tensoriel intégrée qui calcule le journal de la somme des exponentiels des opérandes d’entrée spécifiés.

public static Function Pow(Variable leftOperand, Variable rightOperand, string name = "");

Créez une instance du CNTK opération tensoriel intégrée qui calcule le leftOperand déclenché à la puissance de l’opérande droit.

public static Function ElementTimes(Variable leftOperand, Variable rightOperand, string name = "");

Créez une instance de la CNTK opération de multiplication intégrée au niveau des éléments sur les opérandes d’entrée de tenseur spécifiés.

public static Function ElementDivide(Variable leftOperand, Variable rightOperand, string name = "");

Créez une instance de la CNTK opération de division intégrée au niveau des éléments sur les opérandes d’entrée tensoriel spécifiés.

public static Function CosineDistance(Variable leftOperand, Variable rightOperand, string name = "");

Créez une instance du CNTK opération intégrée pour calculer la distance de cosinus pour les opérandes d’entrée spécifiés.

public static Function CosineDistanceWithNegativeSamples(Variable leftOperand, Variable rightOperand, uint shiftWindow, uint numberOfNegativeSamples, string name = "");

Créez une instance du CNTK opération intégrée pour calculer la distance de cosinus avec des exemples négatifs pour les opérandes d’entrée spécifiés.

public static Function BinaryCrossEntropy(Variable prediction, Variable targets, string name = "");

Créez une instance du CNTK opération intégrée pour calculer l’entropie croisée binaire pour les opérandes d’entrée spécifiés.

public static Function WeightedBinaryCrossEntropy(Variable prediction, Variable targets, Variable weights, string name = "");

Créez une instance de l’opération intégrée CNTK pour calculer l’entropie croisée binaire pondérée pour les opérandes d’entrée spécifiés.

public static Function CrossEntropyWithSoftmax(Variable prediction, Variable labels, Axis axis, string name = "");

Créez une instance du CNTK opération intégrée pour calculer l’entropie croisée avec softmax pour les opérandes d’entrée spécifiés.

public static Function ClassificationError(Variable prediction, Variable labels, uint topN, Axis axis, string name = "");

Créez une instance du CNTK opération intégrée pour calculer l’erreur de prédiction de classification pour les opérandes spécifiés.

public static Function PastValue(Variable operand, Variable initialState, uint offset = 1, string name = "");

Créez une instance de l’opération intégrée CNTK pour obtenir la valeur passée le long de l’axe dynamique unique de l’opérande spécifié.

public static Function FutureValue(Variable operand, Variable initialState, uint offset = 1, string name = "");

Créez une instance du CNTK opération intégrée pour obtenir la valeur future le long de l’axe dynamique unique de l’opérande spécifié.

public static Function Convolution(Variable convolutionMap,
                                     Variable operand,
                                     NDShape strides = { 1 },
                                     BoolVector sharing = { true },
                                     BoolVector autoPadding = { true },
                                     NDShape dilation = { 1 },
                                     uint reductionRank = 1,
                                     uint maxTempMemSizeInSamples = 0,
                                     string name = "");

Convolution

public static Function ROIPooling(Variable operand,
                                    Variable rois,
                                    PoolingType poolingType,
                                    NDShape roiOutputShape,
                                    double spatialScale,
                                    string name= "");

Créer une instance de l’CNTK opération de regroupement de retours sur investissement intégrée sur les opérandes d’entrée de tenseur spécifiés avec la forme de sortie spécifiée

public static Function Pooling(Variable operand,
                                 PoolingType poolingType,
                                 NDShape poolingWindowShape,
                                 NDShape strides = {1},
                                 BoolVector autoPadding = {false},
                                 const bool ceilOutDim = false,
                                 const bool includePad = false,
                                 string name = "");

public static Function BatchNormalization(Variable operand,
                                            Variable scale,
                                            Variable bias,
                                            Variable runningMean,
                                            Variable runningInvStd,
                                            Variable runningCount,
                                            bool spatial,
                                            double normalizationTimeConstant = 0,
                                            double blendTimeConstant = 0,
                                            double epsilon = 0.00001,
                                            bool useCuDNNEngine = true,
                                            string name = "");

public static Function Splice(VariableVector operands, Axis axis, string name = "");

Créez une instance de l’opération d’épingage intégrée CNTK pour associer tous les opérandes tensoriels spécifiés dans un seul tenseur de sortie

public static Function Combine(VariableVector operands, string name = "");

Créez une instance de fonction qui combine simplement les sorties de la liste spécifiée de fonctions « opérandes » de sorte que les « sorties » du nouveau « Function » sont l’union des « Sorties » de chacune des fonctions « opérandes » spécifiées. Par exemple, lors de la création d’un modèle de classification, généralement la fonction de perte CrossEntropy et la fonction ClassificationError comprennent les deux racines du graphique de calcul qui peuvent être « combinées » pour créer une fonction unique avec 2 sorties ; Viz. Perte crossEntropy et sortie ClassificationError.

public static Function LeakyReLU(Variable operand, string name = "");

Créez une instance du CNTK opération de redresseur linéaire intégrée fuite avec l’opérande d’entrée spécifié.

apprenant de classe

class Function

Un Function calcul symbolique avec zéro ou plusieurs arguments d’entrée et une ou plusieurs sorties. Une fonction peut être primitive ou composite (composée d’autres instances de fonction dont les entrées et sorties sont câblées ensemble). Une fonction est effectivement un graphique de calcul composé d’autres fonctions primitives (indiquant le calcul) en tant que nœuds et Variable objets (dénotant des données) en tant que bords et feuilles du graphique.

La Function classe contient les propriétés et méthodes suivantes qui sont pertinentes pour l’évaluation :

public string Name { get; }

Nom de la fonction.

public IList<Variable> Arguments { get; }

Liste de toutes les variables d’entrée de la fonction qui ne sont pas de type Paramètre ou Constante. Ces variables sont des entrées requises pour calculer les sorties de la fonction.

public Variable Output { get; }

Variable de sortie unique de la fonction, s’il n’en existe qu’une seule. Sinon, une exception d’exécution est levée lors de l’accès.

public IList<Variable> Outputs { get; }

Liste de toutes les variables de sortie de la fonction.

public Function RootFunction { get; }

Retourne la fonction primitive à la racine du graphique de Functions sous-jacent à la fonction. Si la fonction elle-même est une fonction primitive, alors (this-RootFunction>() == this).

public string OpName { get; }

Nom de l’opération que la fonction désigne.

public bool IsComposite { get; }

Valeur booléenne indiquant si la fonction est une fonction composite.

public bool IsPrimitive { get; }

Valeur booléenne indiquant si la fonction est une fonction primitive.

public bool IsBlock { get; }

Valeur booléenne indiquant si la fonction est une fonction de bloc.

public void Evaluate(IDictionary<Variable, Value> inputs, IDictionary<Variable, Value> outputs, DeviceDescriptor computeDevice)

public void Evaluate(IDictionary<Variable, Value> inputs, IDictionary<Variable, Value> outputs, bool createPersistentOutputValues, DeviceDescriptor computeDevice)

Évalue la fonction à l’aide de l’entrée spécifiée. Il calcule les sorties de la fonction en fonction des valeurs fournies pour chaque variable d’entrée spécifiée dans le inputs dictionnaire. Les sorties sont stockées dans les valeurs de sortie correspondant aux variables de sortie du outputs dictionnaire.

Paramètres :

  • inputs: les variables d’entrée et leurs valeurs de la fonction.
  • outputs: valeurs de sortie pour chaque variable de sortie. L’appelant peut spécifier l’objet Value pour stocker la sortie ou passer null , auquel cas la méthode alloue le stockage pour les résultats de sortie. Dans les deux cas, l’objet Value renvoie le résultat de la sortie correspondante de la fonction. Si une null valeur a été spécifiée et que le paramètre createPersistentOutputValues n’est pas spécifié ou est défini falsesur , l’objet Value retourné par la méthode est temporaire et n’est garanti qu’être valide jusqu’à l’appel suivant avant/arrière. S’il doit être accédé ultérieurementDeepClone, vous devez spécifier createPersistentOutputValues à true, ou explicitement l’objet Value temporaire.
  • computeDevice: appareil sur lequel le calcul est exécuté. Il doit être aligné sur l’appareil sur lequel le modèle est chargé.
  • createPersistentOutputValues: applicable uniquement si une null valeur a été spécifiée dans les sorties. S’il est défini truesur , la méthode crée des objets Value persistants, sinon les objets Value sont temporaires et ne sont valides que jusqu’à l’appel suivant avant/arrière.
public Function Clone(ParameterCloningMethod parameterCloneMethod = ParameterCloningMethod.Share)

Clones this , fonction.

Paramètres :

  • parameterCloneMethod: spécifie comment les paramètres de la fonction sont clonés : - ParameterCloningMethod.Share Les paramètres sont partagés entre la fonction en cours de clonage et le nouveau clone. Cette valeur doit être utilisée si la fonction cloné est utilisée pour l’évaluation simultanée. ParameterCloningMethod.Clone - Les nouveaux paramètres apprenants sont créés et initialisés avec les valeurs actuelles des paramètres correspondants de la fonction en cours de clonage. ParameterCloningMethod.Freeze - Les paramètres sont clonés et rendus immuables; c’est-à-dire des constantes dans le nouveau clone (par exemple, pour une utilisation comme extracteur de caractéristiques fixes). ParameterCloningMethod est défini ici.
public Function FindByName(string name, bool nestedSearchInsideBlockFunction)

Recherche une fonction portant le nom donné dans le graphique de fonction sous-jacent à la fonction. Si plusieurs fonctions portant le même nom existent, une exception est levée. Si nestedSearchInsideBlockFunction a la valeur true, recherchez également toutes les fonctions à l’intérieur des fonctions de bloc.

Paramètres :

  • name: nom à rechercher.
  • nestedSearchInsideBlockFunction: s’il est vrai, toutes les fonctions à l’intérieur des fonctions de bloc sont également examinées.
public IList<Function> FindAllWithName(string name, bool nestedSearchInsideBlockFunction = false)

Recherche une liste de fonctions portant le nom donné dans le graphique de fonction sous-jacent à la fonction. Si nestedSearchInsideBlockFunction a la valeur true, recherchez également toutes les fonctions à l’intérieur des fonctions de bloc.

Paramètres :

  • name: nom à rechercher.
  • nestedSearchInsideBlockFunction: s’il est vrai, toutes les fonctions à l’intérieur des fonctions de bloc sont également examinées.
public static Function Load(string modelFile, DeviceDescriptor computeDevice)

Charge une fonction à partir d’un fichier de modèle.

Paramètres :

  • modelFile: chemin d’accès au fichier de modèle.
  • computeDevice: appareil sur lequel la fonction est chargée.
public static Function Load(byte[] modelBuffer, DeviceDescriptor computeDevice)

Charge une fonction à partir d’une mémoire tampon représentant un modèle.

Paramètres :

  • modelBuffer: le tableau d’octets contient le contenu du modèle sérialisé.
  • computeDevice: appareil sur lequel la fonction est chargée.
public static Function Combine(IEnumerable<Variable> operands)

Crée une instance de fonction qui combine les sorties de la liste spécifiée des « opérandes » de Functions. Les « sorties » du nouveau « Function » sont l’union des « Sorties » de chacune des fonctions « opérandes » spécifiées. Par exemple, lors de la création d’un modèle de classification, généralement la fonction de perte CrossEntropy et la fonction ClassificationError comprennent les racines du graphique de calcul qui peut être « Combiner » d pour créer une fonction unique avec 2 sorties ; Viz. Perte crossEntropy et sortie ClassificationError.

Paramètre :

  • operands: liste des fonctions ou variables qui doivent être incluses dans les sorties de la nouvelle fonction.
public static Function AsComposite(Function rootFunction, string name = "")

Crée une fonction composite qui a la fonction rootFunction spécifiée comme racine. Le composite indique une fonction de niveau supérieur encapsulant l’ensemble du graphique functions sous-jacent à la fonction rootFunction spécifiée.

Paramètres :

  • rootFunction: racine de la fonction composite à créer.
  • name: nom de la fonction composite à créer.
public static Function Alias(Variable operand, string name = "")

Crée une instance de fonction qui n’est qu’un alias de l’opérande spécifié.

Paramètres :

  • operand: fonction ou variable pour laquelle la fonction alias est créée.
  • name: nom de la nouvelle fonction à créer.

class Value

A Value est un tableau multidimensionnel avec un masque facultatif et est les données réelles transmises ou produites à partir d’un calcul.

Les méthodes suivantes créent un objet Value à l’aide d’une entrée dense avec la forme de tenseur spécifiée.

public static Value CreateBatch<T>(NDShape sampleShape, IEnumerable<T> batch, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant un lot d’exemples. Le nombre d’échantillons dans le lot est le nombre d’éléments divisé par batch la taille ( shape une erreur d’exécution se produit si le reste n’est pas égal à zéro). L’objet Value créé contient une copie des données spécifiées dans batch.

Paramètres :

  • sampleShape: forme deensoriel de l’objet Value.
  • batch: données à contenir dans l’objet Value.
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: l’objet Value est en lecture seule si cet indicateur est true.
public static Value CreateSequence<T>(NDShape sampleShape, IEnumerable<T> sequence, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant une séquence d’exemples. L’objet Value créé contient une copie des données spécifiées dans sequence. La longueur de séquence est le nombre d’éléments divisé par sequence la taille ( shape une erreur d’exécution se produit si le reste n’est pas égal à zéro). La séquence créée est une nouvelle séquence.

Paramètres :

  • sampleShape: forme de tenseur de la valeur.
  • sequence: données à contenir dans la valeur.
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.
public static Value CreateSequence<T>(NDShape sampleShape, IEnumerable<T> sequence, bool sequenceStartFlag, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant une séquence d’exemples. L’objet Value créé contient une copie des données spécifiées sequence . SequenceStartFlag spécifie si cette séquence est une nouvelle séquence ou une continuation d’une séquence précédente à partir d’un appel précédent à cette méthode. La longueur de séquence est le nombre d’éléments divisé par sequence la taille ( shape une erreur d’exécution se produit si le reste n’est pas égal à zéro).

Paramètres :

  • sampleShape: forme de tenseur de la valeur.
  • sequence: données à contenir dans la valeur.
  • sequenceStartFlag: true indique qu’il s’agit d’une nouvelle séquence. false signifie une continuation d’une séquence précédente.
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.
public static Value CreateBatchOfSequences<T>(NDShape sampleShape, IEnumerable<IEnumerable<T>> batchOfSequences, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant un lot de séquences de longueur variable. L’objet Value créé contient une copie des données spécifiées dans batchOfSequences. Le nombre de séquences dans le lot est la taille de batchOfSequences. La longueur de chaque séquence est le nombre d’éléments dans la séquence correspondante divisée batchOfSequences par la taille ( shape une erreur d’exécution se produit si le reste n’est pas égal à zéro). Chaque séquence dans batchOfSequences est une nouvelle séquence.

Paramètres :

  • sampleShape: forme de tenseur de la valeur.
  • batchOfSequences: données à stocker dans la valeur. L’extérieur IEnumerable représente une collection de séquences de longueur variable, et l’intérieur IEnumerable représente chaque séquence individuelle.
  • device: sur quel appareil la valeur doit être créée.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.
public static Value CreateBatchOfSequences<T>(NDShape sampleShape, IEnumerable<IEnumerable<T>> batchOfSequences, IEnumerable<bool> sequenceStartFlags, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant un lot de séquences de longueur variable. L’objet Value créé contient une copie des données spécifiées dans batchOfSequences. Le nombre de séquences dans le lot est la taille de batchOfSequences. La longueur de chaque séquence est le nombre d’éléments dans la séquence correspondante divisée batchOfSequences par la taille ( shape une erreur d’exécution se produit si le reste n’est pas égal à zéro).

Paramètres :

  • sampleShape: forme de tenseur de la valeur.
  • batchOfSequences: données à stocker dans la valeur. L’extérieur IEnumerable représente une collection de séquences de longueur variable, et l’intérieur IEnumerable représente chaque séquence individuelle.
  • sequenceStartFlags: collection de valeurs booléennes. Chaque élément indique si la séquence correspondante est batchOfSequences une nouvelle séquence (en cas de true) ou une continuation d’une séquence précédente (en cas de false).
  • device: sur quel appareil la valeur doit être créée.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.

Les méthodes suivantes créent un objet Value à l’aide d’une entrée à vecteur à chaud.

public static Value CreateBatch<T>(int dimension, IEnumerable<int> batch, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant un lot d’exemples. Chaque exemple est représenté par une valeur d’index qui pointe vers la valeur non nulle dans le vecteur à chaud d’éléments dimension . Le nombre d’échantillons dans le lot est le nombre d’éléments dans batch.

Paramètres :

  • T: type de données de l’objet Value créé. Actuellement, float et double sont pris en charge.
  • dimension: taille de dimension du vecteur à chaud.
  • batch: collection d’index représentant le lot d’échantillons.
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.
public static Value CreateSequence<T>(int dimension, IEnumerable<int> sequence, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant une séquence d’exemples. Chaque exemple est représenté par une valeur d’index qui pointe vers la valeur non nulle dans le vecteur à chaud d’éléments dimension . La longueur de séquence est le nombre d’éléments dans sequence. La séquence créée est une nouvelle séquence.

Paramètres :

  • T: type de données de l’objet Value créé. Actuellement, float et double sont pris en charge.
  • dimension: taille de dimension du vecteur à chaud.
  • sequence: collection d’index représentant la séquence d’échantillons.
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.
public static Value CreateSequence<T>(int dimension, IEnumerable<int> sequence, bool sequenceStartFlag, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant une séquence d’exemples. Chaque exemple est représenté par une valeur d’index qui pointe vers la valeur non nulle dans le vecteur à chaud d’éléments dimension . SequenceStartFlag spécifie si cette séquence est une nouvelle séquence ou une continuation d’une séquence précédente à partir d’un appel précédent à cette méthode. La longueur de séquence est le nombre d’éléments dans sequence.

Paramètres :

  • T: type de données de l’objet Value créé. Actuellement, float et double sont pris en charge.
  • dimension: taille de dimension du vecteur à chaud.
  • sequence: collection d’index représentant la séquence d’échantillons.
  • sequenceStartFlag: true indique qu’il s’agit d’une nouvelle séquence. false signifie une continuation d’une séquence précédente.
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.
public static Value CreateBatchOfSequences<T>(int dimension, IEnumerable<IEnumerable<int>> batchOfSequences, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant un lot de séquences de longueur variable. Chaque exemple est représenté par une valeur d’index qui pointe vers la valeur non nulle dans le vecteur à chaud d’éléments dimension . Le nombre de séquences est le nombre d’éléments dans la collection externe de batchOfSequences. La longueur de chaque séquence est le nombre d’éléments de la séquence correspondante dans la liste de collections de batchOfSequences. Chaque séquence dans batchOfSequences est une nouvelle séquence.

Paramètres :

  • T: type de données de l’objet Value créé. Actuellement, float et double sont pris en charge.
  • dimension: taille de dimension du vecteur à chaud.
  • batchOfSequences: collection d’index représentant des séquences d’échantillons. L’extérieur IEnumerable représente une collection de séquences de longueur variable, et l’intérieur IEnumerable représente chaque séquence individuelle.
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.
public static Value CreateBatchOfSequences<T>(int dimension, IEnumerable<IEnumerable<int>> batchOfSequences, IEnumerable<bool> sequenceStartFlags, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant un lot de séquences de longueur variable. Chaque exemple est représenté par une valeur d’index qui pointe vers la valeur non nulle dans le vecteur à chaud d’éléments dimension . Le nombre de séquences est le nombre d’éléments dans la collection externe de batchOfSequences. La longueur de chaque séquence est le nombre d’éléments de la séquence correspondante dans la collection interne de batchOfSequences.

Paramètres :

  • T: type de données de l’objet Value créé. Actuellement, float et double sont pris en charge.
  • dimension: taille de dimension du vecteur à chaud.
  • batchOfSequences: collection d’index représentant des séquences d’exemples. L’extérieur IEnumerable représente une collection de séquences avec une longueur variable, et l’intérieur IEnumerable représente chaque séquence individuelle.
  • sequenceStartFlags: collection de valeurs booléennes. Chaque élément indique si la séquence correspondante est batchOfSequences une nouvelle séquence (en cas de true) ou une continuation d’une séquence précédente (en cas de false).
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.

Les méthodes suivantes créent un objet Value à l’aide d’une entrée éparse.

Actuellement, le format de colonne éparse compressé (CSC) est pris en charge. Le format CSC stocke la matrice au format principal de colonne et le tableau contenant les index de colonne est compressé. Une matrice au format CSC est représentée par les paramètres suivants :

  • nonZeroValues: tableau de données qui contient toutes les valeurs non nulles de la matrice au format principal de colonne.
  • rowIndices: tableau qui contient les index de ligne des éléments correspondants dans le tableau nonZeroValues.
  • colStarts: tableau qui contient des index dans les tableaux rowIndices et nonZeroValues.

Vous trouverez ici une description détaillée du format CSC.

public static Value CreateSequence<T>(NDShape sampleShape, int sequenceLength, int[] colStarts, int[] rowIndices, T[] nonZeroValues, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant une séquence d’exemples à l’aide du format d’entrée éparse du CSC. La longueur de séquence est le nombre de lignes de la matrice éparse. La séquence créée est une nouvelle séquence.

Paramètres :

  • T: type de données de l’objet Value créé. Actuellement, float et double sont pris en charge.
  • sampleShape: forme de capteur de la valeur. Pour l’entrée éparse, la forme tensor de première dimension doit être identique à la taille totale de la forme tensor.
  • sequenceLength: longueur de séquence, qui est également le nombre de lignes dans la matrice éparse.
  • colStarts: le tableau contient des index pour chaque colonne dans les tableaux rowIndices et nonZeroValues.
  • rowIndices: tableau qui contient les index de ligne des éléments correspondants dans le tableau nonZeroValues.
  • nonZeroValues: tableau qui contient toutes les valeurs non nulles dans la matrice éparse.
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.
public static Value CreateSequence<T>(NDShape sampleShape, int sequenceLength, int[] colStarts, int[] rowIndices, T[] nonZeroValues, bool sequenceStartFlag, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant une séquence d’exemples à l’aide du format d’entrée éparse du CSC. La longueur de séquence est le nombre de lignes de la matrice éparse. SequenceStartFlag spécifie si cette séquence est une nouvelle séquence ou une continuation d’une séquence précédente d’un appel précédent à cette méthode.

Paramètres :

  • T: type de données de l’objet Value créé. Actuellement, float et double sont pris en charge.
  • sampleShape: forme de capteur de la valeur. Pour l’entrée éparse, la forme tensor de première dimension doit être identique à la taille totale de la forme tensor.
  • sequenceLength: longueur de séquence, qui est également le nombre de lignes dans la matrice éparse.
  • colStarts: le tableau contient des index pour chaque colonne dans les tableaux rowIndices et nonZeroValues.
  • rowIndices: tableau qui contient les index de ligne des éléments correspondants dans le tableau nonZeroValues.
  • nonZeroValues: tableau qui contient toutes les valeurs non nulles dans la matrice éparse.
  • sequenceStartFlag: true indique qu’il s’agit d’une nouvelle séquence. false signifie une continuation d’une séquence précédente.
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.
public static Value CreateSequence<T>(int dimension, int sequenceLength, int[] colStarts, int[] rowIndices, T[] nonZeroValues, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant une séquence d’exemples à l’aide du format d’entrée éparse du CSC. La longueur de séquence est le nombre de lignes de la matrice éparse. La séquence créée est une nouvelle séquence.

Paramètres :

  • T: type de données de l’objet Value créé. Actuellement, float et double sont pris en charge.
  • dimension: nombre de colonnes dans la matrice éparse.
  • sequenceLength: longueur de séquence, qui est également le nombre de lignes dans la matrice éparse.
  • colStarts: le tableau contient des index pour chaque colonne dans les tableaux rowIndices et nonZeroValues.
  • rowIndices: tableau qui contient les index de ligne des éléments correspondants dans le tableau nonZeroValues.
  • nonZeroValues: tableau qui contient toutes les valeurs non nulles dans la matrice éparse.
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.
public static Value CreateSequence<T>(int dimension, int sequenceLength, int[] colStarts, int[] rowIndices, T[] nonZeroValues, bool sequenceStartFlag, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value contenant une séquence d’exemples à l’aide du format d’entrée éparse du CSC. La longueur de séquence est le nombre de lignes de la matrice éparse. SequenceStartFlag spécifie si cette séquence est une nouvelle séquence ou une continuation d’une séquence précédente.

Paramètres :

  • T: type de données de l’objet Value créé. Actuellement, float et double sont pris en charge.
  • dimension: nombre de colonnes dans la matrice éparse.
  • sequenceLength: longueur de séquence, qui est également le nombre de lignes dans la matrice éparse.
  • colStarts: le tableau contient des index pour chaque colonne dans les tableaux rowIndices et nonZeroValues.
  • rowIndices: tableau qui contient les index de ligne des éléments correspondants dans le tableau nonZeroValues.
  • nonZeroValues: tableau qui contient toutes les valeurs non nulles dans la matrice éparse.
  • sequenceStartFlag: true indique qu’il s’agit d’une nouvelle séquence. false signifie une continuation d’une séquence précédente.
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.

Les méthodes suivantes créent un objet Value à partir de NDArrayView.

public static Value Create(NDShape sampleShape, IEnumerable<NDArrayView> sequences, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value basé sur une collection de NDArrayViews. Chaque séquence dans sequences est une nouvelle séquence.

Paramètres :

  • sampleShape: forme deensoreur de la valeur en cours de création.
  • sequences: collection de séquences représentées par NDArrayView. Chaque NDArrayView représente une séquence.
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.
public static Value Create(NDShape sampleShape, IEnumerable<NDArrayView> sequences, IEnumerable<bool> sequenceStartFlags, DeviceDescriptor device, bool readOnly = false)

Crée un objet Value basé sur une collection de NDArrayViews. SequenceStartFlags spécifie si une séquence est une nouvelle séquence ou une continuation d’une séquence précédente.

Paramètres :

  • sampleShape: forme deensoreur de la valeur en cours de création.
  • sequences: collection de séquences représentées par NDArrayView. Chaque NDArrayView représente une séquence.
  • sequenceStartFlags: collection de valeurs booléennes. Chaque élément indique si la séquence correspondante est sequences une nouvelle séquence (en cas de true) ou une continuation d’une séquence précédente (en cas de false).
  • device: sur quel appareil l’objet Value doit être créé.
  • readOnly: la valeur est en lecture seule si cet indicateur est true.

Un objet Value contient les propriétés et méthodes suivantes.

public Value(NDArrayView data)

Construit une valeur multidimensionnelle sans masque.

public Value(NDArrayView data, NDMask mask)

Construit une valeur multidimensionnelle avec un masque associé.

public DataType DataType { get; }

DataType des données contenues dans l’objet Value.

public DeviceDescriptor Device { get; }

Descripteur de l’appareil sur lequel réside la valeur.

public NDShape Shape { get; }

Forme de la valeur.

public StroageFormat StorageFormat { get; }

Format de stockage de la valeur.

public bool IsSparse { get; }

Valeur booléenne indiquant si la valeur contient des données au format de stockage éparse.

public bool IsReadOnly { get; }

Valeur booléenne indiquant si la valeur est en lecture seule.

public int maskedCount { get; }

Nombre de valeurs masquées/non valides dans la valeur.

public void CopyFrom(Value Source)

Copie le contenu de source la valeur. Les formes des données et du masque de la Sourcevaleur doivent être identiques aux this données et au masque de la valeur.

Paramètre :

  • Source: objet source à partir duquel la valeur est copiée.
public Value DeepClone()

Crée une valeur avec un stockage nouvellement alloué sur le même appareil que this Value et copie this le contenu de la valeur dans la valeur nouvellement allouée.

public Value DeepClone(bool readOnly)

Crée une valeur avec un stockage nouvellement alloué sur le même appareil que this Value et copie this le contenu de la valeur dans la valeur nouvellement allouée.

Paramètre :

  • readOnly: le nouvel objet Value est en lecture seule si cet indicateur est true.
public Value Alias(bool readOnly)

Crée une valeur qui est un alias de this valeur. Paramètre :

  • readOnly: le nouvel objet Value est en lecture seule si cet indicateur est true.
public IList<IList<T>> GetDenseData<T>(Variable outputVariable)

Obtient les données stockées dans l’objet Value sous la forme d’une liste de séquences avec une longueur variable au format dense. Cette méthode retourne un IList IList<>. Chaque élément de la liste externe représente une séquence. Chaque séquence, représentée par IList, contient un nombre variable d’exemples. Chaque exemple se compose d’un nombre fixe d’éléments avec le type « T ». Le nombre d’éléments est déterminé par la forme de outputVariable. Le nombre d’échantillons est le nombre d’éléments dans IList divisé par le nombre d’éléments de l’exemple.

Paramètre :

  • outputVariable: variable à laquelle la valeur désigne. La forme de la variable doit correspondre à la forme de la valeur.
public IList<IList<int>> GetOneHotData(Variable outputVariable)

Obtient les données stockées dans l’objet Value sous la forme d’une liste de séquences avec une longueur variable au format à vecteur à chaud. Cette méthode retourne un IList IList<>. Chaque élément de la liste externe représente une séquence. Chaque séquence, représentée par IList, contient un nombre variable d’exemples. Chaque exemple est représenté par un index vers le vecteur à chaud. Le nombre d’exemples correspond au nombre d’éléments dans IList.

Paramètre :

  • outputVariable: variable à laquelle la valeur désigne. La taille du vecteur à chaud doit correspondre à celle définie dans la variable.
public void GetSparseData<T>(Variable outputVariable, out int sequenceLength, out IList<int> colStarts, out IList<int> rowIndices, out IList<T> nonZeroValues, out int numNonZeroValues)

Copiez les données stockées dans l’objet Value dans les mémoires tampons représentant une séquence au format éparse CSC. La mémoire tampon de séquence est redimensionnée si nécessaire. La valeur doit avoir la même forme de tenseur que outputVariable. En retour, sequenceLength est défini sur la longueur de la séquence stockée dans la valeur, et colStartsrowIndicesnonZeroValues contient les données des index de début de colonne, des index de ligne et des valeurs non nulles, et numNonZeroValues est définie sur le nombre de valeurs non nulles contenues dans this Value.

Paramètres :

  • outputVariable: indique la forme et les axes dynamiques lors de la copie de données de cette valeur vers les mémoires tampons.
  • sequenceLength: lors du retour, il est défini sur la longueur de la séquence stockée dans la valeur.
  • colStarts: en retour, il contient des index dans le nonZeorValues premier élément non nul de chaque colonne de la matrice.
  • rowIndices: en retour, il contient les index de ligne de chaque élément non nul de la matrice.
  • nonZeroValues: en retour, il contient des valeurs de tous les éléments non nuls de la matrice.
  • numNonZeroValues: en retour, il retourne le nombre d’éléments non nuls de la matrice.

Les méthodes suivantes seront bientôt déconseillées. Utilisez GetDenseData() et GetOneHotData() décrits ci-dessus.

public void CopyVariableValueTo<T>(Variable outputVariable, List<List<T>> sequences)

Copie les données stockées dans la valeur dans la mémoire tampon fournie par sequences. Il sequences s’agit d’une liste de séquences de longueur variable. Le nombre d’éléments contenus dans la liste externe correspond sequences au nombre de séquences dans la valeur. Chaque élément de la liste externe représente une séquence. Chaque séquence, représentée par List<T>, contient un nombre variable d’échantillons. Chaque exemple se compose d’un nombre fixe d’éléments avec le type de T. Le nombre d’éléments d’un échantillon est déterminé par la forme de outputVariable. La forme de la variable doit correspondre à la forme de la valeur.

Paramètres :

  • outputVariable: indique la forme et les axes dynamiques lors de la copie de données de la valeur vers le sequences.
  • sequences: mémoire tampon de sortie utilisée pour stocker les données copiées à partir de la valeur.
public void CopyVariableValueTo(Variable outputVariable, List<List<uint>> sequences

Copie les données stockées dans l’objet Value dans la mémoire tampon fournie par sequences. Il sequences s’agit d’une liste de séquences de longueur variable. Le nombre d’éléments contenus dans la liste externe correspond sequences au nombre de séquences dans la valeur. Chaque élément de la liste externe représente une séquence. Chaque séquence, représentée par List<uint>, contient un nombre variable d’échantillons. Chaque échantillon est représenté par un index pointant vers la valeur différente de zéro dans le vecteur à chaud. La taille de dimension du vecteur à chaud doit correspondre à celle définie dans le outputVariable.

Paramètres :

  • outputVariable: indique la forme et les axes dynamiques lors de la copie de données de la valeur vers le sequences.
  • sequences: mémoire tampon de sortie utilisée pour stocker les données copiées à partir de la valeur.

variable de classe

Désigne une entité symbolique correspondant aux entrées et sorties d’un Function.

Les propriétés de Variable celles-ci sont souvent utilisées dans l’évaluation :

public string Name { get; }

Nom de la variable.

public NDShape Shape { get; }

Forme de la variable.

public DataType DataTye { get; }

DataType(#enum-datatype) des données que la variable représente.

public VariableKind Kind { get; }

VariableKind de la variable.

public bool IsSparse { get; }

Valeur booléenne indiquant si la variable désigne les données éparses.

public bool IsInput { get; }

Valeur booléenne indiquant si la variable est une entrée.

public bool IsOutput { get; }

Valeur booléenne indiquant si la variable est une sortie.

public bool IsParameter { get; }

Valeur booléenne indiquant si la variable est un paramètre.

public bool IsConstant { get; }

Valeur booléenne indiquant si la variable est une constante.

public bool IsPlaceholder { get; }

Valeur booléenne indiquant si la variable est un espace réservé.

public IList<Axis> DynamicAxes { get; }

Retourne les axes dynamiques de la variable.

public Function Owner { get; }

Retourne la fonction dont la variable est une sortie. Retourne null lorsque la variable n’est pas de la sortie VariableKind.

classe DeviceDescriptor

Désigne une instance de périphérique de calcul.

La classe DeviceDescriptor contient les propriétés et méthodes suivantes :

public int Id { get; }

ID de l’appareil.

public DeviceKind Type { get; }

DeviceKind de l’appareil.

public static DeviceDescriptor CPUDevice { get; }

DeviceDescriptor représentant l’appareil processeur sur le système local.

public static DeviceDescriptor GPUDevice(int deviceId)

Obtient le DeviceDescriptor de l’appareil GPU sur le système local avec l’ID d’appareil CUDA spécifié.

Paramètre :

  • deviceId: ID d’appareil CUDA.
public static IList<DeviceDescriptor> AllDevices()

Obtient une liste de descripteurs de tous les appareils disponibles/pris en charge.

classe NDShape

Désigne une forme rectangulaire multidimensionnelle.

public NDShape()

Construit une forme NDShape avec 0 axes, qui désigne un scalaire.

public NDShape(int numAxes, int dimension)

Construit une instance NDShape avec la taille de classement et de dimension spécifiées. Chaque axe a la même dimensionnalité.

Paramètres :

  • numAxes: nombre d’axes de la forme.
  • dimension: taille de dimension appliquée à chaque axe.
public NDShape(int numAxes)

Construit une instance NDShape avec le rang spécifié. La dimensionnalité dans chaque axe est NDShape.InferredDimension.

Paramètre :

  • numAxes: nombre d’axes de la forme.
public static NDShape CreateNDShape(IEnumerable<int> dimensions)

Crée une instance NDShape avec des dimensions spécifiées. Paramètre :

  • dimensions: taille de dimension de chaque axe.
public int Rank { get; }

Rang du NDShape.

public IList<int> Dimensions { get; }

Dimensions de la forme NDShape.

public int TotalSize { get; }

Taille totale de la forme rectangulaire que la forme désigne.

public int this[int key] { get; }

Retourne la taille de dimension de l’axe spécifié.

public int IsUnknown { get; }

Valeur booléenne indiquant si la forme est la forme inconnue spéciale.

public int HasInferredDimension { get; }

Valeur booléenne indiquant si la taille de dimension de l’un des axes de la forme est inconnue/déduite (NDShape.InferredDimension).

public NDShape AppendShape(NDShape shape)

Crée et retourne une nouvelle forme construite en ajoutant les dimensions de la « forme » spécifiée aux this dimensions de la forme.

public NDShape SubShape(int beginAxisId, int endAxisId)

Crée et retourne une nouvelle instance NDShape avec les mêmes dimensions que this la plage d’axes spécifiée de la forme [beginAxisId, endAxisId).

public NDShape SubShape(int beginAxisId)

Crée et retourne une nouvelle instance NDShape avec les mêmes dimensions que this la plage d’axe de la forme entre l’axe beginAxisId (inclusif) et le dernier axe (inclusif).

classe NDArrayView

Désigne un tableau en écriture multidimensionnelle ou en lecture seule de valeurs élémentaires. Ce type désigne une vue et il peut y avoir plusieurs vues simultanées des données sous-jacentes à une instance NDArrayView. Les données sous-jacentes sont stockées dans un format épars ou dense et se trouvent sur un appareil spécifique.

public NDArrayView(NDShape viewShape, float[] dataBuffer, DeviceDescriptor device, bool readOnly = false)

public NDArrayView(NDShape viewShape, double[] dataBuffer, DeviceDescriptor device, bool readOnly = false)

Construit un NDArrayView avec le « dataBuffer » spécifié au format dense comme stockage de stockage sur l’appareil spécifié.

Paramètres :

  • viewShape: forme du NDArrayView en cours de création.
  • dataBuffer: valeurs de données contenues dans le NDArrayView. Le « dataBuffer » doit être au moins aussi grand que la taille totale de l’objet « viewShape » spécifié et doit survivre à l’objet NDArrayView créé.
  • device: sur quel appareil l’objet NDArrayView doit être créé.
  • readOnly: l’objet NDArrayView est en lecture seule si cet indicateur est true.
public NDArrayView(NDShape viewShape, int[] colStarts, int[] rowIndices, float[] nonZeroValues, DeviceDescriptor device, bool readOnly = false)

public NDArrayView(NDShape viewShape, int[] colStarts, int[] rowIndices, double[] nonZeroValues, DeviceDescriptor device, bool readOnly = false)

Construit un NDArrayView avec le stockage spécifié au format CSC partiellement alloué sur l’appareil spécifié. Les données éparses spécifiées doivent survivre à l’objet NDArrayView créé.

Paramètres :

  • viewShape: forme du NDArrayView en cours de création.
  • colStarts: le tableau contient des index pour chaque colonne dans les rowIndices tableaux et nonZeroValues.
  • rowIndices: tableau qui contient les index de ligne des éléments correspondants dans le tableau nonZeroValues.
  • nonZeroValues: tableau qui contient toutes les valeurs non nulles dans la matrice éparse. Les données éparses spécifiées doivent survivre à l’objet NDArrayView créé.
  • device: sur quel appareil l’objet NDArrayView doit être créé.
  • readOnly: l’objet NDArrayView est en lecture seule si cet indicateur est true.
public DeviceDescriptor Device

DeviceDescriptor de l’appareil sur lequel réside le NDArrayView.

public NDShape Shape

Forme du NDArrayView.

public DataType DataType

Type de données des données stockées par le NDArrayView.

public StroageFormat StorageFormat

Format de stockage du NDArrayView.

public bool IsSparse

Valeur booléenne indiquant si le NDArrayView contient des données au format de stockage partiellement alloué.

public bool IsReadOnly`

A boolean value indicating whether the NDArrayView is read-only.

***
```cs
public NDArrayView DeepClone()

Crée un NDArrayView avec un stockage nouvellement alloué sur le même appareil que this l’affichage et copie this le contenu de la vue dans la vue nouvellement allouée.

public NDArrayView DeepClone(bool readOnly)

Crée un NDArrayView avec un stockage nouvellement alloué sur le même appareil que this l’affichage et copie this le contenu de la vue dans la vue nouvellement allouée.

Paramètre :

  • readOnly: le nouvel objet NDArrayView est en lecture seule si cet indicateur est true.
public NDArrayView DeepClone(DeviceDescriptor device, bool readOnly)

Crée un NDArrayView avec un stockage nouvellement alloué sur l’appareil spécifié et copie this le contenu de la vue dans la vue nouvellement allouée.

Paramètres :

  • device: sur quel appareil le nouvel objet NDArrayView doit être créé.
  • readOnly: le nouvel objet NDArrayView est en lecture seule si cet indicateur est true.
public NDArrayView Alias(bool readOnly)

Crée un NDArrayView qui est un alias d’affichage this , c’est-à-dire une nouvelle vue de la même forme que this sur les mêmes données sous-jacentes.

Paramètre :

  • readOnly: le nouvel objet NDArrayView est en lecture seule si cet indicateur est true.
public NDArrayView AsShape(NDShape newShape)

Crée un NDArrayView qui est un alias d’affichage this , mais avec une nouvelle forme.

Paramètre :

  • newShape: forme du nouvel objet NDArrayView.
public void CopyFrom(NDArrayView source)

Copie le contenu du NDArrayView « source » à this afficher. Les formes de la vue « source » et this de la vue doivent être identiques.

Paramètre :

  • source: NDArrayView source dont le contenu est copié dans this la vue.
public void ChangeDevice(DeviceDescriptor device)

Remplace l’appareil du NDArrayView par l’appareil spécifié.

Paramètre :

  • device: appareil cible de l’objet NDArrayView.

classe NDMask

Désigne un masque multidimensionnel utilisé pour spécifier des sections spécifiques d’un objet NDArrayView comme masqué/non valide. Ce type désigne une vue et il peut y avoir plusieurs vues simultanées des données sous-jacentes à une instance NDMask.

public NDMask(NDShape shape, DeviceDescriptor device)

Construisez un nouvel objet Mask de forme spécifiée sur l’appareil spécifié.

Paramètres :

  • shape: forme de l’objet NDMask.
  • device: appareil cible de l’objet MDMask.
public int MaskedCount { get; }

Nombre de valeurs masquées/non valides.

public int Device { get; }

Descripteur de l’appareil sur lequel réside le masque

public int Shape { get; }

Forme du masque.

public void InvalidateSection(IEnumerable<int> sectionOffset, NDShape sectionShape)

Masquez la sous-section spécifiée comme non valide.

Paramètres :

  • sectionOffset: liste spécifiant les positions de début de la section qui doivent être masquées comme non valides.
  • sectionShape: la forme décrit la section qui doit être masquée comme non valide.
public void MarkSequenceBegin(IEnumerable<int> offset)

Marquez la position spécifiée comme début de séquence.

Paramètre :

  • sectionOffset: liste spécifiant les positions de début dans le masque qui doivent être masquées comme début de séquence.
public void MarkSequenceBegin(IEnumerable<int> offset, NDShape sectionShape)

Marquez la sous-section spécifiée comme début de séquence.

Paramètres :

  • offset: liste spécifiant les positions de début de la section qui doivent être masquées comme début de séquence.
  • sectionShape: la forme décrit la section qui doit être masquée au début de la séquence.
public void Clear()

Effacez le masque. Toutes les valeurs actuellement masquées comme non valides sont définies sur valides.

public NDMask DeepClone(DeviceDescriptor device)

Crée un NDMask avec un stockage nouvellement alloué sur l’appareil spécifié et copie this le contenu du masque dans la vue nouvellement allouée.

Paramètre :

  • device: appareil cible de l’objet MDMask.
public NDMask DeepClone()

Crée un nouveau masque NDMask avec un stockage nouvellement alloué sur le même appareil que this le masque et copie this le contenu du masque dans le masque nouvellement alloué.

public NDMask Alias()

Crée un objet NDMask qui est un alias de this masque.

public void CopyFrom(NDMask source)

Copie le contenu du source masque NDMask this . Les formes du masque et this du source masque doivent être identiques.

Paramètre :

  • source: source NDMask dont le contenu est copié dans l’affichage this .

Axe des classes

Désigne un axe d’un Variable. Outre les axes statiques correspondant à chacun des axes de la forme de la variable, les variables de type « Entrée » et les variables « Sortie » dépendant d’une variable « Input » ont également 2 axes dynamiques supplémentaires dont les dimensions sont connues uniquement lorsque la variable est liée aux données réelles pendant le calcul (viz. axe de séquence et axe de lot indiquant l’axe le long duquel plusieurs séquences sont traitées par lot)

Les propriétés suivantes sont définies dans la classe Axis

public string Name { get; }

Nom de l’axe.

public bool IsStatic { get; }

Retourne une valeur booléenne indiquant si l’axe correspond à un axe statique.

public bool IsDynamic { get; }

Retourne une valeur booléenne indiquant si l’axe correspond à un axe dynamique.

classe Utils

public static void SetMaxNumCPUThreads(int numCPUThreads)

Définit le nombre maximal de threads processeur à l’échelle du processus à utiliser par n’importe quelle opération de calcul individuelle.

public static int GetMaxNumCPUThreads()

Retourne le nombre maximal de threads processeur à l’échelle du processus à utiliser par n’importe quelle opération de calcul individuelle.

public static void SetTraceLevel(TraceLevel value)

Spécifie le niveau détaillé de journalisation globale.

public static TraceLevel GetTraceLevel()

Retourne le niveau détaillé de journalisation actuel.

enum VariableKind

Indique le type d’un objet symbolique Variable

enum VariableKind { Input, Output, Parameter, Constant, Placeholder };

enum DataType

Indique le type de données des entités de données symboliques ou les données réelles.

enum DataType { Unknown, Float, Double };

énumération DeviceKind

Indique le type d’un appareil de calcul.

enum DeviceKind { CPU, GPU };

enum StorageFormat

Indique le format du stockage sous-jacent à une instance d’un NDArrayView.

enum StorageFormat { Dense, SparseCSC, SparseBlockCol };

enum ParameterCloningMethod

Indique comment les paramètres sont gérés lors du clonage d’une fonction.

enum ParameterCloningMethod {
    Share, // Parameters are shared between the Function being cloned and the new clone.
    Clone, // New learnable Parameters are created and initialized with the current values of the corresponding Parameters of the Function being cloned.
    Freeze // Parameters are cloned and made immutable.
};

énumération TraceLevel

Indique les niveaux de détail de journalisation.

enum TraceLevel { Error, Warning, Info };