Tensor 

@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

Tableau multidimensionnel d'éléments qui est une généralisation de vecteurs et de matrices à des dimensions potentiellement supérieures.

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

  • Le TensorHandle sous-jacent.

    Note

    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 axis , où N est déduit de la forme de ce tenseur. Par exemple, étant donné un tenseur de forme [A, B, C, D] :

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

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

    Condition préalable

    axis doit être compris 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épiler. 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 axis des dimensions en count plus petits. Cela nécessite que count divise uniformément shape[axis] .

    Par exemple: 

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

    Condition préalable

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

    Condition préalable

    axis doit être compris 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 divisions à créer.

    axis

    La dimension selon 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 morceaux sizes.shape[0] . La forme de la i -ème pièce a la même forme que ce tenseur sauf le long de axis des dimensions où la taille est sizes[i] .

    Par exemple: 

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

    Condition préalable

    Les valeurs dans sizes doivent totaliser la taille de axis des dimensions.

    Condition préalable

    axis doit être compris dans la plage [-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 division.

    axis

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

    Valeur de retour

    Tableau contenant les parties tenseurs.

  • Déclaration 

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

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

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

    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 carrelé, construit en carrelant ce tenseur.

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

    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 selon 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 selon le 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

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

    Déclaration 

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

  • Renvoie un Tensor développé en 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é en 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 de 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 les dimensions spécifiées inversées.

    Condition préalable

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

    Condition préalable

    Il ne doit y avoir aucune duplication des axes .

    Déclaration 

    @differentiable(wrt: self)
public func reversed(inAxes axes: Tensor<Int32>) -> Tensor

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

    Condition préalable

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

    Condition préalable

    Il ne doit y avoir aucune duplication des axes .

    Déclaration 

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

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

    Condition préalable

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

    Condition préalable

    Il ne doit y avoir aucune duplication des 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, à l'exception de 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.

    Note

    ++ est un opérateur personnalisé qui n'existe pas dans Swift, mais dans Haskell/Scala. Son ajout ne constitue pas un changement linguistique négligeable et peut prêter à controverse. 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 le long de la dimension axis

    Pour indices 0-D (scalaires) : 

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

    Pour indices 1-D (vecteur) : 

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

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

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

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

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

    Note

    Sur le processeur, si un index hors plage 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 à collecter.

    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 le long de la dimension axis , tout en ignorant les premières dimensions batchDimensionCount qui correspondent aux dimensions du lot. Le regroupement est effectué le long de la première dimension non-batch.

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

    Condition préalable

    axis doit être compris 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 principales du lot à 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 majeur des lignes).

    L' axis peut être utilisé avec mask pour indiquer l'axe à partir duquel masquer. Dans ce cas, axis + mask.rank <= tensor.rank et la 's shape must match the first mask axis + 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

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

    axis

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

    Valeur de retour

    (self.rank - K + 1) -tenseur dimensionnel peuplé d'entrées dans ce tenseur correspondant aux true valeurs dans 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 deuxième dimension (colonnes) représente les coordonnées des éléments non nuls. Gardez à l'esprit que la forme du tenseur de sortie peut varier en fonction du nombre de valeurs vraies qu'il contient. Les indices sont affichés dans l'ordre des lignes principales.

    Par exemple: 

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

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

    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 sous 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 des 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 de chaque dimension.

    upperBounds

    Les limites supérieures de 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 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 valeur scalaire unique et 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 valeur scalaire unique et 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 égales à 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 tensors , le long de la dimension axis , dans un nouveau tenseur de rang supérieur au tenseur actuel et chaque tenseur dans tensors .

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

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

    Par exemple: 

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

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

    Condition préalable

    Tous les tenseurs doivent avoir la même forme.

    Condition préalable

    axis doit être compris 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

    Tenseurs à empiler.

    axis

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

    Valeur de retour

    Le tenseur empilé.

  • Concatène tensors le long de la dimension axis .

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

    Par exemple: 

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

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

    Note

    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 axis doivent être égales.

    Condition préalable

    axis doit être compris 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

    Tenseurs à 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 other dans les voies où mask est true .

    Condition préalable

    self et other doivent avoir la même forme. Si self et other sont scalaires, alors mask doit également être scalaire. Si self et other ont un rang supérieur ou égal à 1 , alors mask doit avoir la même forme que self ou être un Tensor 1D 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 vrai si le type scalaire physique est à 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 convertie en type scalaire physique BFloat16 .

    Déclaration 

    public var toReducedPrecision: `Self` { get }

  • Renvoie une copie de self en type scalaire physique Scalar .

    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 rank est égal à 0 et false sinon.

    Déclaration 

    public var isScalar: Bool { get }

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

    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 tableau littéral.

    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.

    Note

    utilisez fullDescription pour une description non joliment 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 summarize est vrai 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 le résumé via des points de suspension ( ... ).

    summarizing

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

  • Une représentation textuelle complète et non joliment 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 lorsque « Scalaire » : « Numérique »

  • 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 la façon dont un tenseur est rempli.

    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 rembourré 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 lorsque « Scalaire » : « Numérique » et « Comparable »

  • Renvoie un tenseur de scalaires booléens en calculant lhs < rhs 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 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 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 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 par élément.

    Note

    .< 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 par élément.

    Note

    .<= 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 par élément.

    Note

    .> 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 par élément.

    Note

    .>= 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 par élément.

    Note

    .< 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 par élément.

    Note

    .<= 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 par élément.

    Note

    .> 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 par élément.

    Note

    .>= prend en charge la diffusion.

    Déclaration 

    public static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
