Tenseur

Le TensorHandle sous-jacent.

Décompresse la dimension donnée d'un tenseur de rang R en plusieurs tenseurs de rang (R-1) . Décompresse N tenseurs de ce tenseur en le découpant le long de la dimension axis , où N est déduit de la forme de ce tenseur. Par exemple, étant donné un tenseur de forme [A, B, C, D] :

• Si axis == 0 alors le i -ème tenseur du tableau renvoyé est la tranche self[i, :, :, :] et chaque tenseur de ce tableau aura la forme [B, C, D] . (Notez que la dimension décompressée a disparu, contrairement à Tensor.split(numSplits:alongAxis) , ou Tensor.split(sizes:alongAxis) ).
• Si axis == 1 alors le i -ième tenseur du tableau renvoyé est la value[:, i, :, :] et chaque tenseur de ce tableau aura la forme [A, C, D] .
• Etc.

C'est le contraire de Tensor.init(stacking:alongAxis:) .

Divise un tenseur en plusieurs tenseurs. Le tenseur est divisé le long axis des dimensions en count plus petits. Cela nécessite que count divise uniformément shape[axis] .

Par exemple:

// 'value' is a tensor with shape [5, 30]
// Split 'value' into 3 tensors along dimension 1:
let parts = value.split(count: 3, alongAxis: 1)
parts[0] // has shape [5, 10]
parts[1] // has shape [5, 10]
parts[2] // has shape [5, 10]

Divise un tenseur en plusieurs tenseurs. Le tenseur est divisé en morceaux sizes.shape[0] . La forme de la i -ème pièce a la même forme que ce tenseur sauf le long de axis des dimensions où la taille est sizes[i] .

Par exemple:

// 'value' is a tensor with shape [5, 30]
// Split 'value' into 3 tensors with sizes [4, 15, 11] along dimension 1:
let parts = value.split(sizes: Tensor<Int32>([4, 15, 11]), alongAxis: 1)
parts[0] // has shape [5, 4]
parts[1] // has shape [5, 15]
parts[2] // has shape [5, 11]

Renvoie un tenseur carrelé, construit en carrelant ce tenseur.

Ce constructeur crée un nouveau tenseur en répliquant ce tenseur multiples fois. La i 'ième dimension du tenseur construit a des éléments self.shape[i] * multiples[i] , et les valeurs de ce tenseur sont répliquées multiples[i] le long de la i 'ième dimension. Par exemple, mosaïquer [abcd] par [2] produit [abcdabcd] .

Renvoie un tenseur carrelé, construit en carrelant ce tenseur.

Ce constructeur crée un nouveau tenseur en répliquant ce tenseur multiples fois. La i 'ième dimension du tenseur construit a des éléments self.shape[i] * multiples[i] , et les valeurs de ce tenseur sont répliquées multiples[i] le long de la i 'ième dimension. Par exemple, mosaïquer [abcd] par [2] produit [abcdabcd] .

Remodeler à la forme du Tensor spécifié.

Remodeler selon la forme spécifiée.

Remodeler selon le Tensor spécifié représentant une forme.

Renvoie une copie du tenseur réduite en un Tensor 1-D, dans l'ordre des lignes principales.

Renvoie un Tensor développé en forme, avec une dimension de 1 insérée aux indices de forme spécifiés.

Renvoie un Tensor développé en forme, avec une dimension de 1 insérée aux indices de forme spécifiés.

Renvoie un Tensor de rang élevé avec une dimension principale de 1.

Supprime les dimensions spécifiées de taille 1 de la forme d'un tenseur. Si aucune dimension n'est spécifiée, toutes les dimensions de taille 1 seront supprimées.

Supprime les dimensions spécifiées de taille 1 de la forme d'un tenseur. Si aucune dimension n'est spécifiée, toutes les dimensions de taille 1 seront supprimées.

Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre spécifié.

Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre spécifié.

Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre spécifié.

Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre spécifié.

Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre spécifié.

Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre spécifié.

Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre inverse.

Renvoie un tenseur avec les dimensions spécifiées inversées.

Renvoie un tenseur avec les dimensions spécifiées inversées.

Renvoie un tenseur avec les dimensions spécifiées inversées.

Renvoie un tenseur concaténé le long de l'axe spécifié.

Opérateur de concaténation.

Renvoie un tenseur en rassemblant des tranches de l'entrée aux indices le long de la dimension axis

Pour indices 0-D (scalaires) :

result[p_0,          ..., p_{axis-1},
       p_{axis + 1}, ..., p_{N-1}] =
self[p_0,          ..., p_{axis-1},
     indices,
     p_{axis + 1}, ..., p_{N-1}]

