Cette page a été traduite par l'API Cloud Translation.
Switch to English

Tenseur

@frozen
public struct Tensor<Scalar> where Scalar : TensorFlowScalar
extension Tensor: Collatable
extension Tensor: CopyableToDevice
extension Tensor: AnyTensor
extension Tensor: ExpressibleByArrayLiteral
extension Tensor: CustomStringConvertible
extension Tensor: CustomPlaygroundDisplayConvertible
extension Tensor: CustomReflectable
extension Tensor: TensorProtocol
extension Tensor: TensorGroup
extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint
extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint
extension Tensor: Mergeable where Scalar: TensorFlowFloatingPoint
extension Tensor: Equatable where Scalar: Equatable
extension Tensor: Codable where Scalar: Codable
extension Tensor: AdditiveArithmetic where Scalar: Numeric
extension Tensor: PointwiseMultiplicative where Scalar: Numeric
extension Tensor: Differentiable & EuclideanDifferentiable where Scalar: TensorFlowFloatingPoint
extension Tensor: DifferentiableTensorProtocol
where Scalar: TensorFlowFloatingPoint

Un tableau multidimensionnel d'éléments qui est une généralisation de vecteurs et de matrices à des dimensions potentiellement plus élevées.

Le paramètre générique Scalar décrit le type de scalaires dans le tenseur (comme Int32 , Float , etc.).

  • Le TensorHandle sous- TensorHandle .

    Remarque

    handle est public pour autoriser les opérations définies par l'utilisateur, mais ne doit normalement pas être utilisé.

    Déclaration

    public let handle: TensorHandle<Scalar>
  • Déclaration

    public init(handle: TensorHandle<Scalar>)
  • 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 de l' 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 dans le tableau retourné est la tranche self[i, :, :, :] et chaque tenseur de ce tableau aura la forme [B, C, D] . (Notez que la dimension Tensor.split(numSplits:alongAxis) disparu, contrairement à Tensor.split(numSplits:alongAxis) , ou Tensor.split(sizes:alongAxis) ).
    • Si axis == 1 alors le i ième tenseur dans le tableau retourné est la value[:, i, :, :] la tranche value[:, i, :, :] et chaque tenseur de ce tableau aura la forme [A, C, D] .
    • Etc.

    C'est l'opposé de Tensor.init(stacking:alongAxis:) .

    Condition préalable

    axis doit être dans la plage [-rank, rank) , où rank est le rang des tenseurs fournis.

    Déclaration

    @differentiable
    public func unstacked(alongAxis axis: Int = 0) -> [Tensor]

    Paramètres

    axis

    Dimension le long de laquelle décompresser. Les valeurs négatives s'enroulent.

    Valeur de retour

    Tableau contenant les tenseurs non empilés.

  • Divise un tenseur en plusieurs tenseurs. Le tenseur est divisé le long de l' axis dimensions en count plus petits. Cela nécessite que le count divise également la 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]
    

    Condition préalable

    count doit diviser la taille de l' axis des dimensions de manière égale.

    Condition préalable

    axis doit être dans la plage [-rank, rank) , où rank est le rang des tenseurs fournis.

    Déclaration

    @differentiable
    public func split(count: Int, alongAxis axis: Int = 0) -> [Tensor]

    Paramètres

    count

    Nombre de fractionnements à créer.

    axis

    La dimension le long de laquelle diviser ce tenseur. Les valeurs négatives s'enroulent.

    Valeur de retour

    Un tableau contenant la partie tenseurs.

  • Divise un tenseur en plusieurs tenseurs. Le tenseur est divisé en sizes.shape[0] . La forme de la i ème pièce a la même forme que ce tenseur sauf le long de l' axis dimensions où la taille est des 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]
    

    Condition préalable

    Les valeurs en sizes doivent correspondre à la taille de l' axis de cote.

    Condition préalable

    axis doit être dans l'intervalle [-rank, rank) , où rank est le rang des tenseurs fournis.

    Déclaration

    @differentiable(wrt: self)
    public func split(sizes: Tensor<Int32>, alongAxis axis: Int = 0) -> [Tensor]

    Paramètres

    sizes

    Tenseur 1-D contenant la taille de chaque scission.

    axis

    Dimension le long de laquelle diviser ce tenseur. Les valeurs négatives s'enroulent.

    Valeur de retour

    Tableau contenant les parties des tenseurs.

  • Déclaration

    @differentiable(wrt: self)
    public func split(sizes: [Int], alongAxis axis: Int = 0) -> [Tensor]
  • Renvoie un tenseur en mosaïque, construit en tapant ce tenseur.

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

    Condition préalable

    Le rank attendu des multiples doit être 1 .

    Condition préalable

    La forme des multiples doit être [tensor.rank] .

    Condition préalable

    Tous les scalaires en multiples doivent être non négatifs.

    Déclaration

    @differentiable(wrt: self)
    public func tiled(multiples: [Int]) -> Tensor
  • Renvoie un tenseur en mosaïque, construit en tapant ce tenseur.

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

    Condition préalable

    Le rank attendu des multiples doit être 1 .

    Condition préalable

    La forme des multiples doit être [tensor.rank] .

    Déclaration

    @differentiable(wrt: self)
    public func tiled(multiples: Tensor<Int32>) -> Tensor
  • Remodeler à la forme du Tensor spécifié.

    Condition préalable

    Le nombre de scalaires correspond à la nouvelle forme.

    Déclaration

    @differentiable(wrt: self)
    public func reshaped<T>(like other: Tensor<T>) -> Tensor where T : TensorFlowScalar
  • Remodeler à la forme spécifiée.

    Condition préalable

    Le nombre de scalaires correspond à la nouvelle forme.

    Déclaration

    @differentiable(wrt: self)
    public func reshaped(to newShape: TensorShape) -> Tensor
  • Remodeler au Tensor spécifié représentant une forme.

    Condition préalable

    Le nombre de scalaires correspond à la nouvelle forme.

    Déclaration

    @differentiable(wrt: self)
    public func reshaped(toShape newShape: Tensor<Int32>) -> Tensor
  • Retourner une copie du tenseur effondré dans un 1-D Tensor , dans l' ordre des lignes majeur.

    Déclaration

    @differentiable(wrt: self)
    public func flattened() -> Tensor
  • Renvoie un Tensor développé par la forme, avec une dimension de 1 insérée aux indices de forme spécifiés.

    Déclaration

    @differentiable(wrt: self)
    public func expandingShape(at axes: Int...) -> Tensor
  • Renvoie un Tensor développé par la forme, avec une dimension de 1 insérée aux indices de forme spécifiés.

    Déclaration

    @differentiable(wrt: self)
    public func expandingShape(at axes: [Int]) -> Tensor
  • Renvoie un Tensor rang élevé avec une dimension principale de 1.

    Déclaration

    @differentiable(wrt: self)
    public func rankLifted() -> Tensor
  • 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.

    Déclaration

    @differentiable(wrt: self)
    public func squeezingShape(at axes: Int...) -> Tensor
  • 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.

    Déclaration

    @differentiable(wrt: self)
    public func squeezingShape(at axes: [Int]) -> Tensor
  • Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre spécifié.

    Déclaration

    @differentiable(wrt: self)
    public func transposed(permutation: Tensor<Int32>) -> Tensor
  • Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre spécifié.

    Déclaration

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
    @differentiable(wrt: self)
    public func transposed(withPermutations permutations: Tensor<Int32>) -> Tensor
  • Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre spécifié.

    Déclaration

    @differentiable(wrt: self)
    public func transposed(permutation: [Int]) -> Tensor
  • Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre spécifié.

    Déclaration

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
    @differentiable(wrt: self)
    public func transposed(withPermutations permutations: [Int]) -> Tensor
  • Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre spécifié.

    Déclaration

    @differentiable(wrt: self)
    public func transposed(permutation: Int...) -> Tensor
  • Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre spécifié.

    Déclaration

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
    @differentiable(wrt: self)
    public func transposed(withPermutations permutations: Int...) -> Tensor
  • Renvoie un tenseur transposé, avec des dimensions permutées dans l'ordre inverse.

    Déclaration

    @differentiable(wrt: self)
    public func transposed() -> Tensor
  • Renvoie un tenseur avec des dimensions spécifiées inversées.

    Condition préalable

    Chaque valeur des axes doit être dans la plage -rank..<rank .

    Condition préalable

    Il ne doit y avoir aucune duplication dans les axes .

    Déclaration

    @differentiable(wrt: self)
    public func reversed(inAxes axes: Tensor<Int32>) -> Tensor
  • Renvoie un tenseur avec des dimensions spécifiées inversées.

    Condition préalable

    Chaque valeur des axes doit être dans la plage -rank..<rank .

    Condition préalable

    Il ne doit y avoir aucune duplication dans les axes .

    Déclaration

    @differentiable(wrt: self)
    public func reversed(inAxes axes: [Int]) -> Tensor
  • Renvoie un tenseur avec des dimensions spécifiées inversées.

    Condition préalable

    Chaque valeur des axes doit être dans la plage -rank..<rank .

    Condition préalable

    Il ne doit y avoir aucune duplication dans les axes .

    Déclaration

    @differentiable(wrt: self)
    public func reversed(inAxes axes: Int...) -> Tensor
  • Renvoie un tenseur concaténé le long de l'axe spécifié.

    Condition préalable

    Les tenseurs doivent avoir les mêmes dimensions, sauf pour l'axe spécifié.

    Condition préalable

    L'axe doit être dans la plage -rank..<rank .

    Déclaration

    @differentiable
    public func concatenated(with other: Tensor, alongAxis axis: Int = 0) -> Tensor
  • Opérateur de concaténation.

    Remarque

    ++ est un opérateur personnalisé qui n'existe pas dans Swift, mais qui existe dans Haskell / Scala. Son ajout n'est pas un changement de langue insignifiant et peut être controversé. L'existence / la dénomination de ++ sera discutée lors d'une phase ultérieure de conception de l'API.

    Déclaration

    @differentiable
    public static func ++ (lhs: Tensor, rhs: Tensor) -> Tensor
  • Renvoie un tenseur en rassemblant des tranches de l'entrée aux indices long de la dimension de l' axis

    Pour les 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 les indices 1-D (vectoriels):

    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}]
    

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

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

    Remarque

    Sur le processeur, si un index hors limites est trouvé, une erreur est générée. Sur GPU, si un index hors plage est trouvé, un 0 est stocké dans les valeurs de sortie correspondantes.

    Condition préalable

    axis doit être dans la plage [-rank, rank) .

    Déclaration

    @differentiable(wrt: self)
    public func gathering<Index: TensorFlowIndex>(
      atIndices indices: Tensor<Index>,
      alongAxis axis: Int = 0
    ) -> Tensor

    Paramètres

    indices

    Contient les indices sur lesquels se rassembler.

    axis

    Dimension le long de laquelle se rassembler. Les valeurs négatives s'enroulent.

    Valeur de retour

    Le tenseur rassemblé.

  • Renvoie des tranches de ce tenseur aux indices long de la dimension de l' 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 à celle de la gathering , sauf que la forme tenseur résultante est maintenant shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] .

    Condition préalable

    axis doit être dans la plage -rank..<rank , tout en étant également supérieur ou égal à batchDimensionCount .

    Condition préalable

    batchDimensionCount doit être inférieur à indices.rank .

    Déclaration

    @differentiable(wrt: self)
    public func batchGathering<Index: TensorFlowIndex>(
      atIndices indices: Tensor<Index>,
      alongAxis axis: Int = 1,
      batchDimensionCount: Int = 1
    ) -> Tensor

    Paramètres

    indices

    Contient les indices à rassembler.

    axis

    Dimension le long de laquelle se rassembler. Les valeurs négatives s'enroulent.

    batchDimensionCount

    Nombre de dimensions de lot principales à ignorer.

    Valeur de retour

    Le tenseur rassemblé.

  • 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 des lignes principales).

    L' axis peut être utilisé avec un mask pour indiquer l'axe à partir duquel le masque doit être masqué. Dans ce cas, axis + mask.rank <= tensor.rank et la 's shape must match the first du mask 's shape must match the first dimensions of the 's shape must match the first axe + mask.rank dimensions of the forme du tenseur.

    Condition préalable

    Le mask ne peut pas être un scalaire: mask.rank != 0 .

    Déclaration

    @differentiable(wrt: self)
    public func gathering(where mask: Tensor<Bool>, alongAxis axis: Int = 0) -> Tensor

    Paramètres

    mask

    KD tenseur booléen, où K <= self.rank .

    axis

    Tenseur entier 0-D représentant l'axe en self à masquer, où K + axis <= self.rank .

    Valeur de retour

    (self.rank - K + 1) dimensionnel peuplé d'entrées dans ce tenseur correspondant à true valeurs true dans le mask .

  • 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 seconde 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 y a dans ce tenseur. Les indices sont sortis 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]]
    

    Déclaration

    public func nonZeroIndices() -> Tensor<Int64>

    Valeur de retour

    Un tenseur de forme (num_true, rank(condition)) .

  • Déclaration

    @differentiable(wrt: self)
    public func broadcasted(toShape shape: Tensor<Int32>) -> Tensor
  • Déclaration

    @differentiable(wrt: self)
    public func broadcasted(to shape: TensorShape) -> Tensor
  • Diffusez à la même forme que le Tensor spécifié.

    Condition préalable

    La forme spécifiée doit être compatible pour la diffusion.

    Déclaration

    @differentiable(wrt: self)
    public func broadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar
  • Déclaration

    public static func .= (lhs: inout Tensor, rhs: Tensor)
  • Extrait une tranche du tenseur défini par les limites inférieure et supérieure pour chaque dimension.

    Déclaration

    @differentiable(wrt: self)
    public func slice(lowerBounds: [Int], upperBounds: [Int]) -> Tensor

    Paramètres

    lowerBounds

    Les limites inférieures à chaque dimension.

    upperBounds

    Les limites supérieures à chaque dimension.

  • Déclaration

    @differentiable(wrt: self)
    public func slice(lowerBounds: Tensor<Int32>, sizes: Tensor<Int32>) -> Tensor
  • Déclaration

    @differentiable(wrt: self)
    public func slice(lowerBounds: [Int], sizes: [Int]) -> Tensor
  • Déclaration

    @differentiable(wrt: self)
    public subscript(ranges: TensorRangeExpression...) -> Tensor { get set }
  • 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.

    Déclaration

    func ensureValid(
      axes: Tensor<Int32>,
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • 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.

    Déclaration

    func ensureValid(
      axes: [Int],
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • Vérifie que k désigne un axe de self et arrête le programme avec un diagnostic dans le cas contraire.

    Déclaration

    func ensureValid(
      axis k: Int,
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • Déclaration

    public init<BatchSamples: Collection>(collating samples: BatchSamples)
    where BatchSamples.Element == Self
  • Crée une copie de l' other sur le Device donné.

    Déclaration

    public init(copying other: Tensor, to device: Device)
  • Crée un tenseur avec la forme spécifiée et une seule valeur scalaire répétée.

    Déclaration

    @available(*, deprecated, renamed: "init(repeating:shape:﹚")
    public init(shape: TensorShape, repeating repeatedValue: Scalar)

    Paramètres

    shape

    Les dimensions du tenseur.

    repeatedValue

    La valeur scalaire à répéter.

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

    Déclaration

    @differentiable
    public init(
      repeating repeatedValue: Scalar, shape: TensorShape,
      on device: Device = .default
    )

    Paramètres

    repeatedValue

    La valeur scalaire à répéter.

    shape

    Les dimensions du tenseur.

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

    Déclaration

    public init(broadcasting scalar: Scalar, rank: Int, on device: Device = .default)
  • Crée un tenseur à partir d'un tableau de tenseurs (qui peuvent eux-mêmes être des scalaires).

    Déclaration

    @differentiable
    public init(_ elements: [Tensor])
  • Empile les tensors , le long de la dimension de l' axis , dans un nouveau tenseur avec un rang supérieur au tenseur actuel et chaque tenseur en tensors .

    Étant donné que les 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 l'opposé de Tensor.unstacked(alongAxis:) .

    Condition préalable

    Tous les tenseurs doivent avoir la même forme.

    Condition préalable

    axis doit être dans la plage [-rank, rank) , où rank est le rang des tenseurs fournis.

    Déclaration

    @differentiable
    public init(stacking tensors: [Tensor], alongAxis axis: Int = 0)

    Paramètres

    tensors

    Des tenseurs à empiler.

    axis

    Dimension le long de laquelle empiler. Les valeurs négatives s'enroulent.

    Valeur de retour

    Le tenseur empilé.

  • Concatène les tensors long de la cote de l' axis .

    Sachant que les 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 de l' 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]
    

    Remarque

    Si vous concaténez le long d'un nouvel axe, envisagez d'utiliser Tensor.init(stacking:alongAxis:) .

    Condition préalable

    Tous les tenseurs doivent avoir le même rang et toutes les dimensions sauf l' axis doivent être égales.

    Condition préalable

    axis doit être dans la plage [-rank, rank) , où rank est le rang des tenseurs fournis.

    Déclaration

    @differentiable
    public init(concatenating tensors: [Tensor], alongAxis axis: Int = 0)

    Paramètres

    tensors

    Tensors à concaténer.

    axis

    Dimension le long de laquelle concaténer. Les valeurs négatives s'enroulent.

    Valeur de retour

    Le tenseur concaténé.

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

    Condition préalable

    self et les other doivent avoir la même forme. Si self et les other sont scalaires, le mask doit également être scalaire. Si self et other ont un rang supérieur ou égal à 1 , alors le mask doit avoir la même forme que self ou être un Tensor 1-D tel que mask.scalarCount == self.shape[0] .

    Déclaration

    @differentiable(wrt: (self, other)
    ) public func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor
  • Renvoie true si le type scalaire physique est de précision réduite.

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

    Déclaration

    public var isReducedPrecision: Bool { get }
  • Transforme un scalaire en tenseur avec le même dispositif et la même précision que le tenseur donné.

    Déclaration

    @differentiable
    public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)
  • Renvoie une copie de self converti en type scalaire physique BFloat16 .

    Déclaration

    public var toReducedPrecision: `Self` { get }
  • Renvoie une copie de l' self converti en Scalar type scalaire physique.

    Déclaration

    public var toFullPrecision: `Self` { get }
  • Le nombre de dimensions du Tensor .

    Déclaration

    public var rank: Int { get }
  • La forme du Tensor .

    Déclaration

    public var shape: TensorShape { get }
  • Le nombre de scalaires dans le Tensor .

  • Déclaration

    public var scalarCount: Int { get }
  • Le rang du tenseur, représenté par un Tensor<Int32> .

    Déclaration

    public var rankTensor: Tensor<Int32> { get }
  • Les dimensions du tenseur, représentées par un Tensor<Int32> .

    Déclaration

    public var shapeTensor: Tensor<Int32> { get }
  • Le nombre de scalaires dans le tenseur, représenté par un Tensor<Int32> .

    Déclaration

    public var scalarCountTensor: Tensor<Int32> { get }
  • Renvoie true si le rank est égal à 0 et false cas contraire.

    Déclaration

    public var isScalar: Bool { get }
  • Renvoie l'élément scalaire unique si le rank est égal à 0 et nil cas contraire.

    Déclaration

    public var scalar: Scalar? { get }
  • Remodeler en scalaire.

    Condition préalable

    Le tenseur a exactement un scalaire.

    Déclaration

    @differentiable
    public func scalarized() -> Scalar
  • Déclaration

    public var array: ShapedArray<Scalar> { get }
  • Déclaration

    @differentiable
    public var scalars: [Scalar] { get }
  • Crée un tenseur 0-D à partir d'une valeur scalaire.

    Déclaration

    @differentiable
    public init(_ value: Scalar, on device: Device = .default)
  • Crée un tenseur 1D à partir de scalaires.

    Déclaration

    @differentiable
    public init(_ scalars: [Scalar], on device: Device = .default)
  • Crée un tenseur 1D à partir de scalaires.

    Déclaration

    public init<C: Collection>(
      _ vector: C, on device: Device = .default
    ) where C.Element == Scalar
  • Crée un tenseur avec la forme spécifiée et des scalaires contigus dans l'ordre des lignes principales.

    Condition préalable

    Le produit des dimensions de la forme doit être égal au nombre de scalaires.

    Déclaration

    @differentiable
    public init(shape: TensorShape, scalars: [Scalar], on device: Device = .default)

    Paramètres

    shape

    La forme du tenseur.

    scalars

    Le contenu scalaire du tenseur.

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

    Condition préalable

    Le produit des dimensions de la forme doit être égal au nombre de scalaires.

    Déclaration

    public init(
      shape: TensorShape,
      scalars: UnsafeBufferPointer<Scalar>,
      on device: Device = .default
    )

    Paramètres

    shape

    La forme du tenseur.

    scalars

    Le contenu scalaire du tenseur.

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

    Condition préalable

    Le produit des dimensions de la forme doit être égal au nombre de scalaires.
  • Crée un tenseur avec la forme spécifiée et des scalaires contigus dans l'ordre des lignes principales.

    Condition préalable

    Le produit des dimensions de la forme doit être égal au nombre de scalaires.

    Déclaration

    public init<C: Collection>(
      shape: TensorShape, scalars: C, on device: Device = .default
    ) where C.Element == Scalar

    Paramètres

    shape

    La forme du tenseur.

    scalars

    Le contenu scalaire du tenseur.

  • Le type des éléments d'un littéral de tableau.

    Déclaration

    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
  • Crée un tenseur initialisé avec les éléments donnés.

    Déclaration

    public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)
  • Une représentation textuelle du tenseur.

    Remarque

    utilisez fullDescription pour une description peu imprimée montrant tous les scalaires.

    Déclaration

    public var description: String { get }
  • Une représentation textuelle du tenseur. Renvoie une description résumée si la valeur summarize est true et que le nombre d'éléments dépasse le double de edgeElementCount .

    Déclaration

    public func description(
      lineWidth: Int = 80,
      edgeElementCount: Int = 3,
      summarizing: Bool = false
    ) -> String

    Paramètres

    lineWidth

    La largeur de ligne maximale pour l'impression. Utilisé pour déterminer le nombre de scalaires à imprimer par ligne.

    edgeElementCount

    Le nombre maximum d'éléments à imprimer avant et après la synthèse via des ellipses ( ... ).

    summarizing

    Si vrai, résumez la description si le nombre d'éléments dépasse deux fois edgeElementCount .

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

    Déclaration

    public var fullDescription: String { get }
  • Déclaration

    public var playgroundDescription: Any { get }
  • Déclaration

    public var customMirror: Mirror { get }
  • Les annotations décrivant ce tenseur.

    Déclaration

    public var annotations: String { get }
  • Un alias pour les annotations.

    Déclaration

    public var summary: String { get }
  • Déclaration

    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?)
  • Déclaration

    public init<C: RandomAccessCollection>(
      _handles: C
    ) where C.Element: _AnyTensorHandle
  • Déclaration

    public init(_ array: ShapedArray<Scalar>, on device: Device = .default)
  • Déclaration

    init(_xla: XLATensor)
  • Déclaration

    init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)
  • Déclaration

    var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }
  • Déclaration

    var xlaTensor: XLATensor { get }

