tensore

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.
@frozen
public struct Tensor<Scalar> where Scalar : TensorFlowScalar
extension Tensor: Collatable
extension Tensor: CopyableToDevice
extension Tensor: AnyTensor
extension Tensor: ExpressibleByArrayLiteral
extension Tensor: CustomStringConvertible
extension Tensor: CustomPlaygroundDisplayConvertible
extension Tensor: CustomReflectable
extension Tensor: TensorProtocol
extension Tensor: TensorGroup
extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint
extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint
extension Tensor: Mergeable where Scalar: TensorFlowFloatingPoint
extension Tensor: Equatable where Scalar: Equatable
extension Tensor: Codable where Scalar: Codable
extension Tensor: AdditiveArithmetic where Scalar: Numeric
extension Tensor: PointwiseMultiplicative where Scalar: Numeric
extension Tensor: Differentiable & EuclideanDifferentiable where Scalar: TensorFlowFloatingPoint
extension Tensor: DifferentiableTensorProtocol
where Scalar: TensorFlowFloatingPoint

Un array multidimensionale di elementi che è una generalizzazione di vettori e matrici a dimensioni potenzialmente superiori.

Il parametro generico Scalar descrive il tipo di scalari del tensore (come Int32 , Float , ecc).

  • La sottostante TensorHandle .

    Nota

    handle è pubblica consentire ops definiti dall'utente, ma normalmente non dovrebbe essere usato.

    Dichiarazione

    public let handle: TensorHandle<Scalar>
  • Dichiarazione

    public init(handle: TensorHandle<Scalar>)
  • Spacchetta la dimensione proposta di una di ranghi R tensore in di ranghi multipla (R-1) tensori. Spacchetta N tensori di questo tensore di scheggiatura lungo axis dimensione, dove N è dedotta dalla forma di questo tensore. Ad esempio, dato un tensore di forma [A, B, C, D] :

    • Se axis == 0 allora i -esimo tensore nell'array restituito è la fetta self[i, :, :, :] e ogni tensore di tale array avrò forma [B, C, D] . (Nota che la dimensione scompattato lungo è andato, a differenza Tensor.split(numSplits:alongAxis) , o Tensor.split(sizes:alongAxis) ).
    • Se axis == 1 quindi il i -esimo tensore nell'array restituito è la fetta value[:, i, :, :] e ogni tensore di tale array avrà forma [A, C, D] .
    • Eccetera.

    Questo è l'opposto di Tensor.init(stacking:alongAxis:) .

    Prerequisito

    axis deve essere compreso nell'intervallo [-rank, rank) , dove rank è la posizione dei tensori forniti.

    Dichiarazione

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

    Parametri

    axis

    Dimensione lungo la quale disimpilare. I valori negativi si avvolgono.

    Valore di ritorno

    Array contenente i tensori non impilati.

  • Divide un tensore in più tensori. Il tensore è diviso lungo dimensione axis in count piccoli tensori. Ciò richiede che count uniformemente divide shape[axis] .

    Per esempio:

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

    Prerequisito

    count deve dividere la dimensione della dimensione axis uniformemente.

    Prerequisito

    axis deve essere compreso nell'intervallo [-rank, rank) , dove rank è la posizione dei tensori forniti.

    Dichiarazione

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

    Parametri

    count

    Numero di divisioni da creare.

    axis

    La dimensione lungo la quale dividere questo tensore. I valori negativi si avvolgono.

    Valore di ritorno

    Un array contenente la parte dei tensori.

  • Divide un tensore in più tensori. Il tensore è diviso in sizes.shape[0] pezzi. La forma del i pezzo -esimo ha la stessa forma di questo tensore eccetto lungo dimensione axis dove la dimensione è sizes[i] .

    Per esempio:

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

    Prerequisito

    I valori in sizes devono aggiungere fino alle dimensioni di dimensione axis .

    Precondizione

    axis deve essere compreso nell'intervallo [-rank, rank) , dove rank è la posizione dei tensori forniti.

    Dichiarazione

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

    Parametri

    sizes

    Tensore 1-D contenente la dimensione di ciascuna divisione.

    axis

    Dimensione lungo la quale dividere questo tensore. I valori negativi si avvolgono.

    Valore di ritorno

    Matrice contenente le parti dei tensori.

  • Dichiarazione

    @differentiable(wrt: self)
    public func split(sizes: [Int], alongAxis axis: Int = 0) -> [Tensor]
  • Restituisce un tensore affiancato, costruito affiancando questo tensore.

    Questo costruttore crea un nuovo tensore replicando questo tensore multiples volte. Il tensore costruito è i '° dimensione contiene self.shape[i] * multiples[i] elementi, ed i valori di questo tensore vengono replicati multiples[i] volte lungo il i ' ° dimensione. Ad esempio, piastrelle [abcd] da [2] produce [abcdabcd] .

    Prerequisito

    L'atteso rank di multipli deve essere 1 .

    Prerequisito

    La forma di multiples deve essere [tensor.rank] .

    Prerequisito

    Tutti scalari in multiples devono essere non negativo.

    Dichiarazione

    @differentiable(wrt: self)
    public func tiled(multiples: [Int]) -> Tensor
  • Restituisce un tensore affiancato, costruito affiancando questo tensore.

    Questo costruttore crea un nuovo tensore replicando questo tensore multiples volte. Il tensore costruito è i '° dimensione contiene self.shape[i] * multiples[i] elementi, ed i valori di questo tensore vengono replicati multiples[i] volte lungo il i ' ° dimensione. Ad esempio, piastrelle [abcd] da [2] produce [abcdabcd] .

    Prerequisito

    L'atteso rank di multipli deve essere 1 .

    Prerequisito

    La forma di multiples deve essere [tensor.rank] .

    Dichiarazione

    @differentiable(wrt: self)
    public func tiled(multiples: Tensor<Int32>) -> Tensor
  • Rimodellare la forma del specificato Tensor .

    Prerequisito

    Il numero di scalari corrisponde alla nuova forma.

    Dichiarazione

    @differentiable(wrt: self)
    public func reshaped<T>(like other: Tensor<T>) -> Tensor where T : TensorFlowScalar
  • Rimodellare alla forma specificata.

    Prerequisito

    Il numero di scalari corrisponde alla nuova forma.

    Dichiarazione

    @differentiable(wrt: self)
    public func reshaped(to newShape: TensorShape) -> Tensor
  • Rimodellare la specificata Tensor che rappresenta una forma.

    Prerequisito

    Il numero di scalari corrisponde alla nuova forma.

    Dichiarazione

    @differentiable(wrt: self)
    public func reshaped(toShape newShape: Tensor<Int32>) -> Tensor
  • Restituire una copia del tensore collassata in un 1-D Tensor , al fine row-major.

    Dichiarazione

    @differentiable(wrt: self)
    public func flattened() -> Tensor
  • Restituisce una forma espansa Tensor , con una dimensione di 1 inserito gli indici forma specifica.

    Dichiarazione

    @differentiable(wrt: self)
    public func expandingShape(at axes: Int...) -> Tensor
  • Restituisce una forma espansa Tensor , con una dimensione di 1 inserito gli indici forma specifica.

    Dichiarazione

    @differentiable(wrt: self)
    public func expandingShape(at axes: [Int]) -> Tensor
  • Restituisce un rango-sollevato Tensor con una dimensione principale di 1.

    Dichiarazione

    @differentiable(wrt: self)
    public func rankLifted() -> Tensor
  • Rimuove le dimensioni specificate di dimensione 1 dalla forma di un tensore. Se non vengono specificate dimensioni, tutte le dimensioni della taglia 1 verranno rimosse.

    Dichiarazione

    @differentiable(wrt: self)
    public func squeezingShape(at axes: Int...) -> Tensor
  • Rimuove le dimensioni specificate di dimensione 1 dalla forma di un tensore. Se non vengono specificate dimensioni, tutte le dimensioni della taglia 1 verranno rimosse.

    Dichiarazione

    @differentiable(wrt: self)
    public func squeezingShape(at axes: [Int]) -> Tensor
  • Restituisce un tensore trasposto, con dimensioni permutate nell'ordine specificato.

    Dichiarazione

    @differentiable(wrt: self)
    public func transposed(permutation: Tensor<Int32>) -> Tensor
  • Restituisce un tensore trasposto, con dimensioni permutate nell'ordine specificato.

    Dichiarazione

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
    @differentiable(wrt: self)
    public func transposed(withPermutations permutations: Tensor<Int32>) -> Tensor
  • Restituisce un tensore trasposto, con dimensioni permutate nell'ordine specificato.

    Dichiarazione

    @differentiable(wrt: self)
    public func transposed(permutation: [Int]) -> Tensor
  • Restituisce un tensore trasposto, con dimensioni permutate nell'ordine specificato.

    Dichiarazione

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
    @differentiable(wrt: self)
    public func transposed(withPermutations permutations: [Int]) -> Tensor
  • Restituisce un tensore trasposto, con dimensioni permutate nell'ordine specificato.

    Dichiarazione

    @differentiable(wrt: self)
    public func transposed(permutation: Int...) -> Tensor
  • Restituisce un tensore trasposto, con dimensioni permutate nell'ordine specificato.

    Dichiarazione

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
    @differentiable(wrt: self)
    public func transposed(withPermutations permutations: Int...) -> Tensor
  • Restituisce un tensore trasposto, con le dimensioni permutate in ordine inverso.

    Dichiarazione

    @differentiable(wrt: self)
    public func transposed() -> Tensor
  • Restituisce un tensore con le dimensioni specificate invertite.

    Precondizione

    Ogni valore in axes deve essere nel range -rank..<rank .

    Precondizione

    Non ci deve essere la duplicazione di axes .

    Dichiarazione

    @differentiable(wrt: self)
    public func reversed(inAxes axes: Tensor<Int32>) -> Tensor
  • Restituisce un tensore con le dimensioni specificate invertite.

    Prerequisito

    Ogni valore in axes deve essere nel range -rank..<rank .

    Prerequisito

    Non ci deve essere la duplicazione di axes .

    Dichiarazione

    @differentiable(wrt: self)
    public func reversed(inAxes axes: [Int]) -> Tensor
  • Restituisce un tensore con le dimensioni specificate invertite.

    Prerequisito

    Ogni valore in axes deve essere nel range -rank..<rank .

    Prerequisito

    Non ci deve essere la duplicazione di axes .

    Dichiarazione

    @differentiable(wrt: self)
    public func reversed(inAxes axes: Int...) -> Tensor
  • Restituisce un tensore concatenato lungo l'asse specificato.

    Precondizione

    I tensori devono avere le stesse dimensioni, ad eccezione dell'asse specificato.

    Prerequisito

    L'asse deve essere nel range -rank..<rank .

    Dichiarazione

    @differentiable
    public func concatenated(with other: Tensor, alongAxis axis: Int = 0) -> Tensor
  • Operatore di concatenazione.

    Nota

    ++ è un operatore personalizzato che non esiste in Swift, ma lo fa in Haskell / Scala. La sua aggiunta non è un cambiamento di lingua insignificante e può essere controversa. L'esistenza / denominazione di ++ sarà discusso durante una fase di progettazione API tardi.

    Dichiarazione

    @differentiable
    public static func ++ (lhs: Tensor, rhs: Tensor) -> Tensor
  • Restituisce un tensore raccogliendo fette di ingresso in corrispondenza indices lungo l' axis dimensione

    Per 0-D (scalari) indices :

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

    Per 1-D (vettore) indices :

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

    Nel caso generale, produce un tensore risultante dove:

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

    dove N = self.rank e M = indices.rank .

    La forma del tensore risultante è: self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...] .

    Nota

    Sulla CPU, se viene trovato un indice fuori intervallo, viene generato un errore. Sulla GPU, se viene trovato un indice fuori range, viene memorizzato uno 0 nei corrispondenti valori di output.

    Prerequisito

    axis deve essere nel range [-rank, rank) .

    Dichiarazione

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

    Parametri

    indices

    Contiene gli indici su cui raccogliere.

    axis

    Dimensione lungo la quale raccogliersi. I valori negativi si avvolgono.

    Valore di ritorno

    Il tensore raccolto.

  • Rendimenti fette di questo tensore a indices lungo l' axis dimensione, ignorando i primi batchDimensionCount dimensioni che corrispondono alle dimensioni batch. La raccolta viene eseguita lungo la prima dimensione non batch.

    Esegue una funzionalità simile a gathering , tranne che la forma tensore risultante è ora shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] .

    Precondizione

    axis deve essere nell'intervallo -rank..<rank , mentre anche essere maggiore o uguale a batchDimensionCount .

    Prerequisito

    batchDimensionCount deve essere inferiore a indices.rank .

    Dichiarazione

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

    Parametri

    indices

    Contiene gli indici da raccogliere.

    axis

    Dimensione lungo la quale raccogliersi. I valori negativi si avvolgono.

    batchDimensionCount

    Numero di dimensioni batch principali da ignorare.

    Valore di ritorno

    Il tensore raccolto.

  • Restituisce un tensore raccogliendo i valori dopo aver applicato la maschera booleana fornita all'input.

    Per esempio:

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

    In generale, 0 < mask.rank = K <= tensor.rank , e la mask 's forma deve corrispondere primi dimensioni K del tensor ' forma s. Abbiamo poi abbiamo: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] , dove [i1, ..., iK] rappresenta l' i esimo true entrata di mask (ordine row-major).

    L' axis potrebbe essere utilizzato con mask per indicare l'asse per mascherare da. In tal caso, axis + mask.rank <= tensor.rank e la mask 's shape must match the first assi + mask.rank dimensions of the forma del tensor`.

    Prerequisito

    La mask non può essere uno scalare: mask.rank != 0 .

    Dichiarazione

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

    Parametri

    mask

    KD tensore booleana, dove K <= self.rank .

    axis

    0-D intero tensore rappresenta l'asse in self per mascherare da dove K + axis <= self.rank .

    Valore di ritorno

    (self.rank - K + 1) tensore -dimensional popolato da voci in questo tensore corrispondenti ai true valori in mask .

  • Restituisce le posizioni dei valori diversi da zero/vero in questo tensore.

    Le coordinate vengono restituite in un tensore 2-D dove la prima dimensione (righe) rappresenta il numero di elementi diversi da zero e la seconda dimensione (colonne) rappresenta le coordinate degli elementi diversi da zero. Tieni presente che la forma del tensore di output può variare a seconda di quanti valori veri ci sono in questo tensore. Gli indici vengono emessi in ordine di riga.

    Per esempio:

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

    Dichiarazione

    public func nonZeroIndices() -> Tensor<Int64>

    Valore di ritorno

    Un tensore di forma (num_true, rank(condition)) .

  • Dichiarazione

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

    @differentiable(wrt: self)
    public func broadcasted(to shape: TensorShape) -> Tensor
  • Broadcast per la stessa forma della specificato Tensor .

    Prerequisito

    La forma specificata deve essere compatibile per la trasmissione.

    Dichiarazione

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

    public static func .= (lhs: inout Tensor, rhs: Tensor)
  • Estrae una porzione dal tensore definito dai limiti inferiore e superiore per ogni dimensione.

    Dichiarazione

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

    Parametri

    lowerBounds

    I limiti inferiori in ogni dimensione.

    upperBounds

    I limiti superiori in ogni dimensione.

  • Dichiarazione

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

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

    @differentiable(wrt: self)
    public subscript(ranges: TensorRangeExpression...) -> Tensor { get set }
  • Verifica che ogni elemento di axes denota un asse di self , e arresta il programma con una diagnostica altrimenti.

    Dichiarazione

    func ensureValid(
      axes: Tensor<Int32>,
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • Verifica che ogni elemento di axes denota un asse di self , e arresta il programma con una diagnostica altrimenti.

    Dichiarazione

    func ensureValid(
      axes: [Int],
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • Verifica che k denota un asse di self , e arresta il programma con una diagnostica altrimenti.

    Dichiarazione

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

    public init<BatchSamples: Collection>(collating samples: BatchSamples)
    where BatchSamples.Element == Self
  • Crea una copia di other sul dato Device .

    Dichiarazione

    public init(copying other: Tensor, to device: Device)
  • Crea un tensore con la forma specificata e un singolo valore scalare ripetuto.

    Dichiarazione

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

    Parametri

    shape

    Le dimensioni del tensore.

    repeatedValue

    Il valore scalare da ripetere.

  • Crea un tensore con la forma specificata e un singolo valore scalare ripetuto.

    Dichiarazione

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

    Parametri

    repeatedValue

    Il valore scalare da ripetere.

    shape

    Le dimensioni del tensore.

  • Crea un tensore trasmettendo lo scalare dato a un dato rango con tutte le dimensioni pari a 1.

    Dichiarazione

    public init(broadcasting scalar: Scalar, rank: Int, on device: Device = .default)
  • Crea un tensore da un array di tensori (che possono essere a loro volta scalari).

    Dichiarazione

    @differentiable
    public init(_ elements: [Tensor])
  • Pile tensors , lungo l' axis dimensione, in un nuovo tensore di rango uno rispetto al tensore corrente e per ciascun tensore in tensors .

    Dato che tensors tutti hanno forma [A, B, C] , e tensors.count = N , allora:

    • se axis == 0 allora il tensore risultante avrà la forma [N, A, B, C] .
    • se axis == 1 allora il tensore risultante avrà la forma [A, N, B, C] .
    • eccetera.

    Per esempio:

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

    Ciò è l'opposto di Tensor.unstacked(alongAxis:) .

    Prerequisito

    Tutti i tensori devono avere la stessa forma.

    Precondizione

    axis deve essere compreso nell'intervallo [-rank, rank) , dove rank è la posizione dei tensori forniti.

    Dichiarazione

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

    Parametri

    tensors

    Tensori da impilare.

    axis

    Dimensione lungo la quale impilare. I valori negativi si avvolgono.

    Valore di ritorno

    Il tensore impilato.

  • Concatena tensors lungo l' axis dimensione.

    Dato che tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] , allora il risultato concatenato ha forma [D0, D1, ... Raxis, ...Dn] , dove Raxis = sum(Daxis(i)) . Cioè, i dati dei tensori ingresso è unito lungo l' axis dimensione.

    Per esempio:

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

    Nota

    Se si concatenato lungo un nuovo asse considerare l'utilizzo di Tensor.init(stacking:alongAxis:) .

    Prerequisito

    Tutti tensori devono avere lo stesso grado e tutte le dimensioni eccetto axis devono essere uguali.

    Prerequisito

    axis deve essere compreso nell'intervallo [-rank, rank) , dove rank è la posizione dei tensori forniti.

    Dichiarazione

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

    Parametri

    tensors

    Tensori da concatenare.

    axis

    Dimensione lungo la quale concatenare. I valori negativi si avvolgono.

    Valore di ritorno

    Il tensore concatenato.

  • Sostituisce elementi di questo tensore con other nelle corsie in cui mask è true .

    Prerequisito

    self e other devono avere la stessa forma. Se self e other sono scalari, quindi mask deve essere anche scalare. Se self e other hanno una maggiore rango o uguale a 1 , quindi mask deve essere o avere la stessa forma self o essere un 1-D Tensor tale che mask.scalarCount == self.shape[0] .

    Dichiarazione

    @differentiable(wrt: (self, other)
    ) public func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor
  • Restituisce vero se il tipo scalare fisico ha una precisione ridotta.

    Attualmente, ridotta precisione tipi scalari fisici comprendono solo BFloat16 .

    Dichiarazione

    public var isReducedPrecision: Bool { get }
  • Promuove uno scalare a tensore con lo stesso dispositivo e precisione del tensore specificato.

    Dichiarazione

    @differentiable
    public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)
  • Restituisce una copia di self convertiti in BFloat16 tipo scalare fisico.

    Dichiarazione

    public var toReducedPrecision: `Self` { get }
  • Restituisce una copia di self convertiti Scalar tipo scalare fisico.

    Dichiarazione

    public var toFullPrecision: `Self` { get }
  • Il numero di dimensioni del Tensor .

    Dichiarazione

    public var rank: Int { get }
  • La forma del Tensor .

    Dichiarazione

    public var shape: TensorShape { get }
  • Il numero di scalari del Tensor .

  • Dichiarazione

    public var scalarCount: Int { get }
  • Il rango del tensore, rappresentato come un Tensor<Int32> .

    Dichiarazione

    public var rankTensor: Tensor<Int32> { get }
  • Le dimensioni del tensore, rappresentata come Tensor<Int32> .

    Dichiarazione

    public var shapeTensor: Tensor<Int32> { get }
  • Il numero di scalari nel tensore, rappresentato come un Tensor<Int32> .

    Dichiarazione

    public var scalarCountTensor: Tensor<Int32> { get }
  • Restituisce true se rank è uguale a 0 e false altrimenti.

    Dichiarazione

    public var isScalar: Bool { get }
  • Restituisce l'elemento singolo scalare se rank è uguale a 0 e nil altrimenti.

    Dichiarazione

    public var scalar: Scalar? { get }
  • Rimodellare in scalare.

    Prerequisito

    Il tensore ha esattamente uno scalare.

    Dichiarazione

    @differentiable
    public func scalarized() -> Scalar
  • Dichiarazione

    public var array: ShapedArray<Scalar> { get }
  • Dichiarazione

    @differentiable
    public var scalars: [Scalar] { get }
  • Crea un tensore 0-D da un valore scalare.

    Dichiarazione

    @differentiable
    public init(_ value: Scalar, on device: Device = .default)
  • Crea un tensore 1D da scalari.

    Dichiarazione

    @differentiable
    public init(_ scalars: [Scalar], on device: Device = .default)
  • Crea un tensore 1D da scalari.

    Dichiarazione

    public init<C: Collection>(
      _ vector: C, on device: Device = .default
    ) where C.Element == Scalar
  • Crea un tensore con la forma specificata e scalari contigui in ordine di riga.

    Prerequisito

    Il prodotto delle dimensioni della forma deve essere uguale al numero di scalari.

    Dichiarazione

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

    Parametri

    shape

    La forma del tensore.

    scalars

    Il contenuto scalare del tensore.

  • Crea un tensore con la forma specificata e scalari contigui in ordine di riga.

    Prerequisito

    Il prodotto delle dimensioni della forma deve essere uguale al numero di scalari.

    Dichiarazione

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

    Parametri

    shape

    La forma del tensore.

    scalars

    Il contenuto scalare del tensore.

  • Crea un tensore con la forma specificata e scalari contigui in ordine di riga.

    Precondizione

    Il prodotto delle dimensioni della forma deve essere uguale al numero di scalari.
  • Crea un tensore con la forma specificata e scalari contigui in ordine di riga.

    Precondizione

    Il prodotto delle dimensioni della forma deve essere uguale al numero di scalari.

    Dichiarazione

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

    Parametri

    shape

    La forma del tensore.

    scalars

    Il contenuto scalare del tensore.

  • Il tipo degli elementi di un valore letterale dell'array.

    Dichiarazione

    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
  • Crea un tensore inizializzato con gli elementi dati.

    Dichiarazione

    public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)
  • Una rappresentazione testuale del tensore.

    Nota

    uso fullDescription per una descrizione non pretty-stampato che mostra tutti gli scalari.

    Dichiarazione

    public var description: String { get }
  • Una rappresentazione testuale del tensore. Restituisce una descrizione riassunto se summarize è vero e il conteggio elemento supera il doppio del edgeElementCount .

    Dichiarazione

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

    Parametri

    lineWidth

    La larghezza massima della linea per la stampa. Utilizzato per determinare il numero di scalari da stampare per riga.

    edgeElementCount

    Il numero massimo di elementi da stampare prima e dopo riepilogo via puntini di sospensione ( ... ).

    summarizing

    Se fosse vero, riassumere descrizione se count elemento supera due volte edgeElementCount .

  • Una rappresentazione testuale completa e non stampata del tensore, che mostra tutti gli scalari.

    Dichiarazione

    public var fullDescription: String { get }
  • Dichiarazione

    public var playgroundDescription: Any { get }
  • Dichiarazione

    public var customMirror: Mirror { get }
  • Le annotazioni che descrivono questo tensore.

    Dichiarazione

    public var annotations: String { get }
  • Un alias per le annotazioni.

    Dichiarazione

    public var summary: String { get }
  • Dichiarazione

    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?)
  • Dichiarazione

    public init<C: RandomAccessCollection>(
      _handles: C
    ) where C.Element: _AnyTensorHandle
  • Dichiarazione

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

    init(_xla: XLATensor)
  • Dichiarazione

    init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)
  • Dichiarazione

    var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }
  • Dichiarazione

    var xlaTensor: XLATensor { get }