Disponible lorsque « Scalaire » : « Équatable »

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

    Note

    .== 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 par élément.

    Note

    .!= 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 par élément.

    Note

    .== 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 par élément.

    Note

    .!= 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 par élément.

    Note

    .== 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 par élément.

    Note

    .!= prend en charge la diffusion.

    Déclaration 

    public static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
Disponible où `Scalar` : `TensorFlowFloatingPoint` & `Equatable`

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

    Condition préalable

    self et other doivent avoir la même forme.

    Déclaration 

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

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

    Condition préalable

    self et other doivent avoir la même forme.

    Déclaration 

    public func isAlmostEqual(
  to other: Tensor,
  tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Bool
Disponible 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 où `Scalar` : `TensorFlowFloatingPoint`
Disponible lorsque « Scalaire » : « Numérique »

  • 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 où `Scalar` : `TensorFlowFloatingPoint`
Disponible lorsque « Scalaire » : « Numérique »

  • 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

    Tenseur 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

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

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

    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 de fin 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 1D représentant une séquence allant d'une valeur de départ à une valeur finale (sans l'inclure), en incrémentant la quantité spécifiée.

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

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

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

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

    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 dimension chaude.

    onValue

    Un scalaire définissant la valeur à l'emplacement auquel fait référence un index dans indices .

    offValue

    Un scalaire définissant la valeur à un emplacement qui n'est référencé par aucun index dans indices .

    axis

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

Disponible 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 uniformément 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 de fin 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 uniformément 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 de fin 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 où `Scalar` : `TensorFlowIndex`

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

    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 où `Scalar` : `TensorFlowFloatingPoint`

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

    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 les valeurs scalaires 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 les valeurs scalaires 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 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 2D avec forme [batchSize, classCount] . Chaque tranche [i, :] représente les probabilités logarithmiques non normalisées pour toutes les classes.

    sampleCount

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

    seed

    La valeur de départ.

    Valeur de retour

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