Disponible là où `Scalar`:` Numeric`

  • Déclaration

    @differentiable(wrt: self)
    public func unbroadcasted(toShape otherShape: Tensor<Int32>) -> Tensor
  • Déclaration

    @differentiable(wrt: self)
    public func unbroadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar
  • Déclaration

    @differentiable(wrt: self)
    public func unbroadcasted(to shape: TensorShape) -> Tensor
  • Un mode qui dicte comment un tenseur est rembourré.

    Déclaration

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

    Déclaration

    @differentiable(wrt: self)
    public func padded(forSizes sizes: [(before: Int, after: Int)], with value: Scalar = 0)
      -> Tensor
  • Renvoie un tenseur complété en fonction des tailles et du mode de remplissage spécifiés.

    Déclaration

    @differentiable(wrt: self)
    public func padded(forSizes sizes: [(before: Int, after: Int)], mode: PaddingMode) -> Tensor

Disponible là où `Scalar`:` Numeric` & `Comparable`

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

    Déclaration

    public static func .< (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs <= rhs élément par élément.

    Déclaration

    public static func .<= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs > rhs élément par élément.

    Déclaration

    public static func .> (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs >= rhs élément par élément.

    Déclaration

    public static func .>= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs < rhs élément par élément.

    Remarque

    .< prend en charge la diffusion.

    Déclaration

    public static func .< (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs <= rhs élément par élément.

    Remarque

    .<= prend en charge la diffusion.

    Déclaration

    public static func .<= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs > rhs élément par élément.

    Remarque

    .> prend en charge la diffusion.

    Déclaration

    public static func .> (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs >= rhs élément par élément.

    Remarque

    .>= prend en charge la diffusion.

    Déclaration

    public static func .>= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs < rhs élément par élément.

    Remarque

    .< prend en charge la diffusion.

    Déclaration

    public static func .< (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs <= rhs élément par élément.

    Remarque

    .<= prend en charge la diffusion.

    Déclaration

    public static func .<= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs > rhs élément par élément.

    Remarque

    .> prend en charge la diffusion.

    Déclaration

    public static func .> (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs >= rhs élément par élément.

    Remarque

    .>= prend en charge la diffusion.

    Déclaration

    public static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>

Disponible là où `Scalar`:` Equatable`

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

    Remarque

    .== prend en charge la diffusion.

    Déclaration

    public static func .== (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs != rhs élément par élément.

    Remarque

    .!= prend en charge la diffusion.

    Déclaration

    public static func .!= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs == rhs élément par élément.

    Remarque

    .== prend en charge la diffusion.

    Déclaration

    public static func .== (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs != rhs élément par élément.

    Remarque

    .!= prend en charge la diffusion.

    Déclaration

    public static func .!= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs == rhs élément par élément.

    Remarque

    .== prend en charge la diffusion.

    Déclaration

    public static func .== (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • Renvoie un tenseur de scalaires booléens en calculant lhs != rhs élément par élément.

    Remarque

    .!= prend en charge la diffusion.

    Déclaration

    public static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>

Disponible là où `Scalar`:` TensorFlowFloatingPoint` & `Equatable`

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

    Condition préalable

    self et les other doivent avoir la même forme.

    Déclaration

    public func elementsAlmostEqual(
      _ other: Tensor,
      tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
    ) -> Tensor<Bool>

Disponible là où `Scalar`:` TensorFlowFloatingPoint`

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

    Condition préalable

    self et les other doivent avoir la même forme.

    Déclaration

    public func isAlmostEqual(
      to other: Tensor,
      tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
    ) -> Bool

Disponible là où `Scalar`:` TensorFlowNumeric`

  • 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.

    Déclaration

    public mutating mutating func crossReplicaSum(_ scale: Double)

Disponible là où `Scalar`:` TensorFlowFloatingPoint`

Disponible là où `Scalar`:` Numeric`

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

    Déclaration

    public init(_ other: Tensor<Bool>)
  • Effectuez une conversion élément par élément à partir d'un autre Tensor .

    Déclaration

    @differentiable
    public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar

Disponible là où `Scalar`:` TensorFlowFloatingPoint`

Disponible où `Scalar`:` Numeric`

  • Crée un tenseur avec tous les scalaires mis à zéro.

    Déclaration

    public init(zeros shape: TensorShape, on device: Device = .default)

    Paramètres

    shape

    Forme du tenseur.

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

    Déclaration

    public init(ones shape: TensorShape, on device: Device = .default)

    Paramètres

    shape

    Forme du tenseur.

  • 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.

    Déclaration

    public init(zerosLike other: Tensor)

    Paramètres

    other

    Tensor dont la forme et le type de données à utiliser.

  • 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.

    Déclaration

    public init(onesLike other: Tensor)

    Paramètres

    other

    Tensor dont la forme et le type de données à utiliser.

  • Crée un tenseur 1D représentant une séquence à partir d'une valeur de départ jusqu'à, mais sans inclure, une valeur de fin, en progressant de la quantité spécifiée.

    Déclaration

    public init(
      rangeFrom start: Scalar, to end: Scalar, stride: Scalar,
      on device: Device = .default
    )

    Paramètres

    start

    La valeur de départ à utiliser pour la séquence. Si la séquence contient des valeurs, la première est start .

    end

    Une valeur finale pour limiter la séquence. end n'est jamais un élément de la séquence résultante.

    stride

    Le montant à parcourir à chaque itération. stride doit être positive.

  • Crée un tenseur 1-D représentant une séquence d'une valeur de départ à, mais sans inclure, une valeur de fin, en progressant de la quantité spécifiée.

    Déclaration

    public init(rangeFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, stride: Tensor<Scalar>)

    Paramètres

    start

    La valeur de départ à utiliser pour la séquence. Si la séquence contient des valeurs, la première est start .

    end

    Une valeur finale pour limiter la séquence. end n'est jamais un élément de la séquence résultante.

    stride

    Le montant à parcourir à chaque itération. stride doit être positive.

  • Crée un tenseur one-hot à des indices donnés. Les emplacements représentés par des 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 entrée sont de rang n , le nouveau tenseur aura le rang n+1 . Le nouvel axe est créé sur l' axis cote (par défaut, le nouvel axe est ajouté à la fin).

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

    Si les indices sont un vecteur d' features de longueur, la forme en sortie sera: entités x profondeur, si axe == -1 profondeur x entités, si axe == 0

    Si les indices est une matrice (lot) avec une forme [batch, features] , la forme en 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

    Déclaration

    public init(
      oneHotAtIndices indices: Tensor<Int32>,
      depth: Int,
      onValue: Scalar = 1,
      offValue: Scalar = 0,
      axis: Int = -1
    )

    Paramètres

    indices

    Un Tensor d'indices.

    depth

    Un scalaire définissant la profondeur de la seule dimension chaude.

    onValue

    Un scalaire définissant la valeur à l'emplacement référencé par un index dans les indices .

    offValue

    Un scalaire définissant la valeur à un emplacement qui ne sont pas mentionnés par un indice en indices .

    axis

    L'axe à remplir. La valeur par défaut est -1 , un nouvel axe le plus à l'intérieur.

Disponible là où `Scalar`:` TensorFlowFloatingPoint`

  • 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 régulièrement pour générer le nombre de valeurs spécifié.

    Déclaration

    public init(
      linearSpaceFrom start: Scalar, to end: Scalar, count: Int, on device: Device = .default
    )

    Paramètres

    start

    La valeur de départ à utiliser pour la séquence. Si la séquence contient des valeurs, la première est start .

    end

    Une valeur finale pour limiter la séquence. end est le dernier élément de la séquence résultante.

    count

    Le nombre de valeurs dans la séquence résultante. count doit être positif.

  • 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 régulièrement pour générer le nombre de valeurs spécifié.

    Condition préalable

    start , to et count doivent être des Tensors contenant une seule valeur scalaire.

    Déclaration

    public init(linearSpaceFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, count: Tensor<Int32>)

    Paramètres

    start

    La valeur de départ à utiliser pour la séquence. Si la séquence contient des valeurs, la première est start .

    end

    Une valeur finale pour limiter la séquence. end est le dernier élément de la séquence résultante.

    count

    Le nombre de valeurs dans la séquence résultante. count doit être positif.

Disponible là où `Scalar`:` TensorFlowIndex`

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

    Déclaration

    public init(
      randomUniform shape: TensorShape,
      lowerBound: Tensor<Scalar>? = nil,
      upperBound: Tensor<Scalar>? = nil,
      seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Paramètres

    shape

    Les dimensions du tenseur.

    lowerBound

    La limite inférieure de la distribution.

    upperBound

    La limite supérieure de la distribution.

    seed

    La valeur de départ.

Disponible là où `Scalar`:` TensorFlowFloatingPoint`

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

    Déclaration

    public init(
      randomUniform shape: TensorShape,
      lowerBound: Tensor<Scalar>? = nil,
      upperBound: Tensor<Scalar>? = nil,
      seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Paramètres

    shape

    Les dimensions du tenseur.

    lowerBound

    La limite inférieure de la distribution.

    upperBound

    La limite supérieure de la distribution.

    seed

    La valeur de départ.

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

    Déclaration

    public init(
      randomNormal shape: TensorShape,
      mean: Tensor<Scalar>? = nil,
      standardDeviation: Tensor<Scalar>? = nil,
      seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Paramètres

    shape

    Les dimensions du tenseur.

    mean

    La moyenne de la distribution.

    standardDeviation

    L'écart type de la distribution.

    seed

    La valeur de départ.

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

    Déclaration

    public init(
      randomTruncatedNormal shape: TensorShape,
      mean: Tensor<Scalar>? = nil,
      standardDeviation: Tensor<Scalar>? = nil,
      seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Paramètres

    shape

    Les dimensions du tenseur.

    mean

    La moyenne de la distribution.

    standardDeviation

    L'écart type de la distribution.

    seed

    La valeur de départ.

Disponible là où `Scalar`:` TensorFlowIndex`

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

    Déclaration

    public init<T: TensorFlowFloatingPoint>(
      randomCategorialLogits: Tensor<T>,
      sampleCount: Int32,
      seed: TensorFlowSeed = Context.local.randomSeed
    )

    Paramètres

    randomCategorialLogits

    Tenseur 2-D avec forme [batchSize, classCount] . Chaque tranche [i, :] ,: [i, :] représente les probabilités log non normalisées pour toutes les classes.

    sampleCount

    0-D. Nombre d'échantillons indépendants à dessiner pour chaque tranche de ligne.

    seed

    La valeur de départ.

    Valeur de retour

    Tenseur 2-D avec forme [batchSize, sampleCount] . Chaque tranche [i, :] [0, classCount) [i, :] contient les étiquettes de classe dessinées avec range [0, classCount) .

Disponible là où `Scalar`:` TensorFlowFloatingPoint`

  • Crée un tenseur avec la forme spécifiée en effectuant une initialisation uniforme de 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 par défaut du nombre aléatoire, où la limit est sqrt(6 / (fanIn + fanOut)) et fanIn / fanOut représentent le nombre d'entrée et de sortie fonctionnalités multiplié par le réceptif taille du champ.

    Référence: "Comprendre la difficulté de former des réseaux de neurones à feedforward profond"

    Déclaration

    public init(
      glorotUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Paramètres

    shape

    Les dimensions du tenseur.

    seed

    La valeur de départ.

  • Crée un tenseur avec la forme spécifiée en effectuant l'initialisation normale de Glorot (Xavier).

    Il tire des échantillons aléatoires à partir 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 par défaut du nombre aléatoire, où fanIn / fanOut représentent le nombre d'entrée et de sortie dispose multipliée par le champ récepteur Taille.

    Référence: "Comprendre la difficulté de former des réseaux de neurones à feedforward profond"

    Déclaration

    public init(
      glorotNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Paramètres

    shape

    Les dimensions du tenseur.

    seed

    La valeur de départ.

  • 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 profondément dans les redresseurs: dépasser les performances au niveau humain sur la classification ImageNet"

    Déclaration

    public init(
      heUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Paramètres

    shape

    Les dimensions du tenseur.

    seed

    La valeur de départ.

  • 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 profondément dans les redresseurs: dépasser les performances au niveau humain sur la classification ImageNet"

    Déclaration

    public init(
      heNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Paramètres

    shape

    Les dimensions du tenseur.

    seed

    La valeur de départ.

  • 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"

    Déclaration

    public init(
      leCunUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Paramètres

    shape

    Les dimensions du tenseur.

    seed

    La valeur de départ.

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

    It draws random samples from a truncated normal distribution centered on 0 with standard deviation sqrt(1 / fanIn) generated by the default random number generator, where fanIn represents the number of input features multiplied by the receptive field size.

    Reference: “Efficient BackProp”

    Declaration

    public init(
      leCunNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Parameters

    shape

    The dimensions of the tensor.

    seed

    The seed value.

  • Creates an orthogonal matrix or tensor.

    If the shape of the tensor to initialize is two-dimensional, it is initialized with an orthogonal matrix obtained from the QR decomposition of a matrix of random numbers drawn from a normal distribution. If the matrix has fewer rows than columns then the output will have orthogonal rows. Otherwise, the output will have orthogonal columns.

    If the shape of the tensor to initialize is more than two-dimensional, a matrix of shape [shape[0] * ... * shape[rank - 2], shape[rank - 1]] is initialized. The matrix is subsequently reshaped to give a tensor of the desired shape.

    Declaration

    public init(
      orthogonal shape: TensorShape,
      gain: Tensor<Scalar> = Tensor<Scalar>(1),
      seed: TensorFlowSeed = Context.local.randomSeed
    )

    Parameters

    shape

    The shape of the tensor.

    gain

    A multiplicative factor to apply to the orthogonal tensor.

    seed

    A tuple of two integers to seed the random number generator.

Available where `Scalar`: `TensorFlowNumeric`

  • Returns the [batched] diagonal part of a [batched] tensor. For the tensor instance of the shape [..., M, N] , the output is a tensor of the shape [..., K] , where K equals min(N, M) .

    For example:

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

    Declaration

    @differentiable
    public func diagonalPart() -> Tensor
  • Constructs a [batched] diagonal array. For the tensor instance of the shape [..., M] , the output is a tensor of the shape [..., M, M] .

    For example:

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

    Declaration

    @differentiable
    public func diagonal() -> Tensor
  • Returns self with new diagonal values, given that self is an optionally batched matrix.

    The returned tensor has the same shape and values as self , except for the specified diagonals of the innermost matrices which are overwritten by the values in diagonal .

    Parameter diagonal: A tensor with rank rank - 1 representing the new diagonal values.

    Declaration

    public func withDiagonal(_ diagonal: Tensor<Scalar>) -> Tensor
  • Declaration

    @differentiable(wrt: self)
    public func bandPart(_ subdiagonalCount: Int, _ superdiagonalCount: Int) -> Tensor
  • Returns a copy of a innermost tensor defined by a central band boundaries. The output is a tensor of the same shape as the instance [..., :, :] .

    For example:

    // '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]]
    

    Declaration

    @differentiable
    public func bandPart(subdiagonalCount: Int, superdiagonalCount: Int) -> Tensor

    Parameters

    subdiagonalCount

    The number of subdiagonals to keep. If negative, keep entire lower triangle.

    superdiagonalCount

    The number of superdiagonals to keep. If negative, keep entire upper triangle.

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Returns the QR decomposition of each inner matrix in the tensor, a tensor with inner orthogonal matrices q and a tensor with inner upper triangular matrices r , such that the tensor is equal to matmul(q, r) .

    Declaration

    public func qrDecomposition(fullMatrices: Bool = false) -> (
      q: Tensor<Scalar>, r: Tensor<Scalar>
    )

    Parameters

    fullMatrices

    If true , compute full-sized q and r . Otherwise compute only the leading min(shape[rank - 1], shape[rank - 2]) columns of q .

  • Returns the singular value decomposition of self , given that self is an optionally batched matrix.

    The singular value decomposition (SVD) of the optionally batched matrix self is values s , u , and v , such that:

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

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

    Precondition

    self must be a tensor with shape [..., M, N] .

    Declaration

    public func svd(computeUV: Bool = true, fullMatrices: Bool = false) -> (
      s: Tensor<Scalar>, u: Tensor<Scalar>?, v: Tensor<Scalar>?
    )

    Parameters

    computeUV

    If true , the left and right singular vectors are computed and returned as u and v , respectively. If false , nil values are returned as u and v .

    fullMatrices

    If true , u and v respectively have shapes [..., M, M] and [..., N, N] . If false , u and v respectively have shapes [..., M, K] and [..., K, N] . Ignored when computeUV is false.

    Return Value

    • s: The singular values, with shape [..., K] . Within each vector, the singular values are sorted in descending order.
    • u: The left singular vectors.
    • v: The right singular vectors.
  • The square root of x .

    For real types, if x is negative the result is .nan . For complex types there is a branch cut on the negative real axis.

    Declaration

    @differentiable
    public static func sqrt(_ x: `Self`) -> Tensor<Scalar>
  • The cosine of x , interpreted as an angle in radians.

    Declaration

    @differentiable
    public static func cos(_ x: `Self`) -> Tensor<Scalar>
  • The sine of x , interpreted as an angle in radians.

    Declaration

    @differentiable
    public static func sin(_ x: `Self`) -> Tensor<Scalar>
  • The tangent of x , interpreted as an angle in radians.

    Declaration

    @differentiable
    public static func tan(_ x: `Self`) -> Tensor<Scalar>
  • The inverse cosine of x in radians.

    Declaration

    @differentiable
    public static func acos(_ x: `Self`) -> Tensor<Scalar>
  • The inverse sine of x in radians.

    Declaration

    @differentiable
    public static func asin(_ x: `Self`) -> Tensor<Scalar>
  • The inverse tangent of x in radians.

    Declaration

    @differentiable
    public static func atan(_ x: `Self`) -> Tensor<Scalar>
  • The hyperbolic cosine of x .

    Declaration

    @differentiable
    public static func cosh(_ x: `Self`) -> Tensor<Scalar>
  • The hyperbolic sine of x .

    Declaration

    @differentiable
    public static func sinh(_ x: `Self`) -> Tensor<Scalar>
  • The hyperbolic tangent of x .

    Declaration

    @differentiable
    public static func tanh(_ x: `Self`) -> Tensor<Scalar>
  • The inverse hyperbolic cosine of x .

    Declaration

    @differentiable
    public static func acosh(_ x: `Self`) -> Tensor<Scalar>
  • The inverse hyperbolic sine of x .

    Declaration

    @differentiable
    public static func asinh(_ x: `Self`) -> Tensor<Scalar>
  • The inverse hyperbolic tangent of x .

    Declaration

    @differentiable
    public static func atanh(_ x: `Self`) -> Tensor<Scalar>
  • The exponential function applied to x , or e**x .

    Declaration

    @differentiable
    public static func exp(_ x: `Self`) -> Tensor<Scalar>
  • Two raised to to power x .

    Declaration

    @differentiable
    public static func exp2(_ x: `Self`) -> Tensor<Scalar>
  • Ten raised to to power x .

    Declaration

    @differentiable
    public static func exp10(_ x: `Self`) -> Tensor<Scalar>
  • exp(x) - 1 evaluated so as to preserve accuracy close to zero.

    Declaration

    @differentiable
    public static func expm1(_ x: `Self`) -> Tensor<Scalar>
  • The natural logarithm of x .

    Declaration

    @differentiable
    public static func log(_ x: `Self`) -> Tensor<Scalar>
  • The base-two logarithm of x .

    Declaration

    @differentiable
    public static func log2(_ x: `Self`) -> Tensor<Scalar>
  • The base-ten logarithm of x .

    Declaration

    @differentiable
    public static func log10(_ x: `Self`) -> Tensor<Scalar>
  • log(1 + x) evaluated so as to preserve accuracy close to zero.

    Declaration

    @differentiable
    public static func log1p(_ x: `Self`) -> Tensor<Scalar>
  • exp(y log(x)) computed without loss of intermediate precision.

    For real types, if x is negative the result is NaN, even if y has an integral value. For complex types, there is a branch cut on the negative real axis.

    Declaration

    @differentiable
    public static func pow(_ x: `Self`, _ y: `Self`) -> Tensor<Scalar>
  • x raised to the n th power.

    The product of n copies of x .

    Declaration

    @differentiable
    public static func pow(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
  • The n th root of x .

    For real types, if x is negative and n is even, the result is NaN. For complex types, there is a branch cut along the negative real axis.

    Declaration

    @differentiable
    public static func root(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
  • Declaration

    public typealias VectorSpaceScalar = Float
  • Declaration

    public func scaled(by scale: Float) -> Tensor<Scalar>
  • Declaration

    public func adding(_ scalar: Float) -> Tensor<Scalar>
  • Declaration

    public func subtracting(_ scalar: Float) -> Tensor<Scalar>

Available where `Scalar`: `Numeric`

  • Adds the scalar to every scalar of the tensor and produces the sum.

    Declaration

    @differentiable
    public static func + (lhs: Scalar, rhs: Tensor) -> Tensor
  • Adds the scalar to every scalar of the tensor and produces the sum.

    Declaration

    @differentiable
    public static func + (lhs: Tensor, rhs: Scalar) -> Tensor
  • Subtracts the scalar from every scalar of the tensor and produces the difference.

    Declaration

    @differentiable
    public static func - (lhs: Scalar, rhs: Tensor) -> Tensor
  • Subtracts the scalar from every scalar of the tensor and produces the difference

    Declaration

    @differentiable
    public static func - (lhs: Tensor, rhs: Scalar) -> Tensor
  • Adds two tensors and stores the result in the left-hand-side variable.

    Note

    += supports broadcasting.

    Declaration

    public static func += (lhs: inout Tensor, rhs: Tensor)
  • Adds the scalar to every scalar of the tensor and stores the result in the left-hand-side variable.

    Declaration

    public static func += (lhs: inout Tensor, rhs: Scalar)
  • Subtracts the second tensor from the first and stores the result in the left-hand-side variable.

    Note

    -= supports broadcasting.

    Declaration

    public static func -= (lhs: inout Tensor, rhs: Tensor)
  • Subtracts the scalar from every scalar of the tensor and stores the result in the left-hand-side variable.

    Declaration

    public static func -= (lhs: inout Tensor, rhs: Scalar)
  • Returns the tensor produced by multiplying the two tensors.

    Note

    * supports broadcasting.

    Declaration

    @differentiable
    public static func * (lhs: Tensor, rhs: Tensor) -> Tensor
  • Returns the tensor by multiplying it with every scalar of the tensor.

    Declaration

    @differentiable
    public static func * (lhs: Scalar, rhs: Tensor) -> Tensor
  • Multiplies the scalar with every scalar of the tensor and produces the product.

    Declaration

    @differentiable
    public static func * (lhs: Tensor, rhs: Scalar) -> Tensor
  • Multiplies two tensors and stores the result in the left-hand-side variable.

    Note

    *= supports broadcasting.

    Declaration

    public static func *= (lhs: inout Tensor, rhs: Tensor)
  • Multiplies the tensor with the scalar, broadcasting the scalar, and stores the result in the left-hand-side variable.

    Declaration

    public static func *= (lhs: inout Tensor, rhs: Scalar)
  • Returns the quotient of dividing the first tensor by the second.

    Note

    / supports broadcasting.

    Declaration

    @differentiable
    public static func / (lhs: Tensor, rhs: Tensor) -> Tensor
  • Returns the quotient of dividing the scalar by the tensor, broadcasting the scalar.

    Declaration

    @differentiable
    public static func / (lhs: Scalar, rhs: Tensor) -> Tensor
  • Returns the quotient of dividing the tensor by the scalar, broadcasting the scalar.

    Declaration

    @differentiable
    public static func / (lhs: Tensor, rhs: Scalar) -> Tensor
  • Divides the first tensor by the second and stores the quotient in the left-hand-side variable.

    Declaration

    public static func /= (lhs: inout Tensor, rhs: Tensor)
  • Divides the tensor by the scalar, broadcasting the scalar, and stores the quotient in the left-hand-side variable.

    Declaration

    public static func /= (lhs: inout Tensor, rhs: Scalar)
  • Returns the remainder of dividing the first tensor by the second.

    Note

    % supports broadcasting.

    Declaration

    public static func % (lhs: Tensor, rhs: Tensor) -> Tensor
  • Returns the remainder of dividing the tensor by the scalar, broadcasting the scalar.

    Declaration

    public static func % (lhs: Tensor, rhs: Scalar) -> Tensor
  • Returns the remainder of dividing the scalar by the tensor, broadcasting the scalar.

    Declaration

    public static func % (lhs: Scalar, rhs: Tensor) -> Tensor
  • Divides the first tensor by the second and stores the remainder in the left-hand-side variable.

    Declaration

    public static func %= (lhs: inout Tensor, rhs: Tensor)
  • Divides the tensor by the scalar and stores the remainder in the left-hand-side variable.

    Declaration

    public static func %= (lhs: inout Tensor, rhs: Scalar)

Available where `Scalar` == `Bool`

  • Returns !self element-wise.

    Declaration

    public func elementsLogicalNot() -> Tensor
  • Returns self && other element-wise.

    Note

    && supports broadcasting.

    Declaration

    public func elementsLogicalAnd(_ other: Tensor) -> Tensor
  • Returns self && other element-wise, broadcasting other .

    Declaration

    public func elementsLogicalAnd(_ other: Scalar) -> Tensor
  • Returns self || other element-wise.

    Declaration

    public func elementsLogicalOr(_ other: Tensor) -> Tensor
  • Returns self || other element-wise, broadcasting other .

    Declaration

    public func elementsLogicalOr(_ other: Scalar) -> Tensor

Available where `Scalar`: `TensorFlowNumeric`

  • Returns max(min(self, max), min) .

    Declaration

    @differentiable
    public func clipped(min: Tensor, max: Tensor) -> Tensor
  • Returns max(min(self, max), min) .

    Declaration

    @differentiable(wrt: (self, min)
    ) public func clipped(min: Tensor, max: Scalar) -> Tensor
  • Returns max(min(self, max), min) .

    Declaration

    @differentiable(wrt: (self, max)
    ) public func clipped(min: Scalar, max: Tensor) -> Tensor
  • Returns max(min(self, max), min) .

    Declaration

    @differentiable(wrt: self)
    public func clipped(min: Scalar, max: Scalar) -> Tensor

Available where `Scalar`: `SignedNumeric`

  • Returns the negation of the specified tensor element-wise.

    Declaration

    @differentiable
    public prefix static func - (rhs: Tensor) -> Tensor

Available where `Scalar`: `Numeric`

  • Declaration

    @differentiable(wrt: self)
    public func squared() -> Tensor

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Returns a boolean tensor indicating which elements of x are finite.

    Declaration

    public var isFinite: Tensor<Bool> { get }
  • Returns a boolean tensor indicating which elements of x are infinite.

    Declaration

    public var isInfinite: Tensor<Bool> { get }
  • Returns a boolean tensor indicating which elements of x are NaN-valued.

    Declaration

    public var isNaN: Tensor<Bool> { get }

Available where `Scalar` == `Bool`

  • Returns true if all scalars are equal to true . Otherwise, returns false .

    Declaration

    public func all() -> Bool
  • Returns true if any scalars are equal to true . Otherwise, returns false .

    Declaration

    public func any() -> Bool
  • Performs a logical AND operation along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    public func all(squeezingAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Performs a logical AND operation along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    public func any(squeezingAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Performs a logical AND operation along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    public func all(alongAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Performs a logical OR operation along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    public func any(alongAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

Available where `Scalar`: `Numeric` & `Comparable`

  • Declaration

    @differentiable
    public func min() -> Tensor
  • Declaration

    @differentiable
    public func max() -> Tensor
  • Returns the maximum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func max(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the maximum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func max(squeezingAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the maximum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func max(squeezingAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func min(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func min(squeezingAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func min(squeezingAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the indices of the maximum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    public func argmax(squeezingAxis axis: Int) -> Tensor<Int32>

    Parameters

    axes

    The dimensions to reduce.

  • Returns the indices of the minimum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    public func argmin(squeezingAxis axis: Int) -> Tensor<Int32>

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func min(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func min(alongAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func min(alongAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func max(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func max(alongAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func max(alongAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the index of the maximum value of the flattened scalars.

    Declaration

    public func argmax() -> Tensor<Int32>
  • Returns the index of the minimum value of the flattened scalars.

    Declaration

    public func argmin() -> Tensor<Int32>

Available where `Scalar`: `Numeric`

  • Returns the sum along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

    @differentiable(wrt: self)
    public func sum(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the sum along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

    @differentiable(wrt: self)
    public func sum(squeezingAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the sum along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

    @differentiable(wrt: self)
    public func sum(squeezingAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Declaration

    @differentiable(wrt: self)
    public func sum() -> Tensor
  • Returns the sum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func sum(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the sum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func sum(alongAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the sum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func sum(alongAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the product along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

    @differentiable(wrt: self)
    public func product(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the product along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

    @differentiable(wrt: self)
    public func product(squeezingAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the product along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

    @differentiable(wrt: self)
    public func product(squeezingAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Declaration

    @differentiable(wrt: self)
    public func product() -> Tensor
  • Returns the product along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    public func product(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the product along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    public func product(alongAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the product along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    public func product(alongAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

    @differentiable(wrt: self)
    public func mean(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

    @differentiable(wrt: self)
    public func mean(squeezingAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

    @differentiable(wrt: self)
    public func mean(squeezingAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Declaration

    @differentiable(wrt: self)
    public func mean() -> Tensor
  • Returns the arithmetic mean along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func mean(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func mean(alongAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func mean(alongAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the variance along the specified axes. The reduced dimensions are removed. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func variance(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the variance along the specified axes. The reduced dimensions are removed. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func variance(squeezingAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func variance(squeezingAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Declaration

    @differentiable(wrt: self)
    public func variance() -> Tensor
  • Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func variance(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func variance(alongAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func variance(alongAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the cumulative sum of this tensor along the specified axis. By default, this function performs an inclusive cumulative sum which means that the first element of the input is identical to the first element of the output:

    Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])
    

    By setting the exclusive argument to true , an exclusive cumulative sum is performed instead:

    Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])
    

    By setting the reverse argument to true , the cumulative sum is performed in the opposite direction:

    Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) ==
        Tensor<Float>([a + b + c, a + b, a])
    

    This is more efficient than separately reversing the resulting tensor.

    Precondition

    axis must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func cumulativeSum(
      alongAxis axis: Int,
      exclusive: Bool = false,
      reverse: Bool = false
    ) -> Tensor

    Parameters

    axis

    Axis along which to perform the cumulative sum operation.

    exclusive

    Indicates whether to perform an exclusive cumulative sum.

    reverse

    Indicates whether to perform the cumulative sum in reversed order.

    Return Value

    Result of the cumulative sum operation.

  • Returns the cumulative sum of this tensor along the specified axis. By default, this function performs an inclusive cumulative sum which means that the first element of the input is identical to the first element of the output:

    Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])
    

    By setting the exclusive argument to true , an exclusive cumulative sum is performed instead:

    Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])
    

    By setting the reverse argument to true , the cumulative sum is performed in the opposite direction:

    Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) ==
        Tensor<Float>([a + b + c, a + b, a])
    

    This is more efficient than separately reversing the resulting tensor.

    Precondition

    axis.rank must be 0 .

    Precondition

    axis must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func cumulativeSum(
      alongAxis axis: Tensor<Int32>,
      exclusive: Bool = false,
      reverse: Bool = false
    ) -> Tensor

    Parameters

    axis

    Axis along which to perform the cumulative sum operation.

    exclusive

    Indicates whether to perform an exclusive cumulative sum.

    reverse

    Indicates whether to perform the cumulative sum in reversed order.

    Return Value

    Result of the cumulative sum operation.

  • Returns the cumulative product of this tensor along the specified axis. By default, this function performs an inclusive cumulative product which means that the first element of the input is identical to the first element of the output:

    Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])
    

    By setting the exclusive argument to true , an exclusive cumulative product is performed instead:

    Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])
    

    By setting the reverse argument to true , the cumulative product is performed in the opposite direction:

    Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) ==
        Tensor<Float>([a * b * c, a * b, a])
    

    This is more efficient than separately reversing the resulting tensor.

    Precondition

    axis must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func cumulativeProduct(
      alongAxis axis: Int,
      exclusive: Bool = false,
      reverse: Bool = false
    ) -> Tensor

    Parameters

    axis

    Axis along which to perform the cumulative product operation.

    exclusive

    Indicates whether to perform an exclusive cumulative product.

    reverse

    Indicates whether to perform the cumulative product in reversed order.

    Return Value

    Result of the cumulative product operation.

  • Returns the cumulative product of this tensor along the specified axis. By default, this function performs an inclusive cumulative product which means that the first element of the input is identical to the first element of the output:

    Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])
    

    By setting the exclusive argument to true , an exclusive cumulative product is performed instead:

    Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])
    

    By setting the reverse argument to true , the cumulative product is performed in the opposite direction:

    Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) ==
        Tensor<Float>([a * b * c, a * b, a])
    

    This is more efficient than separately reversing the resulting tensor.

    Precondition

    axis must have rank 0 .

    Precondition

    axis must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func cumulativeProduct(
      alongAxis axis: Tensor<Int32>,
      exclusive: Bool = false,
      reverse: Bool = false
    ) -> Tensor

    Parameters

    axis

    Axis along which to perform the cumulative product operation.

    exclusive

    Indicates whether to perform an exclusive cumulative product.

    reverse

    Indicates whether to perform the cumulative product in reversed order.

    Return Value

    Result of the cumulative product operation.

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func standardDeviation(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func standardDeviation(squeezingAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func standardDeviation(squeezingAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the standard deviation of all elements in this tensor. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func standardDeviation() -> Tensor
  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func standardDeviation(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func standardDeviation(alongAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func standardDeviation(alongAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns log(exp(self).sum(squeezingAxes: axes)) . The reduced dimensions are removed.

    This function is more numerically stable than computing log(exp(self).sum(squeezingAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func logSumExp(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns log(exp(self).sum(squeezingAxes: axes)) . The reduced dimensions are removed.

    This function is more numerically stable than computing log(exp(self).sum(squeezingAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func logSumExp(squeezingAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns log(exp(self).sum(squeezingAxes: axes)) . The reduced dimensions are removed.

    This function is more numerically stable than computing log(exp(self).sum(squeezingAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func logSumExp(squeezingAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns log(exp(self).sum()) . The result is a scalar.

    This function is more numerically stable than computing log(exp(self).sum()) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Declaration

    @differentiable(wrt: self)
    public func logSumExp() -> Tensor
  • Returns log(exp(self).sum(alongAxes: axes)) . The reduced dimensions are retained with value 1 .

    This function is more numerically stable than computing log(exp(self).sum(alongAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func logSumExp(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns log(exp(self).sum(alongAxes: axes)) . The reduced dimensions are retained with value 1 .

    This function is more numerically stable than computing log(exp(self).sum(alongAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func logSumExp(alongAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns log(exp(self).sum(alongAxes: axes)) . The reduced dimensions are retained with value 1 .

    This function is more numerically stable than computing log(exp(self).sum(alongAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func logSumExp(alongAxes axes: Int...) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are removed.

    Precondition

    axes must have rank 1 .

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func moments(squeezingAxes axes: Tensor<Int32>) -> Moments<Scalar>

    Parameters

    axes

    The dimensions to reduce.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func moments(squeezingAxes axes: [Int]) -> Moments<Scalar>

    Parameters

    axes

    The dimensions to reduce.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func moments(squeezingAxes axes: Int...) -> Moments<Scalar>

    Parameters

    axes

    The dimensions to reduce.

  • Returns the mean and variance of this tensor's elements.

    Declaration

    @differentiable(wrt: self)
    public func moments() -> Moments<Scalar>
  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are retained with value 1 .

    Precondition

    axes must have rank 1 .

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func moments(alongAxes axes: Tensor<Int32>) -> Moments<Scalar>

    Parameters

    axes

    The dimensions to reduce.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are retained with value 1 .

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func moments(alongAxes axes: [Int]) -> Moments<Scalar>

    Parameters

    axes

    The dimensions to reduce.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are retained with value 1 .

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func moments(alongAxes axes: Int...) -> Moments<Scalar>

    Parameters

    axes

    The dimensions to reduce.

Available where `Scalar`: `Numeric`

  • Performs matrix multiplication between two tensors and produces the result.

    Declaration

    @differentiable
    public static func  (lhs: Tensor, rhs: Tensor) -> Tensor

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Declaration

    static func vjpInitDeviceAndPrecisionLike(
      _ value: Scalar,
      deviceAndPrecisionLike tensor: Tensor
    ) -> (value: Tensor, pullback: (Tensor) -> (Scalar, Tensor))
  • Returns a tensor computed from batch-normalizing the input along the specified axis.

    Specifically, returns (self - mu) / (var + epsilon) * gamma + beta where mu and var are respectively the mean and variance of self along axis .

    Declaration

    @differentiable(wrt: (self, offset, scale)
    public func batchNormalized(
      alongAxis axis: Int,
      offset: Tensor = Tensor(0),
      scale: Tensor = Tensor(1),
      epsilon: Scalar = 0.001
    ) -> Tensor

    Parameters

    axis

    The batch dimension.

    offset

    The offset, also known as beta.

    scale

    The scale, also known as gamma.

    epsilon

    A small value added to the denominator for numerical stability.

  • Concatenates two tensors along last axis.

    Declaration

    @differentiable
    public static func concatenate(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Adds two values and produces their sum.

    Declaration

    @differentiable
    public static func sum(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Averages two values.

    Declaration

    @differentiable
    public static func average(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Multiplies two values.

    Declaration

    @differentiable
    public static func multiply(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Stack two values.

    Declaration

    @differentiable
    public static func stack(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Declaration

    @derivative
    init(shape: scalars)

Available where `Scalar`: `Equatable`

  • Declaration

    public static func == (lhs: Tensor, rhs: Tensor) -> Bool
  • Declaration

    public static func != (lhs: Tensor, rhs: Tensor) -> Bool

Available where `Scalar`: `Codable`

  • Declaration

    public func encode(to encoder: Encoder) throws
  • Declaration

    public init(from decoder: Decoder) throws

Available where `Scalar`: `Numeric`

  • The scalar zero tensor.

  • Declaration

    public static var zero: Tensor { get }
  • Adds two tensors and produces their sum.

    Note

    + supports broadcasting.

    Declaration

    @differentiable
    public static func + (lhs: Tensor, rhs: Tensor) -> Tensor
  • Subtracts one tensor from another and produces their difference.

    Note

    - supports broadcasting.

    Declaration

    @differentiable
    public static func - (lhs: Tensor, rhs: Tensor) -> Tensor
  • one

    The scalar one tensor.

    Declaration

    public static var one: Tensor { get }
  • Returns the element-wise reciprocal of self .

    Declaration

    public var reciprocal: Tensor { get }
  • Multiplies two tensors element-wise and produces their product.

    Note

    .* supports broadcasting.

    Declaration

    public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Declaration

    public typealias TangentVector = Tensor
  • Declaration

    public var zeroTangentVectorInitializer: () -> TangentVector { get }
  • Adds an annotation.

    Note: Only X10 is supported. For other backends, umodified self is returned.

    Declaration

    @differentiable(wrt: self)
    public func annotate(_ annotation: String) -> Tensor<Scalar>

    Parameters

    annotation

    The annotation to be added.

    Return Value

    The annotated tensor.

  • Declaration

    @derivative
    func vjpAnnotate(_ annotation: String) -> (
      value: Tensor<Scalar>, pullback: (Tensor<Scalar>) -> Tensor<Scalar>
    )