Disponibile dove `Scalare`: `Numerico`

  • Dichiarazione

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

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

    @differentiable(wrt: self)
    public func unbroadcasted(to shape: TensorShape) -> Tensor
  • Una modalità che determina come viene imbottito un tensore.

    Dichiarazione

    public enum PaddingMode
  • Restituisce un tensore imbottito con costante in base alle dimensioni di riempimento specificate.

    Dichiarazione

    @differentiable(wrt: self)
    public func padded(forSizes sizes: [(before: Int, after: Int)], with value: Scalar = 0)
      -> Tensor
  • Restituisce un tensore imbottito in base alle dimensioni e alla modalità di riempimento specificate.

    Dichiarazione

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

Disponibile dove `Scalare`: `Numerico` & `Confrontabile`

  • Restituisce un tensore di scalari booleane calcolando lhs < rhs elemento-saggio.

    Dichiarazione

    public static func .< (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs <= rhs elemento-saggio.

    Dichiarazione

    public static func .<= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs > rhs elemento-saggio.

    Dichiarazione

    public static func .> (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs >= rhs elemento-saggio.

    Dichiarazione

    public static func .>= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs < rhs elemento-saggio.

    Nota

    .< Broadcasting supporti.

    Dichiarazione

    public static func .< (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs <= rhs elemento-saggio.

    Nota

    .<= Supporti radiodiffusione.

    Dichiarazione

    public static func .<= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs > rhs elemento-saggio.

    Nota

    .> Supporti di radiodiffusione.

    Dichiarazione

    public static func .> (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs >= rhs elemento-saggio.

    Nota

    .>= Supporti di radiodiffusione.

    Dichiarazione

    public static func .>= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs < rhs elemento-saggio.

    Nota

    .< Broadcasting supporti.

    Dichiarazione

    public static func .< (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs <= rhs elemento-saggio.

    Nota

    .<= Supporti radiodiffusione.

    Dichiarazione

    public static func .<= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs > rhs elemento-saggio.

    Nota

    .> Supporti di radiodiffusione.

    Dichiarazione

    public static func .> (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs >= rhs elemento-saggio.

    Nota

    .>= Supporti di radiodiffusione.

    Dichiarazione

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

Disponibile dove `Scalare`: `Equabile`

  • Restituisce un tensore di scalari booleane calcolando lhs == rhs elemento-saggio.

    Nota

    .== supporti trasmissione.

    Dichiarazione

    public static func .== (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs != rhs elemento-saggio.

    Nota

    .!= Supporti radiodiffusione.

    Dichiarazione

    public static func .!= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs == rhs elemento-saggio.

    Nota

    .== supporti trasmissione.

    Dichiarazione

    public static func .== (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs != rhs elemento-saggio.

    Nota

    .!= Supporti radiodiffusione.

    Dichiarazione

    public static func .!= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs == rhs elemento-saggio.

    Nota

    .== supporti trasmissione.

    Dichiarazione

    public static func .== (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • Restituisce un tensore di scalari booleane calcolando lhs != rhs elemento-saggio.

    Nota

    .!= Supporti radiodiffusione.

    Dichiarazione

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

Disponibile dove `Scalare`: `TensorFlowFloatingPoint` & `Equatable`

  • Restituisce un tensore di valori booleani che indicano se gli elementi di self sono all'incirca uguali a quelle di other .

    Prerequisito

    self e other deve essere della stessa forma.

    Dichiarazione

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

Disponibile dove `Scalare`: `TensorFlowFloatingPoint`

  • Restituisce true se tutti gli elementi di self sono approssimativamente uguali a quelli di other .

    Prerequisito

    self e other deve essere della stessa forma.

    Dichiarazione

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

Disponibile dove `Scalare`: `TensorFlowNumeric`

  • Esegue una somma di repliche incrociate per questo tensore. La stessa somma di replica incrociata deve avvenire su ciascuno degli altri dispositivi che partecipano alla somma.

    Dichiarazione

    public mutating mutating func crossReplicaSum(_ scale: Double)

Disponibile dove `Scalare`: `TensorFlowFloatingPoint`

Disponibile dove `Scalare`: `Numerico`

  • Eseguire un tipo di conversione elemento-saggio da un Bool tensore.

    Dichiarazione

    public init(_ other: Tensor<Bool>)
  • Eseguire una conversione elemento-saggio da un altro Tensor .

    Dichiarazione

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

Disponibile dove `Scalare`: `TensorFlowFloatingPoint`

Disponibile dove `Scalare`: `Numerico`

  • Crea un tensore con tutti gli scalari impostati a zero.

    Dichiarazione

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

    Parametri

    shape

    Forma del tensore.

  • Crea un tensore con tutti gli scalari impostati su uno.

    Dichiarazione

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

    Parametri

    shape

    Forma del tensore.

  • Crea un tensore con tutti gli scalari impostati su zero che ha la stessa forma e tipo del tensore fornito.

    Dichiarazione

    public init(zerosLike other: Tensor)

    Parametri

    other

    Tensore di cui utilizzare la forma e il tipo di dati.

  • Crea un tensore con tutti gli scalari impostati su uno che abbia la stessa forma e lo stesso tipo del tensore fornito.

    Dichiarazione

    public init(onesLike other: Tensor)

    Parametri

    other

    Tensore di cui utilizzare la forma e il tipo di dati.

  • Crea un tensore 1-D che rappresenta una sequenza da un valore iniziale a, ma non includendo, un valore finale, aumentando l'importo specificato.

    Dichiarazione

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

    Parametri

    start

    Il valore iniziale da utilizzare per la sequenza. Se la sequenza contiene qualsiasi valore, il primo è start .

    end

    Un valore finale per limitare la sequenza. end non è mai un elemento della sequenza risultante.

    stride

    L'importo da aggiungere a ogni iterazione. stride deve essere positivo.

  • Crea un tensore 1-D che rappresenta una sequenza da un valore iniziale a, ma non includendo, un valore finale, aumentando l'importo specificato.

    Dichiarazione

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

    Parametri

    start

    Il valore iniziale da utilizzare per la sequenza. Se la sequenza contiene qualsiasi valore, il primo è start .

    end

    Un valore finale per limitare la sequenza. end non è mai un elemento della sequenza risultante.

    stride

    L'importo da aggiungere a ogni iterazione. stride deve essere positivo.

  • Crea un tensore one-hot a determinati indici. Le posizioni rappresentate da indices assumono valore onValue ( 1 di default), mentre tutti gli altri località assumono valore offValue ( 0 per default). Se l'ingresso indices è rango n , il nuovo tensore avrà rango n+1 . Il nuovo asse viene creato dimensione axis (per impostazione predefinita, il nuovo asse viene aggiunto alla fine).

    Se indices è uno scalare, la forma del nuovo tensore sarà un vettore di lunghezza depth .

    Se indices è un vettore di lunghezza features , la forma uscita sarà: caratteristiche x profondità, se le funzioni asse == -1 profondità x, se l'asse == 0

    Se indices è una matrice (batch) di forma [batch, features] , la forma uscita sarà: lotto x caratteristiche profondità x, se le funzioni asse == -1 lotto x profondità x, se l'asse == 1 x profondità x lotti caratteristiche , se asse == 0

    Dichiarazione

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

    Parametri

    indices

    Un Tensor di indici.

    depth

    Uno scalare che definisce la profondità di una dimensione calda.

    onValue

    Uno scalare definisce il valore alla posizione di cui da un indice in indices .

    offValue

    Uno scalare definire il valore in una posizione che non è indicato da un indice di indices .

    axis

    L'asse da riempire. Il valore predefinito è -1 , un nuovo più interna asse.

Disponibile dove `Scalare`: `TensorFlowFloatingPoint`

  • Crea un tensore 1-D che rappresenta una sequenza da un valore iniziale, fino a un valore finale compreso, spaziato uniformemente per generare il numero di valori specificato.

    Dichiarazione

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

    Parametri

    start

    Il valore iniziale da utilizzare per la sequenza. Se la sequenza contiene qualsiasi valore, il primo è start .

    end

    Un valore finale per limitare la sequenza. end è l'ultimo elemento della sequenza risultante.

    count

    Il numero di valori nella sequenza risultante. count deve essere positivo.

  • Crea un tensore 1-D che rappresenta una sequenza da un valore iniziale, fino a un valore finale compreso, spaziato uniformemente per generare il numero di valori specificato.

    Prerequisito

    start , to , e count deve essere Tensors contenenti un singolo valore scalare.

    Dichiarazione

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

    Parametri

    start

    Il valore iniziale da utilizzare per la sequenza. Se la sequenza contiene qualsiasi valore, il primo è start .

    end

    Un valore finale per limitare la sequenza. end è l'ultimo elemento della sequenza risultante.

    count

    Il numero di valori nella sequenza risultante. count deve essere positivo.

Disponibile dove `Scalare`: `TensorFlowIndex`

  • Crea un tensore con la forma specificata, campionando a caso valori scalari da una distribuzione uniforme tra lowerBound e upperBound .

    Dichiarazione

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

    Parametri

    shape

    Le dimensioni del tensore.

    lowerBound

    Il limite inferiore della distribuzione.

    upperBound

    Il limite superiore della distribuzione.

    seed

    Il valore del seme.

Disponibile dove `Scalare`: `TensorFlowFloatingPoint`

  • Crea un tensore con la forma specificata, campionando a caso valori scalari da una distribuzione uniforme tra lowerBound e upperBound .

    Dichiarazione

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

    Parametri

    shape

    Le dimensioni del tensore.

    lowerBound

    Il limite inferiore della distribuzione.

    upperBound

    Il limite superiore della distribuzione.

    seed

    Il valore del seme.

  • Crea un tensore con la forma specificata, campionando casualmente valori scalari da una distribuzione normale.

    Dichiarazione

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

    Parametri

    shape

    Le dimensioni del tensore.

    mean

    La media della distribuzione.

    standardDeviation

    La deviazione standard della distribuzione.

    seed

    Il valore del seme.

  • Crea un tensore con la forma specificata, campionando in modo casuale valori scalari da una distribuzione Normale troncata.

    Dichiarazione

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

    Parametri

    shape

    Le dimensioni del tensore.

    mean

    La media della distribuzione.

    standardDeviation

    La deviazione standard della distribuzione.

    seed

    Il valore del seme.

Disponibile dove `Scalare`: `TensorFlowIndex`

  • Crea un tensore disegnando campioni da una distribuzione categoriale.

    Dichiarazione

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

    Parametri

    randomCategorialLogits

    2-D Tensor di forma [batchSize, classCount] . Ogni fetta [i, :] rappresenta le probabilità di registro non normalizzate per tutte le classi.

    sampleCount

    0-D. Numero di campioni indipendenti da disegnare per ogni sezione di riga.

    seed

    Il valore del seme.

    Valore di ritorno

    2-D Tensor di forma [batchSize, sampleCount] . Ogni fetta [i, :] contiene le etichette di classe disegnate con range [0, classCount) .

Disponibile dove `Scalare`: `TensorFlowFloatingPoint`

  • Crea un tensore con la forma specificata eseguendo l'inizializzazione uniforme di Glorot (Xavier).

    Trae campioni casuali da una distribuzione uniforme tra -limit e limit generato dal generatore di numeri casuali predefinita, dove limit è sqrt(6 / (fanIn + fanOut)) e fanIn / fanOut rappresentano il numero di input e output caratteristiche moltiplicato per il ricettivo dimensione del campo.

    Riferimento: “Comprendere la difficoltà di formare reti neurali feedforward profonda”

    Dichiarazione

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

    Parametri

    shape

    Le dimensioni del tensore.

    seed

    Il valore del seme.

  • Crea un tensore con la forma specificata eseguendo l'inizializzazione normale di Glorot (Xavier).

    Si richiama campioni casuali da una distribuzione normale troncato centrate su 0 con deviazione standard sqrt(2 / (fanIn + fanOut)) generato dal generatore predefinito di numeri casuali, dove fanIn / fanOut rappresentano il numero di input e output caratteristiche moltiplicata per il campo recettivo dimensione.

    Riferimento: “Comprendere la difficoltà di formare reti neurali feedforward profonda”

    Dichiarazione

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

    Parametri

    shape

    Le dimensioni del tensore.

    seed

    Il valore del seme.

  • Crea un tensore con la forma specificata eseguendo l'inizializzazione uniforme He (Kaiming).

    Trae campioni casuali da una distribuzione uniforme tra -limit e limit generato dal generatore di numeri casuali predefinito, dove limit è sqrt(6 / fanIn) e fanIn rappresenta il numero di ingressi caratteristiche moltiplicato per la dimensione del campo recettivo.

    Riferimento: “scavare in profondità in raddrizzatori: Superando Human-Performance Level su IMAGEnet Classificazione”

    Dichiarazione

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

    Parametri

    shape

    Le dimensioni del tensore.

    seed

    Il valore del seme.

  • Crea un tensore con la forma specificata eseguendo l'inizializzazione normale He (Kaiming).

    Si richiama campioni casuali da una distribuzione normale troncato centrate su 0 con deviazione standard sqrt(2 / fanIn)) generato dal generatore di numeri casuali predefinita, dove fanIn rappresenta il numero di ingressi caratteristiche moltiplicato per la dimensione del campo recettivo.

    Riferimento: “scavare in profondità in raddrizzatori: Superando Human-Performance Level su IMAGEnet Classificazione”

    Dichiarazione

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

    Parametri

    shape

    Le dimensioni del tensore.

    seed

    Il valore del seme.

  • Crea un tensore con la forma specificata eseguendo l'inizializzazione uniforme di LeCun.

    Trae campioni casuali da una distribuzione uniforme tra -limit e limit generato dal generatore di numeri casuali predefinito, dove limit è sqrt(3 / fanIn) e fanIn rappresenta il numero di ingressi caratteristiche moltiplicato per la dimensione del campo recettivo.

    Riferimento: “Efficient BackProp”

    Dichiarazione

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

    Parametri

    shape

    Le dimensioni del tensore.

    seed

    Il valore del seme.

  • Crea un tensore con la forma specificata eseguendo l'inizializzazione normale di LeCun.

    Si richiama campioni casuali da una distribuzione normale troncato centrate su 0 con deviazione standard sqrt(1 / fanIn) generato dal generatore di numeri casuali predefinita, dove fanIn rappresenta il numero di ingressi caratteristiche moltiplicato per la dimensione del campo recettivo.

    Riferimento: “Efficient BackProp”

    Dichiarazione

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

    Parametri

    shape

    Le dimensioni del tensore.

    seed

    Il valore del seme.

  • Crea una matrice ortogonale o tensore.

    Se la forma del tensore da inizializzare è bidimensionale, si inizializza con una matrice ortogonale ottenuta dalla scomposizione QR di una matrice di numeri casuali estratti da una distribuzione normale. Se la matrice ha meno righe che colonne, l'output avrà righe ortogonali. In caso contrario, l'output avrà colonne ortogonali.

    Se la forma del tensore di inizializzazione è più di due dimensioni, una matrice di forma [shape[0] * ... * shape[rank - 2], shape[rank - 1]] viene inizializzato. La matrice viene successivamente rimodellata per dare un tensore della forma desiderata.

    Dichiarazione

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

    Parametri

    shape

    La forma del tensore.

    gain

    Un fattore moltiplicativo da applicare al tensore ortogonale.

    seed

    Una tupla di due interi per il seeding del generatore di numeri casuali.

Disponibile dove `Scalare`: `TensorFlowNumeric`

  • Restituisce la parte diagonale [batch] di un tensore [batch]. Per l'istanza tensore della forma [..., M, N] , l'uscita è un tensore della forma [..., K] , dove K è uguale min(N, M) .

    Per esempio:

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

    Dichiarazione

    @differentiable
    public func diagonalPart() -> Tensor
  • Costruisce un array diagonale [batch]. Per l'istanza tensore della forma [..., M] , l'uscita è un tensore della forma [..., M, M] .

    Per esempio:

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

    Dichiarazione

    @differentiable
    public func diagonal() -> Tensor
  • Ritorna self con valori nuovi diagonali, dato che self è una matrice opzionalmente batch.

    Il tensore restituito ha la stessa forma e valori self , tranne per le diagonali delle matrici specificate più interne che vengono sovrascritti dai valori in diagonal .

    Parametro diagonale: un tensore con rango rank - 1 che rappresenta i nuovi valori diagonali.

    Dichiarazione

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

    @differentiable(wrt: self)
    public func bandPart(_ subdiagonalCount: Int, _ superdiagonalCount: Int) -> Tensor
  • Restituisce una copia di un tensore più interno definito da un limite di banda centrale. L'uscita è un tensore della stessa forma come istanza [..., :, :] .

    Per esempio:

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

    Dichiarazione

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

    Parametri

    subdiagonalCount

    Il numero di sottodiagonali da mantenere. Se negativo, mantieni l'intero triangolo inferiore.

    superdiagonalCount

    Il numero di superdiagonali da mantenere. Se negativo, mantieni l'intero triangolo superiore.

Disponibile dove `Scalare`: `TensorFlowFloatingPoint`

  • Restituisce il QR decomposizione di ciascuna matrice interna del tensore, un tensore con matrici ortogonali interno q e un tensore con interni matrici triangolari superiori r , tale che il tensore è uguale a matmul(q, r) .

    Dichiarazione

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

    Parametri

    fullMatrices

    Se true , calcolare full-sized q e r . Altrimenti calcolare solo il leader min(shape[rank - 1], shape[rank - 2]) colonne di q .

  • Restituisce il valore decomposizione singolare di self , dato che self è una matrice opzionalmente dosare.

    Il valore singolare decomposizione (SVD) della matrice opzionalmente dosata self è valori s , u , e v , tali che:

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

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

    Prerequisito

    self deve essere un tensore di forma [..., M, N] .

    Dichiarazione

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

    Parametri

    computeUV

    Se true , i vettori singolari sinistra e destra vengono calcolati e restituiti come u e v , rispettivamente. Se false , nil valori vengono restituiti come u e v .

    fullMatrices

    Se true , u e v hanno rispettivamente forme [..., M, M] e [..., N, N] . Se false , u e v hanno rispettivamente forme [..., M, K] e [..., K, N] . Ignorato quando computeUV è falsa.

    Valore di ritorno

    • S: I valori singolari, con la forma [..., K] . All'interno di ciascun vettore, i valori singolari sono ordinati in ordine decrescente.
    • u: I vettori singolari di sinistra.
    • v: I vettori singolari giusti.
  • La radice quadrata di x .

    Per i tipi reali, se x è negativo il risultato è .nan . Per i tipi complessi c'è un taglio di ramo sull'asse reale negativo.

    Dichiarazione

    @differentiable
    public static func sqrt(_ x: `Self`) -> Tensor<Scalar>
  • Il coseno di x , interpretato come angolo in radianti.

    Dichiarazione

    @differentiable
    public static func cos(_ x: `Self`) -> Tensor<Scalar>
  • Il seno di x , interpretato come angolo in radianti.

    Dichiarazione

    @differentiable
    public static func sin(_ x: `Self`) -> Tensor<Scalar>
  • La tangente di x , interpretato come angolo in radianti.

    Dichiarazione

    @differentiable
    public static func tan(_ x: `Self`) -> Tensor<Scalar>
  • Il coseno inverso di x in radianti.

    Dichiarazione

    @differentiable
    public static func acos(_ x: `Self`) -> Tensor<Scalar>
  • Il seno inverso di x in radianti.

    Dichiarazione

    @differentiable
    public static func asin(_ x: `Self`) -> Tensor<Scalar>
  • La tangente inversa di x in radianti.

    Dichiarazione

    @differentiable
    public static func atan(_ x: `Self`) -> Tensor<Scalar>
  • Il coseno iperbolico di x .

    Dichiarazione

    @differentiable
    public static func cosh(_ x: `Self`) -> Tensor<Scalar>
  • Il seno iperbolico di x .

    Dichiarazione

    @differentiable
    public static func sinh(_ x: `Self`) -> Tensor<Scalar>
  • La tangente iperbolica di x .

    Dichiarazione

    @differentiable
    public static func tanh(_ x: `Self`) -> Tensor<Scalar>
  • Il coseno iperbolico inverso di x .

    Dichiarazione

    @differentiable
    public static func acosh(_ x: `Self`) -> Tensor<Scalar>
  • Il seno iperbolico inverso di x .

    Dichiarazione

    @differentiable
    public static func asinh(_ x: `Self`) -> Tensor<Scalar>
  • La tangente iperbolica inversa di x .

    Dichiarazione

    @differentiable
    public static func atanh(_ x: `Self`) -> Tensor<Scalar>
  • La funzione esponenziale applicata a x , o e**x .

    Dichiarazione

    @differentiable
    public static func exp(_ x: `Self`) -> Tensor<Scalar>
  • Due elevato alla potenza di x .

    Dichiarazione

    @differentiable
    public static func exp2(_ x: `Self`) -> Tensor<Scalar>
  • Dieci elevato alla potenza di x .

    Dichiarazione

    @differentiable
    public static func exp10(_ x: `Self`) -> Tensor<Scalar>
  • exp(x) - 1 valutato in modo da preservare l'accuratezza vicino a zero.

    Dichiarazione

    @differentiable
    public static func expm1(_ x: `Self`) -> Tensor<Scalar>
  • Il logaritmo naturale di x .

    Dichiarazione

    @differentiable
    public static func log(_ x: `Self`) -> Tensor<Scalar>
  • La base-due logaritmo di x .

    Dichiarazione

    @differentiable
    public static func log2(_ x: `Self`) -> Tensor<Scalar>
  • Il logaritmo in base dieci di x .

    Dichiarazione

    @differentiable
    public static func log10(_ x: `Self`) -> Tensor<Scalar>
  • log(1 + x) valutata in modo da preservare l'accuratezza vicino a zero.

    Dichiarazione

    @differentiable
    public static func log1p(_ x: `Self`) -> Tensor<Scalar>
  • exp(y log(x)) calcolato senza perdita di precisione intermedia.

    Per i tipi reali, se x è negativo il risultato è NaN, anche se y ha un valore integrale. Per i tipi complessi, c'è un taglio di ramo sull'asse reale negativo.

    Dichiarazione

    @differentiable
    public static func pow(_ x: `Self`, _ y: `Self`) -> Tensor<Scalar>
  • x elevato alla n esima potenza.

    Il prodotto di n copie di x .

    Dichiarazione

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

    Per i tipi reali, se x è negativo e n è pari, il risultato è NaN. Per i tipi complessi, c'è un ramo tagliato lungo l'asse reale negativo.

    Dichiarazione

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

    public typealias VectorSpaceScalar = Float
  • Dichiarazione

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

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

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

Disponibile dove `Scalare`: `Numerico`

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

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

    Nota

    += supports broadcasting.

    Dichiarazione

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

    Dichiarazione

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

    Nota

    -= supports broadcasting.

    Dichiarazione

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

    Dichiarazione

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

    Nota

    * supports broadcasting.

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

    Nota

    *= supports broadcasting.

    Dichiarazione

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

    Dichiarazione

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

    Nota

    / supports broadcasting.

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

    Nota

    % supports broadcasting.

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

Available where `Scalar` == `Bool`

  • Returns !self element-wise.

    Dichiarazione

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

    Nota

    && supports broadcasting.

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

Available where `Scalar`: `TensorFlowNumeric`

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

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

Available where `Scalar`: `SignedNumeric`

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

    Dichiarazione

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

Available where `Scalar`: `Numeric`

  • Dichiarazione

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

Available where `Scalar`: `TensorFlowFloatingPoint`

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

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

    public var isNaN: Tensor<Bool> { get }

Available where `Scalar` == `Bool`

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

    Dichiarazione

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

    Dichiarazione

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

  • Dichiarazione

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

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Dichiarazione

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

    Dichiarazione

    public func argmin() -> Tensor<Int32>

Available where `Scalar`: `Numeric`

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

  • Dichiarazione

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

  • Dichiarazione

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

  • Dichiarazione

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

  • Dichiarazione

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

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

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

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

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

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

    This is more efficient than separately reversing the resulting tensor.

    Precondition

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

    Dichiarazione

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

    Parametri

    axis

    Axis along which to perform the cumulative sum operation.

    exclusive

    Indicates whether to perform an exclusive cumulative sum.

    reverse

    Indicates whether to perform the cumulative sum in reversed order.

    Return Value

    Result of the cumulative sum operation.

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

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

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

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

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

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

    This is more efficient than separately reversing the resulting tensor.

    Precondition

    axis.rank must be 0 .

    Precondition

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

    Dichiarazione

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

    Parametri

    axis

    Axis along which to perform the cumulative sum operation.

    exclusive

    Indicates whether to perform an exclusive cumulative sum.

    reverse

    Indicates whether to perform the cumulative sum in reversed order.

    Return Value

    Result of the cumulative sum operation.

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

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

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

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

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

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

    This is more efficient than separately reversing the resulting tensor.

    Precondition

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

    Dichiarazione

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

    Parametri

    axis

    Axis along which to perform the cumulative product operation.

    exclusive

    Indicates whether to perform an exclusive cumulative product.

    reverse

    Indicates whether to perform the cumulative product in reversed order.

    Return Value

    Result of the cumulative product operation.

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

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

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

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

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

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

    This is more efficient than separately reversing the resulting tensor.

    Precondition

    axis must have rank 0 .

    Precondition

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

    Dichiarazione

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

    Parametri

    axis

    Axis along which to perform the cumulative product operation.

    exclusive

    Indicates whether to perform an exclusive cumulative product.

    reverse

    Indicates whether to perform the cumulative product in reversed order.

    Return Value

    Result of the cumulative product operation.

Available where `Scalar`: `TensorFlowFloatingPoint`

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

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

    Dichiarazione

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

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

    axes must have rank 1 .

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Dichiarazione

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

    Precondition

    axes must have rank 1 .

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

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

    Precondition

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

    Dichiarazione

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

    Parametri

    axes

    The dimensions to reduce.

Available where `Scalar`: `Numeric`

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

    Dichiarazione

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

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Dichiarazione

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

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

    Dichiarazione

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

    Parametri

    axis

    The batch dimension.

    offset

    The offset, also known as beta.

    scale

    The scale, also known as gamma.

    epsilon

    A small value added to the denominator for numerical stability.

  • Concatenates two tensors along last axis.

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

    Dichiarazione

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

    @derivative
    init(shape: scalars)

Available where `Scalar`: `Equatable`

  • Dichiarazione

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

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

Available where `Scalar`: `Codable`

  • Dichiarazione

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

    public init(from decoder: Decoder) throws

Available where `Scalar`: `Numeric`

  • The scalar zero tensor.

  • Dichiarazione

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

    Nota

    + supports broadcasting.

    Dichiarazione

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

    Nota

    - supports broadcasting.

    Dichiarazione

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

    The scalar one tensor.

    Dichiarazione

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

    Dichiarazione

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

    Nota

    .* supports broadcasting.

    Dichiarazione

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

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Dichiarazione

    public typealias TangentVector = Tensor
  • Dichiarazione

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

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

    Dichiarazione

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

    Parametri

    annotation

    The annotation to be added.

    Return Value

    The annotated tensor.

  • Dichiarazione

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