Disponible où `Scalar` : `TensorFlowFloatingPoint`

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

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

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

    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 une initialisation normale Glorot (Xavier).

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

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

    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 en profondeur dans les redresseurs : surpasser 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 en profondeur dans les redresseurs : surpasser 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.

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

    Référence : « BackProp efficace »

    Déclaration 

    public init(
  leCunNormal 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 une matrice ou un tenseur orthogonal.

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

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

    Déclaration 

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

    Paramètres

    shape

    La forme du tenseur.

    gain

    Un facteur multiplicatif à appliquer au tenseur orthogonal.

    seed

    Un tuple de deux entiers pour amorcer le générateur de nombres aléatoires.

Disponible où `Scalar` : `TensorFlowNumeric`

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

    Par exemple: 

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

    Déclaration 

    @differentiable
public func diagonalPart() -> Tensor

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

    Par exemple: 

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

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

    Déclaration 

    @differentiable
public func diagonal() -> Tensor

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

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

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

    Déclaration 

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

  • Déclaration 

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

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

    Par exemple: 

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

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

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

    Déclaration 

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

    Paramètres

    subdiagonalCount

    Le nombre de sous-diagonales à conserver. Si négatif, conservez tout le triangle inférieur.

    superdiagonalCount

    Le nombre de superdiagonales à conserver. Si négatif, conservez tout le triangle supérieur.

Disponible où `Scalar` : `TensorFlowFloatingPoint`

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

    Déclaration 

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

    Paramètres

    fullMatrices

    Si true , calculez q et r en taille réelle. Sinon, calculez uniquement les premières colonnes min(shape[rank - 1], shape[rank - 2]) de q .

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

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

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

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

    Condition préalable

    self doit être un tenseur de forme [..., M, N] .

    Déclaration 

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

    Paramètres

    computeUV

    Si true , les vecteurs singuliers gauche et droit sont calculés et renvoyés respectivement sous la forme u et v . Si false , les valeurs nil sont renvoyées sous la forme u et v .

    fullMatrices

    Si true , u et v ont respectivement les formes [..., M, M] et [..., N, N] . Si false , u et v ont respectivement les formes [..., M, K] et [..., K, N] . Ignoré lorsque computeUV est faux.

    Valeur de retour

    • s : Les valeurs singulières, de forme [..., K] . Au sein de chaque vecteur, les valeurs singulières sont triées par ordre décroissant.
    • u : Les vecteurs singuliers gauches.
    • v : Les vecteurs singuliers droits.

  • La racine carrée de x .

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

    Déclaration 

    @differentiable
public static func sqrt(_ x: `Self`) -> Tensor<Scalar>

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

    Déclaration 

    @differentiable
public static func cos(_ x: `Self`) -> Tensor<Scalar>

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

    Déclaration 

    @differentiable
public static func sin(_ x: `Self`) -> Tensor<Scalar>

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

    Déclaration 

    @differentiable
public static func tan(_ x: `Self`) -> Tensor<Scalar>

  • Le cosinus inverse de x en radians.

    Déclaration 

    @differentiable
public static func acos(_ x: `Self`) -> Tensor<Scalar>

  • Le sinus inverse de x en radians.

    Déclaration 

    @differentiable
public static func asin(_ x: `Self`) -> Tensor<Scalar>

  • La tangente inverse de x en radians.

    Déclaration 

    @differentiable
public static func atan(_ x: `Self`) -> Tensor<Scalar>

  • Le cosinus hyperbolique de x .

    Déclaration 

    @differentiable
public static func cosh(_ x: `Self`) -> Tensor<Scalar>

  • Le sinus hyperbolique de x .

    Déclaration 

    @differentiable
public static func sinh(_ x: `Self`) -> Tensor<Scalar>

  • La tangente hyperbolique de x .

    Déclaration 

    @differentiable
public static func tanh(_ x: `Self`) -> Tensor<Scalar>

  • Le cosinus hyperbolique inverse de x .

    Déclaration 

    @differentiable
public static func acosh(_ x: `Self`) -> Tensor<Scalar>

  • Le sinus hyperbolique inverse de x .

    Déclaration 

    @differentiable
public static func asinh(_ x: `Self`) -> Tensor<Scalar>

  • La tangente hyperbolique inverse de x .

    Déclaration 

    @differentiable
public static func atanh(_ x: `Self`) -> Tensor<Scalar>

  • La fonction exponentielle appliquée à x , ou e**x .

    Déclaration 

    @differentiable
public static func exp(_ x: `Self`) -> Tensor<Scalar>

  • Deux élevés au pouvoir x .

    Déclaration 

    @differentiable
public static func exp2(_ x: `Self`) -> Tensor<Scalar>

  • Dix élevés au pouvoir x .

    Déclaration 

    @differentiable
public static func exp10(_ x: `Self`) -> Tensor<Scalar>

  • exp(x) - 1 évalué de manière à conserver une précision proche de zéro.

    Déclaration 

    @differentiable
public static func expm1(_ x: `Self`) -> Tensor<Scalar>

  • Le logarithme népérien de x .

    Déclaration 

    @differentiable
public static func log(_ x: `Self`) -> Tensor<Scalar>

  • Le logarithme en base deux de x .

    Déclaration 

    @differentiable
public static func log2(_ x: `Self`) -> Tensor<Scalar>

  • Le logarithme en base dix de x .

    Déclaration 

    @differentiable
public static func log10(_ x: `Self`) -> Tensor<Scalar>

  • log(1 + x) évalué de manière à conserver une précision proche de zéro.

    Déclaration 

    @differentiable
public static func log1p(_ x: `Self`) -> Tensor<Scalar>

  • exp(y log(x)) calculé sans perte de précision intermédiaire.

    Pour les types réels, si x est négatif, le résultat est nan, même si y a une valeur intégrale. Pour les types complexes, il y a une branche coupée sur l'axe réel négatif.

    Déclaration 

    @differentiable
public static func pow(_ x: `Self`, _ y: `Self`) -> Tensor<Scalar>

  • x élevé au n ème pouvoir.

    Le produit de n copies de x .

    Déclaration 

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

  • La racine n e de x .

    Pour les types réels, si x est négatif et n est même, le résultat est nan. Pour les types complexes, il y a une branche coupée le long de l'axe réel négatif.

    Déclaration 

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

  • Déclaration 

    public typealias VectorSpaceScalar = Float

  • Déclaration 

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

  • Déclaration 

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

  • Déclaration 

    public func subtracting(_ scalar: Float) -> Tensor<Scalar>
Disponible où `scalaire ':« numérique »

  • Ajoute le scalaire à chaque scalaire du tenseur et produit la somme.

    Déclaration 

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

  • Ajoute le scalaire à chaque scalaire du tenseur et produit la somme.

    Déclaration 

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

  • Soustrait le scalaire de chaque scalaire du tenseur et produit la différence.

    Déclaration 

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

  • Soustrait le scalaire de chaque scalaire du tenseur et produit la différence

    Déclaration 

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

  • Ajoute deux tenseurs et stocke le résultat dans la variable côté gauche.

    Note

    += prend en charge la diffusion.

    Déclaration 

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

  • Ajoute le scalaire à chaque scalaire du tenseur et stocke le résultat dans la variable côté gauche.

    Déclaration 

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

  • Soustrait le deuxième tenseur du premier et stocke le résultat dans la variable côté gauche.

    Note

    -= prend en charge la diffusion.

    Déclaration 

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

  • Soustrait le scalaire de chaque scalaire du tenseur et stocke le résultat dans la variable côté gauche.

    Déclaration 

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

  • Renvoie le tenseur produit en multipliant les deux tenseurs.

    Note

    * Prend en charge la diffusion.

    Déclaration 

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

  • Renvoie le tenseur en le multipliant avec chaque scalaire du tenseur.

    Déclaration 

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

  • Multiplie le scalaire avec chaque scalaire du tenseur et produit le produit.

    Déclaration 

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

  • Multiplie deux tenseurs et stocke le résultat dans la variable côté gauche.

    Note

    *= prend en charge la diffusion.

    Déclaration 

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

  • Multiplie le tenseur avec le scalaire, diffusant le scalaire et stocke le résultat dans la variable côté gauche.

    Déclaration 

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

  • Renvoie le quotient de la division du premier tenseur par le second.

    Note

    / Prend en charge la diffusion.

    Déclaration 

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

  • Renvoie le quotient de la division du scalaire par le tenseur, diffusant le scalaire.

    Déclaration 

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

  • Renvoie le quotient de la division du tenseur par le scalaire, diffusant le scalaire.

    Déclaration 

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

  • Divise le premier tenseur par le second et stocke le quotient dans la variable côté gauche.

    Déclaration 

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

  • Divise le tenseur par le scalaire, diffusant le scalaire et stocke le quotient dans la variable côté gauche.

    Déclaration 

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

  • Renvoie le reste de la division du premier tenseur par le second.

    Note

    % prend en charge la diffusion.

    Déclaration 

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

  • Renvoie le reste de la division du tenseur par le scalaire, diffusant le scalaire.

    Déclaration 

    public static func % (lhs: Tensor, rhs: Scalar) -> Tensor

  • Renvoie le reste de la division du scalaire par le tenseur, diffusant le scalaire.

    Déclaration 

    public static func % (lhs: Scalar, rhs: Tensor) -> Tensor

  • Divise le premier tenseur par le second et stocke le reste dans la variable côté gauche.

    Déclaration 

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

  • Divise le tenseur par le scalaire et stocke le reste dans la variable côté gauche.

    Déclaration 

    public static func %= (lhs: inout Tensor, rhs: Scalar)
Disponible où `Scalar` ==` bool`

  • Renvoie !self -élément.

    Déclaration 

    public func elementsLogicalNot() -> Tensor

  • Renvoie self && other élément.

    Note

    && prend en charge la diffusion.

    Déclaration 

    public func elementsLogicalAnd(_ other: Tensor) -> Tensor

  • Renvoie self && other élément, diffusant other .

    Déclaration 

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

  • Renvoie self || other élément.

    Déclaration 

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

  • Renvoie self || other élément, diffusant other .

    Déclaration 

    public func elementsLogicalOr(_ other: Scalar) -> Tensor
Disponible où «Scalar»: «Tensor-Rownnumeric»

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

    Déclaration 

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

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

    Déclaration 

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

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

    Déclaration 

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

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

    Déclaration 

    @differentiable(wrt: self)
public func clipped(min: Scalar, max: Scalar) -> Tensor
Disponible où `scalaire ':` signéNumeric'

  • Renvoie la négation de l'élément tenseur spécifié en ce qui concerne.

    Déclaration 

    @differentiable
public prefix static func - (rhs: Tensor) -> Tensor
Disponible où `scalaire ':« numérique »

  • Déclaration 

    @differentiable(wrt: self)
public func squared() -> Tensor
Disponible où `Scalar ':` TensorflowFloatingPoint`

  • Renvoie un tenseur booléen indiquant quels éléments de x sont finis.

    Déclaration 

    public var isFinite: Tensor<Bool> { get }

  • Renvoie un tenseur booléen indiquant quels éléments de x sont infinis.

    Déclaration 

    public var isInfinite: Tensor<Bool> { get }

  • Renvoie un tenseur booléen indiquant quels éléments de x sont à valeur nan.

    Déclaration 

    public var isNaN: Tensor<Bool> { get }
Disponible où `Scalar` ==` bool`

  • Renvoie true si tous les scalaires sont égaux à true . Sinon, renvoie false .

    Déclaration 

    public func all() -> Bool

  • Renvoie true si des scalaires sont égaux à true . Sinon, renvoie false .

    Déclaration 

    public func any() -> Bool

  • Effectue une logique et un fonctionnement le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Effectue une logique et un fonctionnement le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Effectue une logique et un fonctionnement le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Effectue une logique ou une opération le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

Disponible où «Scalar»: «numérique» et «comparable»

  • Déclaration 

    @differentiable
public func min() -> Tensor

  • Déclaration 

    @differentiable
public func max() -> Tensor

  • Renvoie les valeurs maximales le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie les valeurs maximales le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie les valeurs maximales le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie les valeurs minimales le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie les valeurs minimales le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie les valeurs minimales le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie les indices des valeurs maximales le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie les indices des valeurs minimales le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie le minimum le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie le minimum le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie le minimum le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie le minimum le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie le minimum le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie le minimum le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie l'indice de la valeur maximale des scalaires aplatis.

    Déclaration 

    public func argmax() -> Tensor<Int32>

  • Renvoie l'indice de la valeur minimale des scalaires aplatis.

    Déclaration 

    public func argmin() -> Tensor<Int32>
Disponible où `scalaire ':« numérique »

  • Renvoie la somme le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la somme le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la somme le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Déclaration 

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

  • Renvoie la somme le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la somme le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la somme le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie le produit le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie le produit le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie le produit le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Déclaration 

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

  • Renvoie le produit le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie le produit le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie le produit le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la moyenne arithmétique le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la moyenne arithmétique le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la moyenne arithmétique le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Déclaration 

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

  • Renvoie la moyenne arithmétique le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la moyenne arithmétique le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la moyenne arithmétique le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la variance le long des axes spécifiés. Les dimensions réduites sont supprimées. N'applique pas la correction de Bessel.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la variance le long des axes spécifiés. Les dimensions réduites sont supprimées. N'applique pas la correction de Bessel.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la variance le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1. n'applique pas la correction de Bessel.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Déclaration 

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

  • Renvoie la variance le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1. n'applique pas la correction de Bessel.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la variance le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1. n'applique pas la correction de Bessel.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la variance le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1. n'applique pas la correction de Bessel.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la somme cumulative de ce tenseur le long de l'axe spécifié. Par défaut, cette fonction effectue une somme cumulative inclusive qui signifie que le premier élément de l'entrée est identique au premier élément de la sortie: 

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

    En définissant l'argument exclusive sur true , une somme cumulative exclusive est effectuée à la place: 

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

    En définissant l'argument reverse sur true , la somme cumulative est effectuée dans la direction opposée: 

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

    Ceci est plus efficace que l'inversion séparément du tenseur résultant.

    Condition préalable

    axis doit être dans la plage -rank..<rank .

    Déclaration 

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

    Paramètres

    axis

    Axe le long de lequel effectuer l'opération de somme cumulative.

    exclusive

    Indique s'il faut effectuer une somme cumulative exclusive.

    reverse

    Indique s'il faut effectuer la somme cumulative dans l'ordre inversé.

    Valeur de retour

    Résultat de l'opération de somme cumulative.

  • Renvoie la somme cumulative de ce tenseur le long de l'axe spécifié. Par défaut, cette fonction effectue une somme cumulative inclusive qui signifie que le premier élément de l'entrée est identique au premier élément de la sortie: 

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

    En définissant l'argument exclusive sur true , une somme cumulative exclusive est effectuée à la place: 

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

    En définissant l'argument reverse sur true , la somme cumulative est effectuée dans la direction opposée: 

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

    Ceci est plus efficace que l'inversion séparément du tenseur résultant.

    Condition préalable

    axis.rank doit être 0 .

    Condition préalable

    axis doit être dans la plage -rank..<rank .

    Déclaration 

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

    Paramètres

    axis

    Axe le long de lequel effectuer l'opération de somme cumulative.

    exclusive

    Indique s'il faut effectuer une somme cumulative exclusive.

    reverse

    Indique s'il faut effectuer la somme cumulative dans l'ordre inversé.

    Valeur de retour

    Résultat de l'opération de somme cumulative.

  • Renvoie le produit cumulatif de ce tenseur le long de l'axe spécifié. Par défaut, cette fonction effectue un produit cumulatif inclusif qui signifie que le premier élément de l'entrée est identique au premier élément de la sortie: 

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

    En définissant l'argument exclusive sur true , un produit cumulatif exclusif est effectué à la place: 

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

    En définissant l'argument reverse sur true , le produit cumulatif est effectué dans la direction opposée: 

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

    Ceci est plus efficace que l'inversion séparément du tenseur résultant.

    Condition préalable

    axis doit être dans la plage -rank..<rank .

    Déclaration 

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

    Paramètres

    axis

    Axe le long de lequel effectuer le fonctionnement cumulatif du produit.

    exclusive

    Indique s'il faut effectuer un produit cumulatif exclusif.

    reverse

    Indique s'il faut effectuer le produit cumulatif dans l'ordre inversé.

    Valeur de retour

    Résultat du fonctionnement cumulatif du produit.

  • Renvoie le produit cumulatif de ce tenseur le long de l'axe spécifié. Par défaut, cette fonction effectue un produit cumulatif inclusif qui signifie que le premier élément de l'entrée est identique au premier élément de la sortie: 

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

    En définissant l'argument exclusive sur true , un produit cumulatif exclusif est effectué à la place: 

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

    En définissant l'argument reverse sur true , le produit cumulatif est effectué dans la direction opposée: 

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

    Ceci est plus efficace que l'inversion séparément du tenseur résultant.

    Condition préalable

    axis doit avoir le rang 0 .

    Condition préalable

    axis doit être dans la plage -rank..<rank .

    Déclaration 

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

    Paramètres

    axis

    Axe le long de lequel effectuer le fonctionnement cumulatif du produit.

    exclusive

    Indique s'il faut effectuer un produit cumulatif exclusif.

    reverse

    Indique s'il faut effectuer le produit cumulatif dans l'ordre inversé.

    Valeur de retour

    Résultat du fonctionnement cumulatif du produit.

Disponible où `Scalar ':` TensorflowFloatingPoint`

  • Renvoie l'écart type des éléments le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1 . N'applique pas la correction de Bessel.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie l'écart type des éléments le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1 . N'applique pas la correction de Bessel.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie l'écart type des éléments le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1 . N'applique pas la correction de Bessel.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie l'écart type de tous les éléments de ce tenseur. N'applique pas la correction de Bessel.

    Condition préalable

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

    Déclaration 

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

  • Renvoie l'écart type des éléments le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1 . N'applique pas la correction de Bessel.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie l'écart type des éléments le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1 . N'applique pas la correction de Bessel.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie l'écart type des éléments le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1 . N'applique pas la correction de Bessel.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie log(exp(self).sum(squeezingAxes: axes)) . Les dimensions réduites sont supprimées.

    Cette fonction est plus stable numériquement que log(exp(self).sum(squeezingAxes: axes)) directement. Il évite les débordements causés par le calcul de l' exp de grandes entrées et sous-débris causées par le calcul du log des petites entrées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie log(exp(self).sum(squeezingAxes: axes)) . Les dimensions réduites sont supprimées.

    Cette fonction est plus stable numériquement que log(exp(self).sum(squeezingAxes: axes)) directement. Il évite les débordements causés par le calcul de l' exp de grandes entrées et sous-débris causées par le calcul du log des petites entrées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie log(exp(self).sum(squeezingAxes: axes)) . Les dimensions réduites sont supprimées.

    Cette fonction est plus stable numériquement que log(exp(self).sum(squeezingAxes: axes)) directement. Il évite les débordements causés par le calcul de l' exp de grandes entrées et sous-débris causées par le calcul du log des petites entrées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie log(exp(self).sum()) . Le résultat est un scalaire.

    Cette fonction est plus stable numériquement que log(exp(self).sum()) directement. Il évite les débordements causés par le calcul de l' exp de grandes entrées et sous-débris causées par le calcul du log des petites entrées.

    Déclaration 

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

  • Renvoie log(exp(self).sum(alongAxes: axes)) . Les dimensions réduites sont conservées avec la valeur 1 .

    Cette fonction est plus stable numériquement que log(exp(self).sum(alongAxes: axes)) directement. Il évite les débordements causés par le calcul de l' exp de grandes entrées et sous-débris causées par le calcul du log des petites entrées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie log(exp(self).sum(alongAxes: axes)) . Les dimensions réduites sont conservées avec la valeur 1 .

    Cette fonction est plus stable numériquement que log(exp(self).sum(alongAxes: axes)) directement. Il évite les débordements causés par le calcul de l' exp de grandes entrées et sous-débris causées par le calcul du log des petites entrées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie log(exp(self).sum(alongAxes: axes)) . Les dimensions réduites sont conservées avec la valeur 1 .

    Cette fonction est plus stable numériquement que log(exp(self).sum(alongAxes: axes)) directement. Il évite les débordements causés par le calcul de l' exp de grandes entrées et sous-débris causées par le calcul du log des petites entrées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la moyenne et la variance de ce tenseur le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

    axes doivent avoir le rang 1 .

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la moyenne et la variance de ce tenseur le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la moyenne et la variance de ce tenseur le long des axes spécifiés. Les dimensions réduites sont supprimées.

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la moyenne et la variance des éléments de ce tenseur.

    Déclaration 

    @differentiable(wrt: self)
public func moments() -> Moments<Scalar>

  • Renvoie la moyenne et la variance de ce tenseur le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1 .

    Condition préalable

    axes doivent avoir le rang 1 .

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la moyenne et la variance de ce tenseur le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1 .

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

  • Renvoie la moyenne et la variance de ce tenseur le long des axes spécifiés. Les dimensions réduites sont conservées avec la valeur 1 .

    Condition préalable

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

    Déclaration 

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

    Paramètres

    axes

    Les dimensions à réduire.

Disponible où `scalaire ':« numérique »

  • Effectue une multiplication matricielle entre deux tenseurs et produit le résultat.

    Déclaration 

    @differentiable
public static func • (lhs: Tensor, rhs: Tensor) -> Tensor
Disponible où `Scalar ':` TensorflowFloatingPoint`

  • Déclaration 

    static func vjpInitDeviceAndPrecisionLike(
  _ value: Scalar,
  deviceAndPrecisionLike tensor: Tensor
) -> (value: Tensor, pullback: (Tensor) -> (Scalar, Tensor))

  • Renvoie un tenseur calculé à partir de la normalisation par lots de l'entrée le long de l'axe spécifié.

    Plus précisément, les rendements (self - mu) / (var + epsilon) * gamma + beta où mu et var sont respectivement la moyenne et la variance de self le long de axis .

    Déclaration 

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

    Paramètres

    axis

    La dimension par lots.

    offset

    Le décalage, également connu sous le nom de bêta.

    scale

    L'échelle, également connue sous le nom de gamma.

    epsilon

    Une petite valeur ajoutée au dénominateur pour une stabilité numérique.

  • Concaténe deux tenseurs le long du dernier axe.

    Déclaration 

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

  • Ajoute deux valeurs et produit leur somme.

    Déclaration 

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

  • En moyenne deux valeurs.

    Déclaration 

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

  • Multiplie deux valeurs.

    Déclaration 

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

  • Empiler deux valeurs.

    Déclaration 

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

  • Déclaration 

    @derivative
init(shape: scalars)
Disponible où «Scalar»: «Equatable»

  • Déclaration 

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

  • Déclaration 

    public static func != (lhs: Tensor, rhs: Tensor) -> Bool
Disponible où `scalaire ':« codable »

  • Déclaration 

    public func encode(to encoder: Encoder) throws

  • Déclaration 

    public init(from decoder: Decoder) throws
Disponible où `scalaire ':« numérique »

  • Le tenseur zéro scalaire.

  • Déclaration 

    public static var zero: Tensor { get }

  • Ajoute deux tenseurs et produit leur somme.

    Note

    + prend en charge la diffusion.

    Déclaration 

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

  • Soustrait un tenseur d'un autre et produit leur différence.

    Note

    - prend en charge la diffusion.

    Déclaration 

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

    Le tenseur scalaire.

    Déclaration 

    public static var one: Tensor { get }

  • Renvoie le réciproque par élément de self .

    Déclaration 

    public var reciprocal: Tensor { get }

  • Multiplie deux tenseurs en termes d'éléments et produit leur produit.

    Note

    .* Prend en charge la diffusion.

    Déclaration 

    public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor
Disponible où `Scalar ':` TensorflowFloatingPoint`

  • Déclaration 

    public typealias TangentVector = Tensor

  • Déclaration 

    public var zeroTangentVectorInitializer: () -> TangentVector { get }

  • Ajoute une annotation.

    Remarque: seul X10 est pris en charge. Pour les autres backends, self umodifié est retourné.

    Déclaration 

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

    Paramètres

    annotation

    L'annotation à ajouter.

    Valeur de retour

    Le tenseur annoté.

  • Déclaration 

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