Pour indices 1-D (vecteur) :

result[p_0,          ..., p_{axis-1},
       i,
       p_{axis + 1}, ..., p_{N-1}] =
self[p_0,          ..., p_{axis-1},
     indices[i],
     p_{axis + 1}, ..., p_{N-1}]

Dans le cas général, produit un tenseur résultant où :

result[p_0,             ..., p_{axis-1},
       i_{batch\_dims}, ..., i_{M-1},
       p_{axis + 1},    ..., p_{N-1}] =
self[p_0,             ..., p_{axis-1},
     indices[i_0,     ..., i_{M-1}],
     p_{axis + 1},    ..., p_{N-1}]

où N = self.rank et M = indices.rank .

La forme du tenseur résultant est : self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...] .

Renvoie des tranches de ce tenseur aux indices le long de la dimension axis , tout en ignorant les premières dimensions batchDimensionCount qui correspondent aux dimensions du lot. Le regroupement est effectué le long de la première dimension non-batch.

Exécute une fonctionnalité similaire à gathering , sauf que la forme du tenseur résultante est désormais shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] .

Renvoie un tenseur en rassemblant les valeurs après avoir appliqué le masque booléen fourni à l'entrée.

Par exemple:

// 1-D example
// tensor is [0, 1, 2, 3]
// mask is [true, false, true, false]
tensor.gathering(where: mask) // is [0, 2]

// 2-D example
// tensor is [[1, 2], [3, 4], [5, 6]]
// mask is [true, false, true]
tensor.gathering(where: mask) // is [[1, 2], [5, 6]]

En général, 0 < mask.rank = K <= tensor.rank , et la forme du mask doit correspondre aux K premières dimensions de la forme du tensor . On a alors : tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] où [i1, ..., iK] est la i ème true entrée du mask (ordre majeur des lignes).

L' axis peut être utilisé avec mask pour indiquer l'axe à partir duquel masquer. Dans ce cas, axis + mask.rank <= tensor.rank et la 's shape must match the first mask doivent correspondre aux premières dimensions of the forme du tenseur.

Renvoie les emplacements des valeurs non nulles/vraies dans ce tenseur.

Les coordonnées sont renvoyées dans un tenseur 2D où la première dimension (lignes) représente le nombre d'éléments non nuls et la deuxième dimension (colonnes) représente les coordonnées des éléments non nuls. Gardez à l'esprit que la forme du tenseur de sortie peut varier en fonction du nombre de valeurs vraies qu'il contient. Les indices sont affichés dans l'ordre des lignes principales.

Par exemple:

// 'input' is [[true, false], [true, false]]
// 'input' has 2 true values and so the output has 2 rows.
// 'input' has rank of 2, and so the second dimension of the output has size 2.
input.nonZeroIndices() // is [[0, 0], [1, 0]]

// 'input' is [[[ true, false], [ true, false]],
//             [[false,  true], [false,  true]],
//             [[false, false], [false,  true]]]
// 'input' has 5 true values and so the output has 5 rows.
// 'input' has rank 3, and so the second dimension of the output has size 3.
input.nonZeroIndices() // is [[0, 0, 0],
                       //     [0, 1, 0],
                       //     [1, 0, 1],
                       //     [1, 1, 1],
                       //     [2, 1, 1]]

Diffusez sous la même forme que le Tensor spécifié.

Extrait une tranche du tenseur défini par des limites inférieure et supérieure pour chaque dimension.

Vérifie que chaque élément d' axes désigne un axe de self , et arrête le programme avec un diagnostic dans le cas contraire.

Vérifie que chaque élément d' axes désigne un axe de self , et arrête le programme avec un diagnostic dans le cas contraire.

Vérifie que k désigne un axe de self et arrête le programme avec un diagnostic dans le cas contraire.

Crée une copie de other sur le Device donné.

Crée un tenseur avec la forme spécifiée et une valeur scalaire unique et répétée.

Crée un tenseur avec la forme spécifiée et une valeur scalaire unique et répétée.

Crée un tenseur en diffusant le scalaire donné à un rang donné, toutes les dimensions étant égales à 1.

Crée un tenseur à partir d'un tableau de tenseurs (qui peuvent eux-mêmes être des scalaires).

Empile les tensors , le long de la dimension axis , dans un nouveau tenseur de rang supérieur au tenseur actuel et chaque tenseur dans tensors .

Étant donné que tensors ont tous la forme [A, B, C] et tensors.count = N , alors :

• si axis == 0 alors le tenseur résultant aura la forme [N, A, B, C] .
• si axis == 1 alors le tenseur résultant aura la forme [A, N, B, C] .
• etc.

Par exemple:

// 'x' is [1, 4]
// 'y' is [2, 5]
// 'z' is [3, 6]
Tensor(stacking: [x, y, z]) // is [[1, 4], [2, 5], [3, 6]]
Tensor(stacking: [x, y, z], alongAxis: 1) // is [[1, 2, 3], [4, 5, 6]]

C'est le contraire de Tensor.unstacked(alongAxis:) .

Concatène tensors le long de la dimension axis .

Étant donné que tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] , alors le résultat concaténé a la forme [D0, D1, ... Raxis, ...Dn] , où Raxis = sum(Daxis(i)) . Autrement dit, les données des tenseurs d'entrée sont jointes le long de la dimension axis .

Par exemple:

// t1 is [[1, 2, 3], [4, 5, 6]]
// t2 is [[7, 8, 9], [10, 11, 12]]
Tensor(concatenating: [t1, t2]) // is [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
Tensor(concatenating: [t1, t2], alongAxis: 1) // is [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]

// t3 has shape [2, 3]
// t4 has shape [2, 3]
Tensor(concatenating: [t3, t4]) // has shape [4, 3]
Tensor(concatenating: [t3, t4], alongAxis: 1) // has shape [2, 6]

Remplace les éléments de ce tenseur par other dans les voies où mask est true .

Renvoie vrai si le type scalaire physique est à précision réduite.

Actuellement, les types scalaires physiques à précision réduite incluent uniquement BFloat16 .

Transforme un scalaire en tenseur avec le même dispositif et la même précision que le tenseur donné.

Renvoie une copie de self convertie en type scalaire physique BFloat16 .

Renvoie une copie de self en type scalaire physique Scalar .

Le nombre de dimensions du Tensor .

La forme du Tensor .

Le nombre de scalaires dans le Tensor .

Le rang du tenseur, représenté par un Tensor<Int32> .

Les dimensions du tenseur, représentées par un Tensor<Int32> .

Le nombre de scalaires dans le tenseur, représenté par un Tensor<Int32> .

Renvoie true si rank est égal à 0 et false sinon.

Renvoie l'élément scalaire unique si rank est égal à 0 et nil sinon.

Remodeler en scalaire.

Crée un tenseur 0-D à partir d'une valeur scalaire.

Crée un tenseur 1D à partir de scalaires.

Crée un tenseur 1D à partir de scalaires.

Crée un tenseur avec la forme spécifiée et des scalaires contigus dans l'ordre des lignes principales.

Crée un tenseur avec la forme spécifiée et des scalaires contigus dans l'ordre des lignes principales.

Crée un tenseur avec la forme spécifiée et des scalaires contigus dans l'ordre des lignes principales.

Crée un tenseur avec la forme spécifiée et des scalaires contigus dans l'ordre des lignes principales.

Le type des éléments d’un tableau littéral.

Crée un tenseur initialisé avec les éléments donnés.

Une représentation textuelle du tenseur.

Une représentation textuelle du tenseur. Renvoie une description résumée si summarize est vrai et que le nombre d'éléments dépasse le double de edgeElementCount .

Une représentation textuelle complète et non joliment imprimée du tenseur, montrant tous les scalaires.

Les annotations décrivant ce tenseur.

Un alias pour les annotations.

Un mode qui dicte la façon dont un tenseur est rempli.

Renvoie un tenseur complété par une constante en fonction des tailles de remplissage spécifiées.

Renvoie un tenseur rembourré en fonction des tailles et du mode de remplissage spécifiés.

Renvoie un tenseur de scalaires booléens en calculant lhs < rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs <= rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs > rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs >= rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs < rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs <= rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs > rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs >= rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs < rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs <= rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs > rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs >= rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs == rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs != rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs == rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs != rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs == rhs par élément.

Renvoie un tenseur de scalaires booléens en calculant lhs != rhs par élément.

Renvoie un tenseur de valeurs booléennes indiquant si les éléments de self sont approximativement égaux à ceux de other .

Renvoie true si tous les éléments de self sont approximativement égaux à ceux de other .

Exécute une somme de répliques croisées pour ce tenseur. La même somme de répliques croisées doit se produire sur chacun des autres appareils participant à la somme.

Effectuez une conversion de type élément par élément à partir d'un tenseur Bool .

Effectuez une conversion élément par élément à partir d'un autre Tensor .

Crée un tenseur avec tous les scalaires définis sur zéro.

Crée un tenseur avec tous les scalaires définis sur un.

Crée un tenseur avec tous les scalaires définis sur zéro qui a la même forme et le même type que le tenseur fourni.

Crée un tenseur avec tous les scalaires définis sur un qui a la même forme et le même type que le tenseur fourni.

Crée un tenseur 1D représentant une séquence allant d'une valeur de départ à une valeur finale (sans l'inclure), en incrémentant la quantité spécifiée.

Crée un tenseur 1D représentant une séquence allant d'une valeur de départ à une valeur finale (sans l'inclure), en incrémentant la quantité spécifiée.

Crée un tenseur unique à des indices donnés. Les emplacements représentés par indices prennent la valeur onValue ( 1 par défaut), tandis que tous les autres emplacements prennent la valeur offValue ( 0 par défaut). Si les indices d'entrée sont de rang n , le nouveau tenseur aura le rang n+1 . Le nouvel axe est créé au niveau de axis des dimensions (par défaut, le nouvel axe est ajouté à la fin).

Si indices est un scalaire, la forme du nouveau tenseur sera un vecteur de longueur depth .

Si indices est un vecteur de longueur features , la forme de sortie sera : caractéristiques x profondeur, si axe == -1 profondeur x caractéristiques, si axe == 0

Si indices est une matrice (lot) de forme [batch, features] , la forme de sortie sera : lot x caractéristiques x profondeur, si axe == -1 lot x profondeur x caractéristiques, si axe == 1 profondeur x lot x caractéristiques , si axe == 0

Crée un tenseur 1D représentant une séquence à partir d'une valeur de départ jusqu'à et y compris une valeur de fin, espacée uniformément pour générer le nombre de valeurs spécifié.

Crée un tenseur 1D représentant une séquence à partir d'une valeur de départ jusqu'à et y compris une valeur de fin, espacée uniformément pour générer le nombre de valeurs spécifié.

Crée un tenseur avec la forme spécifiée, en échantillonnant de manière aléatoire les valeurs scalaires à partir d'une distribution uniforme entre lowerBound et upperBound .

Crée un tenseur avec la forme spécifiée, en échantillonnant de manière aléatoire les valeurs scalaires à partir d'une distribution uniforme entre lowerBound et upperBound .

Crée un tenseur avec la forme spécifiée, en échantillonnant de manière aléatoire les valeurs scalaires d'une distribution normale.

Crée un tenseur avec la forme spécifiée, en échantillonnant de manière aléatoire les valeurs scalaires d'une distribution normale tronquée.

Crée un tenseur en tirant des échantillons d'une distribution catégorielle.

Crée un tenseur avec la forme spécifiée en effectuant une initialisation uniforme Glorot (Xavier).

Il tire des échantillons aléatoires à partir d'une distribution uniforme entre -limit et limit générée par le générateur de nombres aléatoires par défaut, où limit est sqrt(6 / (fanIn + fanOut)) et fanIn / fanOut représentent le nombre de fonctionnalités d'entrée et de sortie multiplié par le récepteur. taille du champ.

Référence : « Comprendre la difficulté de former des réseaux de neurones à rétroaction profonde »

Crée un tenseur avec la forme spécifiée en effectuant une initialisation normale Glorot (Xavier).

Il tire des échantillons aléatoires d'une distribution normale tronquée centrée sur 0 avec un écart type sqrt(2 / (fanIn + fanOut)) généré par le générateur de nombres aléatoires par défaut, où fanIn / fanOut représente le nombre de caractéristiques d'entrée et de sortie multiplié par le champ récepteur taille.

Référence : « Comprendre la difficulté de former des réseaux de neurones à rétroaction profonde »

Crée un tenseur avec la forme spécifiée en effectuant une initialisation uniforme He (Kaiming).

Il tire des échantillons aléatoires à partir d'une distribution uniforme entre -limit et limit générée par le générateur de nombres aléatoires par défaut, où limit est sqrt(6 / fanIn) et fanIn représente le nombre d'entités d'entrée multiplié par la taille du champ récepteur.

Référence : « Plonger en profondeur dans les redresseurs : surpasser les performances au niveau humain sur la classification ImageNet »

Crée un tenseur avec la forme spécifiée en effectuant une initialisation normale He (Kaiming).

Il tire des échantillons aléatoires d'une distribution normale tronquée centrée sur 0 avec un écart type sqrt(2 / fanIn)) généré par le générateur de nombres aléatoires par défaut, où fanIn représente le nombre d'entités d'entrée multiplié par la taille du champ récepteur.

Référence : « Plonger en profondeur dans les redresseurs : surpasser les performances au niveau humain sur la classification ImageNet »

Crée un tenseur avec la forme spécifiée en effectuant une initialisation uniforme LeCun.

Il tire des échantillons aléatoires à partir d'une distribution uniforme entre -limit et limit générée par le générateur de nombres aléatoires par défaut, où limit est sqrt(3 / fanIn) et fanIn représente le nombre d'entités d'entrée multiplié par la taille du champ récepteur.

Référence : « BackProp efficace »

Crée un tenseur avec la forme spécifiée en effectuant l'initialisation normale LeCun.

Il tire des échantillons aléatoires d'une distribution normale tronquée centrée sur 0 avec un écart type sqrt(1 / fanIn) généré par le générateur de nombres aléatoires par défaut, où fanIn représente le nombre d'entités d'entrée multiplié par la taille du champ récepteur.

Référence : « BackProp efficace »

Crée une matrice ou un tenseur orthogonal.

Si la forme du tenseur à initialiser est bidimensionnelle, il est initialisé avec une matrice orthogonale obtenue à partir de la décomposition QR d'une matrice de nombres aléatoires issus d'une distribution normale. Si la matrice comporte moins de lignes que de colonnes, la sortie aura des lignes orthogonales. Sinon, la sortie aura des colonnes orthogonales.

Si la forme du tenseur à initialiser est plus que bidimensionnelle, une matrice de forme [shape[0] * ... * shape[rank - 2], shape[rank - 1]] est initialisée. La matrice est ensuite remodelée pour donner un tenseur de la forme souhaitée.

Renvoie la partie diagonale [par lots] d'un tenseur [par lots]. Pour l'instance tensorielle de la forme [..., M, N] , la sortie est un tenseur de la forme [..., K] , où K est égal min(N, M) .

Par exemple:

// 't' is [[1, 0, 0, 0]
//         [0, 2, 0, 0]
//         [0, 0, 3, 0]
//         [0, 0, 0, 4]]
t.diagonalPart()
// [1, 2, 3, 4]

Construit un tableau diagonal [par lots]. Pour l'instance tensorielle de la forme [..., M] , la sortie est un tenseur de la forme [..., M, M] .

Par exemple:

// 't' is [1, 2, 3, 4]

t.diagonal()
// [[1, 0, 0, 0]
//  [0, 2, 0, 0]
//  [0, 0, 3, 0]
//  [0, 0, 0, 4]]

Renvoie self avec de nouvelles valeurs diagonales, étant donné que self est une matrice facultativement groupée.

Le tenseur renvoyé a la même forme et les mêmes valeurs que self , à l'exception des diagonales spécifiées des matrices les plus internes qui sont écrasées par les valeurs de diagonal .

Diagonale de paramètre : un tenseur de rank - 1 représentant les nouvelles valeurs diagonales.

Renvoie une copie d'un tenseur le plus interne défini par les limites d'une bande centrale. La sortie est un tenseur de la même forme que l'instance [..., :, :] .

Par exemple:

// 't' is [[ 0,  1,  2, 3]
//         [-1,  0,  1, 2]
//         [-2, -1,  0, 1]
//         [-3, -2, -1, 0]]

t.bandPart(1, -1)
// [[ 0,  1,  2, 3]
//  [-1,  0,  1, 2]
//  [ 0, -1,  0, 1]
//  [ 0,  0, -1, 0]]

t.bandPart(2, 1)
// [[ 0,  1,  0, 0]
//  [-1,  0,  1, 0]
//  [-2, -1,  0, 1]
//  [ 0, -2, -1, 0]]

Renvoie la décomposition QR de chaque matrice interne du tenseur, un tenseur avec des matrices orthogonales internes q et un tenseur avec des matrices triangulaires supérieures internes r , tels que le tenseur est égal à matmul(q, r) .

Renvoie la décomposition en valeurs singulières de self , étant donné que self est une matrice éventuellement groupée.

La décomposition en valeurs singulières (SVD) de la matrice self facultativement par lots est constituée des valeurs s , u et v , telles que :

self[..., :, :] = u[..., :, :] • s[..., :, :].diagonal() • v[..., :, :].transposed()`

self must be a tensor with shape […, M, N] . Let K = min(M, N)`.

La racine carrée de x .

Pour les types réels, si x est négatif, le résultat est .nan . Pour les types complexes il y a une branche coupée sur l’axe réel négatif.

Le cosinus de x , interprété comme un angle en radians.

Le sinus de x , interprété comme un angle en radians.

La tangente de x , interprétée comme un angle en radians.

Le cosinus inverse de x en radians.

Le sinus inverse de x en radians.

La tangente inverse de x en radians.

Le cosinus hyperbolique de x .

Le sinus hyperbolique de x .

La tangente hyperbolique de x .