Tensore

@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 nel tensore (come Int32 , Float , ecc.).

• maniglia
  Il TensorHandle sottostante.

  Nota

  handle è pubblico per consentire le operazioni definite dall'utente, ma normalmente non dovrebbe essere utilizzato.

  Dichiarazione

  public let handle: TensorHandle<Scalar>

• init(maniglia:)
  Dichiarazione

  public init(handle: TensorHandle<Scalar>)

• non impilato (lungo l'asse:)
  Decomprime la dimensione data di un tensore di rango R in più tensori di rango (R-1) . Scompatta N tensori da questo tensore scheggiandolo lungo la dimensione axis , dove N è dedotto dalla forma di questo tensore. Ad esempio, dato un tensore di forma [A, B, C, D] :

  • Se axis == 0 allora l' i -esimo tensore nell'array restituito è la fetta self[i, :, :, :] e ogni tensore nell'array avrà forma [B, C, D] . (Si noti che la dimensione decompressa è scomparsa, a differenza di Tensor.split(numSplits:alongAxis) o Tensor.split(sizes:alongAxis) ).
  • Se axis == 1 allora l' i -esimo tensore nell'array restituito è il value[:, i, :, :] e ogni tensore nell'array avrà forma [A, C, D] .
  • Ecc.

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

  Precondizione

  axis deve essere compreso nell'intervallo [-rank, rank) , dove rank è il rango 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 restituito

  Matrice contenente i tensori non impilati.

• dividere(contare:lungo l'asse:)
  Divide un tensore in più tensori. Il tensore è suddiviso lungo axis dimensionale in count più piccoli. Ciò richiede che count divida equamente 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]
  

  Precondizione

  count deve dividere equamente la dimensione axis dimensionale.

  Precondizione

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

  Dichiarazione

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

  Parametri

  count	Numero di suddivisioni da creare.
  axis	La dimensione lungo la quale dividere questo tensore. I valori negativi si avvolgono.

  Valore restituito

  Un array contenente la parte tensore.

• diviso(dimensioni:lungo l'asse:)
  Divide un tensore in più tensori. Il tensore è suddiviso in pezzi sizes.shape[0] . La forma dell'i i pezzo ha la stessa forma di questo tensore tranne lungo axis dimensionale 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]
  

  Precondizione

  La somma dei valori nelle sizes deve corrispondere alla dimensione axis dimensionale.

  Precondizione

  axis deve essere compreso nell'intervallo [-rank, rank) , dove rank è il rango 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 restituito

  Matrice contenente le parti tensori.

• diviso(dimensioni:lungo l'asse:)
  Dichiarazione

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

• piastrellato(multipli:)
  Restituisce un tensore affiancato, costruito affiancando questo tensore.

  Questo costruttore crea un nuovo tensore replicando questo tensore multiples volte. L' i -esima dimensione del tensore costruito ha elementi self.shape[i] * multiples[i] , e i valori di questo tensore sono replicati multiples[i] volte lungo l' i -esima dimensione. Ad esempio, affiancando [abcd] con [2] si ottiene [abcdabcd] .

  Precondizione

  Il rank previsto dei multipli deve essere 1 .

  Precondizione

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

  Precondizione

  Tutti gli scalari in multiples devono essere non negativi.

  Dichiarazione

  @differentiable(wrt: self)
  public func tiled(multiples: [Int]) -> Tensor

• piastrellato(multipli:)
  Restituisce un tensore affiancato, costruito affiancando questo tensore.

  Questo costruttore crea un nuovo tensore replicando questo tensore multiples volte. L' i -esima dimensione del tensore costruito ha elementi self.shape[i] * multiples[i] , e i valori di questo tensore sono replicati multiples[i] volte lungo l' i -esima dimensione. Ad esempio, affiancando [abcd] con [2] si ottiene [abcdabcd] .

  Precondizione

  Il rank previsto dei multipli deve essere 1 .

  Precondizione

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

  Dichiarazione

  @differentiable(wrt: self)
  public func tiled(multiples: Tensor<Int32>) -> Tensor

• rimodellato(come:)
  Rimodellare la forma del Tensor specificato.

  Precondizione

  Il numero di scalari corrisponde alla nuova forma.

  Dichiarazione

  @differentiable(wrt: self)
  public func reshaped<T>(like other: Tensor<T>) -> Tensor where T : TensorFlowScalar

• rimodellato(a:)
  Rimodellare alla forma specificata.

  Precondizione

  Il numero di scalari corrisponde alla nuova forma.

  Dichiarazione

  @differentiable(wrt: self)
  public func reshaped(to newShape: TensorShape) -> Tensor

• rimodellato(aShape:)
  Riforma al Tensor specificato che rappresenta una forma.

  Precondizione

  Il numero di scalari corrisponde alla nuova forma.

  Dichiarazione

  @differentiable(wrt: self)
  public func reshaped(toShape newShape: Tensor<Int32>) -> Tensor

• appiattito()
  Restituisce una copia del tensore collassato in un Tensor 1-D, in ordine di riga maggiore.

  Dichiarazione

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

• formaespandibile(a:)
  Restituisce un Tensor espanso di forma, con una dimensione pari a 1 inserita negli indici di forma specificati.

  Dichiarazione

  @differentiable(wrt: self)
  public func expandingShape(at axes: Int...) -> Tensor

• formaespandibile(a:)
  Restituisce un Tensor espanso di forma, con una dimensione pari a 1 inserita negli indici di forma specificati.

  Dichiarazione

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

• rango sollevato()
  Restituisce un Tensor con aumento di rango con una dimensione iniziale pari a 1.

  Dichiarazione

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

• spremituraForma(a:)
  Rimuove le dimensioni specificate della dimensione 1 dalla forma di un tensore. Se non vengono specificate dimensioni, tutte le dimensioni della dimensione 1 verranno rimosse.

  Dichiarazione

  @differentiable(wrt: self)
  public func squeezingShape(at axes: Int...) -> Tensor

• spremituraForma(a:)
  Rimuove le dimensioni specificate della dimensione 1 dalla forma di un tensore. Se non vengono specificate dimensioni, tutte le dimensioni della dimensione 1 verranno rimosse.

  Dichiarazione

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

• trasposto(permutazione:)
  Restituisce un tensore trasposto, con le dimensioni permutate nell'ordine specificato.

  Dichiarazione

  @differentiable(wrt: self)
  public func transposed(permutation: Tensor<Int32>) -> Tensor

• trasposto(conPermutazioni:)
  Restituisce un tensore trasposto, con le dimensioni permutate nell'ordine specificato.

  Dichiarazione

  @available(*, deprecated, renamed: "transposed(permutation:﹚")
  @differentiable(wrt: self)
  public func transposed(withPermutations permutations: Tensor<Int32>) -> Tensor

• trasposto(permutazione:)
  Restituisce un tensore trasposto, con le dimensioni permutate nell'ordine specificato.

  Dichiarazione

  @differentiable(wrt: self)
  public func transposed(permutation: [Int]) -> Tensor

• trasposto(conPermutazioni:)
  Restituisce un tensore trasposto, con le dimensioni permutate nell'ordine specificato.

  Dichiarazione

  @available(*, deprecated, renamed: "transposed(permutation:﹚")
  @differentiable(wrt: self)
  public func transposed(withPermutations permutations: [Int]) -> Tensor

• trasposto(permutazione:)
  Restituisce un tensore trasposto, con le dimensioni permutate nell'ordine specificato.

  Dichiarazione

  @differentiable(wrt: self)
  public func transposed(permutation: Int...) -> Tensor

• trasposto(conPermutazioni:)
  Restituisce un tensore trasposto, con le dimensioni permutate nell'ordine specificato.

  Dichiarazione

  @available(*, deprecated, renamed: "transposed(permutation:﹚")
  @differentiable(wrt: self)
  public func transposed(withPermutations permutations: Int...) -> Tensor

• trasposto()
  Restituisce un tensore trasposto, con le dimensioni permutate in ordine inverso.

  Dichiarazione

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

• invertito(inAssi:)
  Restituisce un tensore con le dimensioni specificate invertite.

  Precondizione

  Ogni valore negli axes deve essere compreso nell'intervallo -rank..<rank .

  Precondizione

  Non devono esserci duplicazioni negli axes .

  Dichiarazione

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

• invertito(inAssi:)
  Restituisce un tensore con le dimensioni specificate invertite.

  Precondizione

  Ogni valore negli axes deve essere compreso nell'intervallo -rank..<rank .

  Precondizione

  Non devono esserci duplicazioni negli axes .

  Dichiarazione

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

• invertito(inAssi:)
  Restituisce un tensore con le dimensioni specificate invertite.

  Precondizione

  Ogni valore negli axes deve essere compreso nell'intervallo -rank..<rank .

  Precondizione

  Non devono esserci duplicazioni negli axes .

  Dichiarazione

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

• concatenato(con:lungoAsse:)
  Restituisce un tensore concatenato lungo l'asse specificato.

  Precondizione

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

  Precondizione

  L'asse deve essere compreso nell'intervallo -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 esiste in Haskell/Scala. La sua aggiunta non è un cambiamento linguistico insignificante e può essere controverso. L'esistenza/denominazione di ++ verrà discussa durante una fase successiva di progettazione dell'API.

  Dichiarazione

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

• raccolta(aIndici:lungoAsse:)
  Restituisce un tensore raccogliendo porzioni dell'input negli indices lungo la dimensione axis

  Per indices 0-D (scalari):

  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 indices 1-D (vettoriali):

  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 intervallo, viene memorizzato uno 0 nei valori di output corrispondenti.

  Precondizione

  axis deve essere compreso nell'intervallo [-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 in cui riunirsi.
  axis	Dimensione lungo la quale raccogliersi. I valori negativi si avvolgono.

  Valore restituito

  Il tensore raccolto.

• batchGathering(atIndices:alongAxis:batchDimensionCount:)
  Restituisce sezioni di questo tensore in corrispondenza indices lungo la dimensione axis , ignorando le prime dimensioni batchDimensionCount che corrispondono alle dimensioni batch. La raccolta viene eseguita lungo la prima dimensione non batch.

  Esegue funzionalità simili alla gathering , tranne per il fatto che la forma tensore risultante è ora shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] .

  Precondizione

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

  Precondizione

  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 restituito

  Il tensore raccolto.

• raccolta(dove:lungo l'asse:)
  Restituisce un tensore raccogliendo i valori dopo aver applicato all'input la maschera booleana fornita.

  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 forma della mask deve corrispondere alle prime K dimensioni della forma del tensor . Abbiamo quindi: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] , dove [i1, ..., iK] è l' i esima true voce della mask (ordine riga maggiore).

  L' axis può essere utilizzato con mask per indicare l'asse da cui mascherare. In tal caso, axis + mask.rank <= tensor.rank e la 's shape must match the first mask devono corrispondere alle prime dimensions of the tensore.

  Precondizione

  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	Tensore booleano KD, dove K <= self.rank .
  axis	Tensore intero 0-D che rappresenta l'asse in self da cui mascherare, dove K + axis <= self.rank .

  Valore restituito

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

• nonZeroIndici()
  Restituisce le posizioni dei valori diversi da zero/veri in questo tensore.

  Le coordinate vengono restituite in un tensore 2D in cui 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 sono presenti in questo tensore. Gli indici vengono emessi in ordine di riga principale.

  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 restituito

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

• trasmesso(aShape:)
  Dichiarazione

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

• trasmesso(a:)
  Dichiarazione

  @differentiable(wrt: self)
  public func broadcasted(to shape: TensorShape) -> Tensor

• trasmesso(come:)
  Trasmetti nella stessa forma del Tensor specificato.

  Precondizione

  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)

• slice(limiti inferiori:limiti superiori:)
  Estrae una sezione dal tensore definito dai limiti inferiore e superiore per ciascuna dimensione.

  Dichiarazione

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

  Parametri

  lowerBounds	I limiti inferiori per ciascuna dimensione.
  upperBounds	I limiti superiori in ciascuna dimensione.

• slice(limiti inferiori:dimensioni:)
  Dichiarazione

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

• slice(limiti inferiori:dimensioni:)
  Dichiarazione

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

• pedice(_:)
  Dichiarazione

  @differentiable(wrt: self)
  public subscript(ranges: TensorRangeExpression...) -> Tensor { get set }

• GuaranteeValid(assi:funzione:file:riga:)
  Controlla che ogni elemento degli axes indichi un asse di self e altrimenti arresta il programma con una diagnostica.

  Dichiarazione

  func ensureValid(
    axes: Tensor<Int32>,
    function: StaticString = #function,
    file: StaticString = #file,
    line: UInt = #line
  )

• GuaranteeValid(assi:funzione:file:riga:)
  Controlla che ogni elemento degli axes indichi un asse di self e altrimenti arresta il programma con una diagnostica.

  Dichiarazione

  func ensureValid(
    axes: [Int],
    function: StaticString = #function,
    file: StaticString = #file,
    line: UInt = #line
  )

• GuaranteeValid(asse:funzione:file:riga:)
  Verifica che k denoti un asse di self e altrimenti interrompe il programma con una diagnostica.

  Dichiarazione

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

• init(raccolta:)
  Dichiarazione

  public init<BatchSamples: Collection>(collating samples: BatchSamples)
  where BatchSamples.Element == Self

• init(copia:in:)
  Crea una copia di other sul Device specificato.

  Dichiarazione

  public init(copying other: Tensor, to device: Device)

• init(forma:ripetizione:)
  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.

• init(ripetizione:forma:on:)
  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.

• init(trasmissione:rank:on:)
  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)

• inizia(_:)
  Crea un tensore da un array di tensori (che possono essere essi stessi scalari).

  Dichiarazione

  @differentiable
  public init(_ elements: [Tensor])

• init(impilamento:lungo l'asse:)
  Impila tensors , lungo la dimensione axis , in un nuovo tensore con rango uno superiore al tensore corrente e ciascun tensore in tensors .

  Dato che tensors hanno tutti 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] .
  • ecc.

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

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

  Precondizione

  Tutti i tensori devono avere la stessa forma.

  Precondizione

  axis deve essere compreso nell'intervallo [-rank, rank) , dove rank è il rango 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 restituito

  Il tensore impilato.

• init(concatenando:lungoAsse:)
  Concatena tensors lungo la dimensione axis .

  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 provenienti dai tensori di input vengono uniti lungo la dimensione axis .

  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 stai concatenando lungo un nuovo asse, considera l'utilizzo di Tensor.init(stacking:alongAxis:) .

  Precondizione

  Tutti i tensori devono avere lo stesso rango e tutte le dimensioni tranne axis devono essere uguali.

  Precondizione

  axis deve essere compreso nell'intervallo [-rank, rank) , dove rank è il rango 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 restituito

  Il tensore concatenato.

• sostituendo(con:dove:)
  Sostituisce gli elementi di questo tensore con other nelle corsie in cui mask è true .

  Precondizione

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

  Dichiarazione

  @differentiable(wrt: (self, other)
  ) public func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor

• èPrecisioneRidotta
  Restituisce vero se il tipo scalare fisico è a precisione ridotta.

  Attualmente, i tipi scalari fisici a precisione ridotta includono solo BFloat16 .

  Dichiarazione

  public var isReducedPrecision: Bool { get }

• init(_:deviceAndPrecisionLike:)
  Promuove uno scalare a tensore con lo stesso dispositivo e precisione del tensore specificato.

  Dichiarazione

  @differentiable
  public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)

• aPrecisioneRidotta
  Restituisce una copia di self convertita nel tipo scalare fisico BFloat16 .

  Dichiarazione

  public var toReducedPrecision: `Self` { get }

• aFullPrecision
  Restituisce una copia di self convertita nel tipo scalare fisico Scalar .

  Dichiarazione

  public var toFullPrecision: `Self` { get }

• rango
  Il numero di dimensioni del Tensor .

  Dichiarazione

  public var rank: Int { get }

• forma
  La forma del Tensor .

  Dichiarazione

  public var shape: TensorShape { get }

• scalarCount
  Il numero di scalari nel Tensor .

• scalarCount
  Dichiarazione

  public var scalarCount: Int { get }

• rangoTensore
  Rango del tensore, rappresentato come Tensor<Int32> .

  Dichiarazione

  public var rankTensor: Tensor<Int32> { get }

• tensore di forma
  Le dimensioni del tensore, rappresentate come Tensor<Int32> .

  Dichiarazione

  public var shapeTensor: Tensor<Int32> { get }

• scalarCountTensor
  Numero di scalari nel tensore, rappresentato come Tensor<Int32> .

  Dichiarazione

  public var scalarCountTensor: Tensor<Int32> { get }

• isScalar
  Restituisce true se rank è uguale a 0 e false altrimenti.

  Dichiarazione

  public var isScalar: Bool { get }

• scalare
  Restituisce il singolo elemento scalare se rank è uguale a 0 e nil altrimenti.

  Dichiarazione

  public var scalar: Scalar? { get }

• scalarizzato()
  Rimodellare in scalare.

  Precondizione

  Il tensore ha esattamente uno scalare.

  Dichiarazione

  @differentiable
  public func scalarized() -> Scalar

• vettore
  Dichiarazione

  public var array: ShapedArray<Scalar> { get }

• scalari
  Dichiarazione

  @differentiable
  public var scalars: [Scalar] { get }

• init(_:su:)
  Crea un tensore 0-D da un valore scalare.

  Dichiarazione

  @differentiable
  public init(_ value: Scalar, on device: Device = .default)

• init(_:su:)
  Crea un tensore 1D da scalari.

  Dichiarazione

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

• init(_:su:)
  Crea un tensore 1D da scalari.

  Dichiarazione

  public init<C: Collection>(
    _ vector: C, on device: Device = .default
  ) where C.Element == Scalar

• init(forma:scalari:on:)
  Crea un tensore con la forma specificata e scalari contigui nell'ordine della riga maggiore.

  Precondizione

  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.

• init(forma:scalari:on:)
  Crea un tensore con la forma specificata e scalari contigui nell'ordine della riga maggiore.

  Precondizione

  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.

• init(forma:scalari:toReducedPrecision:directlyOn:)
  Crea un tensore con la forma specificata e scalari contigui nell'ordine della riga maggiore.

  Precondizione

  Il prodotto delle dimensioni della forma deve essere uguale al numero di scalari.
• init(forma:scalari:on:)
  Crea un tensore con la forma specificata e scalari contigui nell'ordine della riga maggiore.

  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.

• ArrayLiteralElement
  Il tipo degli elementi di un valore letterale di array.

  Dichiarazione

  public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>

• init(arrayLiteral:)
  Crea un tensore inizializzato con gli elementi specificati.

  Dichiarazione

  public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)

• descrizione
  Una rappresentazione testuale del tensore.

  Nota

  utilizzare fullDescription per una descrizione non bella che mostri tutti gli scalari.

  Dichiarazione

  public var description: String { get }

• description(lineWidth:edgeElementCount:riepilogo:)
  Una rappresentazione testuale del tensore. Restituisce una descrizione riepilogativa se summarize è true e il conteggio degli elementi supera il doppio di 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 il riepilogo tramite puntini di sospensione ( ... ).
  summarizing	Se vero, riepiloga la descrizione se il conteggio degli elementi supera il doppio edgeElementCount .

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

  Dichiarazione

  public var fullDescription: String { get }

• irText
• parco giochiDescrizione
  Dichiarazione

  public var playgroundDescription: Any { get }

• customMirror
  Dichiarazione

  public var customMirror: Mirror { get }

• annotazioni
  Le annotazioni che descrivono questo tensore.

  Dichiarazione

  public var annotations: String { get }

• riepilogo
  Un alias per le annotazioni.

  Dichiarazione

  public var summary: String { get }

• init(_proprietario:)
  Dichiarazione

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

• init(_handles:)
  Dichiarazione

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

• init(_:su:)
  Dichiarazione

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

• init(_xla:)
  Dichiarazione

  init(_xla: XLATensor)

• init(_xlaHandle:)
  Dichiarazione

  init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

• xlaHandle
  Dichiarazione

  var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

• xlaTensor
  Dichiarazione

  var xlaTensor: XLATensor { get }

Disponibile dove `Scalare`: `Numerico`

• non trasmesso(toShape:)
  Dichiarazione

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

• non trasmesso (come:)
  Dichiarazione

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

• non trasmesso(a:)
  Dichiarazione

  @differentiable(wrt: self)
  public func unbroadcasted(to shape: TensorShape) -> Tensor

• PaddingMode
  Una modalità che determina come viene imbottito un tensore.

  Dichiarazione

  public enum PaddingMode

• imbottito(perTaglie:con:)
  Restituisce un tensore riempito 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

• imbottito(perTaglie:modalità:)
  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" e "Comparabile".

• .<(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs < rhs per elemento.

  Dichiarazione

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

• .<=(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs <= rhs per elemento.

  Dichiarazione

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

• .>(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs > rhs per elemento.

  Dichiarazione

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

• .>=(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs >= rhs per elemento.

  Dichiarazione

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

• .<(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs < rhs per elemento.

  Nota

  .< supporta la trasmissione.

  Dichiarazione

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

• .<=(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs <= rhs per elemento.

  Nota

  .<= supporta la trasmissione.

  Dichiarazione

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

• .>(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs > rhs per elemento.

  Nota

  .> supporta la trasmissione.

  Dichiarazione

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

• .>=(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs >= rhs per elemento.

  Nota

  .>= supporta la trasmissione.

  Dichiarazione

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

• .<(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs < rhs per elemento.

  Nota

  .< supporta la trasmissione.

  Dichiarazione

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

• .<=(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs <= rhs per elemento.

  Nota

  .<= supporta la trasmissione.

  Dichiarazione

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

• .>(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs > rhs per elemento.

  Nota

  .> supporta la trasmissione.

  Dichiarazione

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

• .>=(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs >= rhs per elemento.

  Nota

  .>= supporta la trasmissione.

  Dichiarazione

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

Disponibile dove "Scalare": "Equabile".

• .==(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs == rhs per elemento.

  Nota

  .== supporta la trasmissione.

  Dichiarazione

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

• .!=(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs != rhs per elemento.

  Nota

  .!= supporta la trasmissione.

  Dichiarazione

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

• .==(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs == rhs per elemento.

  Nota

  .== supporta la trasmissione.

  Dichiarazione

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

• .!=(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs != rhs per elemento.

  Nota

  .!= supporta la trasmissione.

  Dichiarazione

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

• .==(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs == rhs per elemento.

  Nota

  .== supporta la trasmissione.

  Dichiarazione

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

• .!=(_:_:)
  Restituisce un tensore di scalari booleani calcolando lhs != rhs per elemento.

  Nota

  .!= supporta la trasmissione.

  Dichiarazione

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

Disponibile dove `Scalar`: `TensorFlowFloatingPoint` e `Equatable`

• elementiQuasiUguali(_:tolleranza:)
  Restituisce un tensore di valori booleani che indica se gli elementi di self sono approssimativamente uguali a quelli di other .

  Precondizione

  self e other devono avere la stessa forma.

  Dichiarazione

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

Disponibile dove `Scalar`: `TensorFlowFloatingPoint`

• èQuasiUguale(a:tolleranza:)
  Restituisce true se tutti gli elementi di self sono approssimativamente uguali a quelli di other .

  Precondizione

  self e other devono avere la stessa forma.

  Dichiarazione

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

Disponibile dove `Scalar`: `TensorFlowNumeric`

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

  Dichiarazione

  public mutating mutating func crossReplicaSum(_ scale: Double)

Disponibile dove `Scalar`: `TensorFlowFloatingPoint`

• init(ripetendo:)
  Dichiarazione

  @derivative
  init(repeating: shape)

Disponibile dove `Scalare`: `Numerico`

• inizia(_:)
  Eseguire una conversione del tipo per elemento da un tensore Bool .

  Dichiarazione

  public init(_ other: Tensor<Bool>)

• inizia(_:)
  Esegui una conversione a livello di elemento da un altro Tensor .

  Dichiarazione

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

Disponibile dove `Scalar`: `TensorFlowFloatingPoint`

• inizia(_:)
  Dichiarazione

  @derivative
  init(_: <<error type>>)

• init(impilamento:)
  Dichiarazione

  @derivative
  init(stacking: alongAxis)

• init(concatenando:)
  Dichiarazione

  @derivative
  init(concatenating: alongAxis)

Disponibile dove `Scalare`: `Numerico`

• init(zeri:on:)
  Crea un tensore con tutti gli scalari impostati su zero.

  Dichiarazione

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

  Parametri

  shape

  Forma del tensore.

• init(quelli:su:)
  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.

• init(zeroMi piace:)
  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.

• init(Mi piace:)
  Crea un tensore con tutti gli scalari impostati su uno che ha la stessa forma e tipo del tensore fornito.

  Dichiarazione

  public init(onesLike other: Tensor)

  Parametri

  other

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

• init(intervalloDa:a:stride:on:)
  Crea un tensore 1D che rappresenta una sequenza da un valore iniziale a un valore finale escluso, con incrementi della quantità specificata.

  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 dei valori, il primo è start .
  end	Un valore finale per limitare la sequenza. end non è mai un elemento della sequenza risultante.
  stride	L'importo da incrementare con ogni iterazione. stride deve essere positivo.

• init(intervalloDa:a:stride:)
  Crea un tensore 1D che rappresenta una sequenza da un valore iniziale a un valore finale escluso, con incrementi della quantità specificata.

  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 dei valori, il primo è start .
  end	Un valore finale per limitare la sequenza. end non è mai un elemento della sequenza risultante.
  stride	L'importo da incrementare con ogni iterazione. stride deve essere positivo.

• init(oneHotAtIndices:profondità:onValue:offValue:axis:)
  Crea un tensore one-hot a determinati indici. Le posizioni rappresentate dagli indices assumono valore onValue ( 1 per impostazione predefinita), mentre tutte le altre posizioni assumono valore offValue ( 0 per impostazione predefinita). Se gli indices di input sono di rango n , il nuovo tensore avrà rango n+1 . Il nuovo asse viene creato in corrispondenza axis dimensione (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 di output sarà: caratteristiche x profondità, se asse == -1 profondità x caratteristiche, se asse == 0

  Se indices è una matrice (batch) con forma [batch, features] , la forma di output sarà: batch x features x profondità, se asse == -1 batch x profondità x features, se asse == 1 profondità x batch x features , 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 degli indici.
  depth	Uno scalare che definisce la profondità di una dimensione calda.
  onValue	Uno scalare che definisce il valore nella posizione a cui fa riferimento un indice in indices .
  offValue	Uno scalare che definisce il valore in una posizione a cui non fa riferimento alcun indice in indices .
  axis	L'asse da riempire. Il valore predefinito è -1 , un nuovo asse più interno.

Disponibile dove `Scalar`: `TensorFlowFloatingPoint`

• init(linearSpaceFrom:to:count:on:)
  Crea un tensore 1D che rappresenta una sequenza da un valore iniziale fino a un valore finale incluso, distanziato uniformemente per generare il numero di valori specificati.

  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 dei valori, 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.

• init(linearSpaceFrom:to:count:)
  Crea un tensore 1D che rappresenta una sequenza da un valore iniziale fino a un valore finale incluso, distanziato uniformemente per generare il numero di valori specificati.

  Precondizione

  start , to e count devono essere tensori 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 dei valori, 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 `Scalar`: `TensorFlowIndex`

• init(uniforme casuale:limite inferiore:limite superiore:seed:on:)
  Crea un tensore con la forma specificata, campionando in modo casuale 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 `Scalar`: `TensorFlowFloatingPoint`

• init(uniforme casuale:limite inferiore:limite superiore:seed:on:)
  Crea un tensore con la forma specificata, campionando in modo casuale 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.

• init(randomNormal:mean:standardDeviation:seed:on:)
  Crea un tensore con la forma specificata, campionando in modo casuale 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.

• init(randomTruncatedNormal:mean:standardDeviation:seed:on:)
  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 `Scalar`: `TensorFlowIndex`

• init(randomCategorialLogits:sampleCount:seed:)
  Crea un tensore estraendo campioni da una distribuzione categoriale.

  Dichiarazione

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

  Parametri

  randomCategorialLogits	Tensore 2-D con forma [batchSize, classCount] . Ogni fetta [i, :] rappresenta le probabilità logaritmiche non normalizzate per tutte le classi.
  sampleCount	0-D. Numero di campioni indipendenti da disegnare per ogni fetta di riga.
  seed	Il valore del seme.

  Valore restituito

  Tensore 2D con forma [batchSize, sampleCount] . Ogni sezione [i, :] contiene le etichette delle classi disegnate con intervallo [0, classCount) .

Disponibile dove `Scalar`: `TensorFlowFloatingPoint`

• init(glorotUniform:seed:on:)
  Crea un tensore con la forma specificata eseguendo l'inizializzazione uniforme di Glorot (Xavier).

  Disegna campioni casuali da una distribuzione uniforme tra -limit e limit generata dal generatore di numeri casuali predefinito, dove limit è sqrt(6 / (fanIn + fanOut)) e fanIn / fanOut rappresentano il numero di funzioni di input e output moltiplicate per il valore ricettivo dimensione del campo.

  Riferimento: "Comprendere la difficoltà di addestrare reti neurali feedforward profonde"

  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.

• init(glorotNormal:seed:on:)
  Crea un tensore con la forma specificata eseguendo l'inizializzazione normale di Glorot (Xavier).

  Disegna campioni casuali da una distribuzione normale troncata centrata su 0 con deviazione standard sqrt(2 / (fanIn + fanOut)) generata dal generatore di numeri casuali predefinito, dove fanIn / fanOut rappresentano il numero di caratteristiche di input e output moltiplicate per il campo ricettivo misurare.

  Riferimento: "Comprendere la difficoltà di addestrare reti neurali feedforward profonde"

  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.

• init(heUniform:seed:on:)
  Crea un tensore con la forma specificata eseguendo l'inizializzazione uniforme He (Kaiming).

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

  Riferimento: "Approfondire i raddrizzatori: superare le prestazioni a livello umano sulla classificazione ImageNet"

  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.

• init(heNormal:seed:on:)
  Crea un tensore con la forma specificata eseguendo l'inizializzazione normale He (Kaiming).

  Estrae campioni casuali da una distribuzione normale troncata centrata su 0 con deviazione standard sqrt(2 / fanIn)) generata dal generatore di numeri casuali predefinito, dove fanIn rappresenta il numero di caratteristiche di input moltiplicato per la dimensione del campo ricettivo.

  Riferimento: "Approfondire i raddrizzatori: superare le prestazioni a livello umano sulla classificazione ImageNet"

  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.

• init(leCunUniform:seed:on:)
  Crea un tensore con la forma specificata eseguendo l'inizializzazione uniforme di LeCun.

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

  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.

• init(leCunNormal:seed:on:)
  Crea un tensore con la forma specificata eseguendo l'inizializzazione normale di LeCun.

  Estrae campioni casuali da una distribuzione normale troncata centrata su 0 con deviazione standard sqrt(1 / fanIn) generata dal generatore di numeri casuali predefinito, dove fanIn rappresenta il numero di caratteristiche di input moltiplicato per la dimensione del campo ricettivo.

  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.

• init(ortogonale:guadagno:seme:)
  Crea una matrice ortogonale o tensore.

  Se la forma del tensore da inizializzare è bidimensionale, viene inizializzato con una matrice ortogonale ottenuta dalla scomposizione QR di una matrice di numeri casuali ricavata da una distribuzione normale. Se la matrice ha meno righe che colonne, l'output avrà righe ortogonali. Altrimenti, l'output avrà colonne ortogonali.

  Se la forma del tensore da inizializzare è più che bidimensionale, viene inizializzata una matrice di forma [shape[0] * ... * shape[rank - 2], shape[rank - 1]] . 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 numeri interi per inizializzare il generatore di numeri casuali.

Disponibile dove `Scalar`: `TensorFlowNumeric`

• diagonalPart()
  Restituisce la parte diagonale [in batch] di un tensore [in batch]. Per l'istanza tensore della forma [..., M, N] , l'output è 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

• diagonale()
  Costruisce un array diagonale [batch]. Per l'istanza tensore della forma [..., M] , l'output è 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

• conDiagonale(_:)
  Restituisce self con nuovi valori diagonali, dato che self è una matrice raggruppata facoltativamente.

  Il tensore restituito ha la stessa forma e gli stessi valori di self , ad eccezione delle diagonali specificate delle matrici più interne che vengono sovrascritte 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

• parteband(_:_:)
  Dichiarazione

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

• bandPart(Conteggio subdiagonale:Conteggio superdiagonale:)
  Restituisce una copia di un tensore più interno definito dai limiti di una banda centrale. L'output è un tensore della stessa forma dell'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 diagonali secondarie da conservare. Se negativo, mantieni l'intero triangolo inferiore.
  superdiagonalCount	Il numero di superdiagonali da conservare. Se negativo, mantieni l'intero triangolo superiore.

Disponibile dove `Scalar`: `TensorFlowFloatingPoint`

• qrDecomposizione(matrici complete:)
  Restituisce la scomposizione QR di ciascuna matrice interna nel tensore, un tensore con matrici ortogonali interne q e un tensore con matrici triangolari superiori interne r , in modo tale che il tensore sia uguale a matmul(q, r) .

  Dichiarazione

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

  Parametri

  fullMatrices

  Se true , calcola q e r a grandezza naturale. Altrimenti calcola solo le colonne iniziali min(shape[rank - 1], shape[rank - 2]) di q .

• svd(computeUV:fullMatrici:)
  Restituisce la scomposizione del valore singolare di self , dato che self è una matrice raggruppata facoltativamente.

  La decomposizione dei valori singolari (SVD) della matrice self facoltativamente raggruppata è costituita dai valori s , u e v , tali che:

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

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

  Precondizione

  self deve essere un tensore con 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 sinistro e destro vengono calcolati e restituiti rispettivamente come u e v . Se false , i valori nil 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 è falso.

  Valore restituito

  • s: I valori singolari, con 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 destri.
• quadrato(_:)
  La radice quadrata di x .

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

  Dichiarazione

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

• cos(_:)
  Il coseno di x , interpretato come un angolo in radianti.

  Dichiarazione

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

• peccato(_:)
  Il seno di x , interpretato come un angolo in radianti.

  Dichiarazione

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

• abbronzatura(_:)
  La tangente di x , interpretata come un angolo in radianti.

  Dichiarazione

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

• acos(_:)
  L'inverso del coseno di x in radianti.

  Dichiarazione

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

• asin(_:)
  Il seno inverso di x in radianti.

  Dichiarazione

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

• atan(_:)
  La tangente inversa di x in radianti.

  Dichiarazione

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

• cosh(_:)
  Il coseno iperbolico di x .

  Dichiarazione

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

• peccato(_:)
  Il seno iperbolico di x .

  Dichiarazione

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

• tanto(_:)
  La tangente iperbolica di x .

  Dichiarazione

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

• acosh(_:)
  Il coseno iperbolico inverso di x

  Dichiarazione

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

• asinh (_ :)
  Il seno iperbolico inverso di x

  Dichiarazione

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

• atanh (_ :)
  La tangente iperbolica inversa di x

  Dichiarazione

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

• exp (_ :)
  La funzione esponenziale applicata a x o e**x .

  Dichiarazione

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

• exp2 (_ :)
  Due sollevati per alimentare x

  Dichiarazione

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

• exp10 (_ :)
  Dieci sono cresciuti per alimentare x .

  Dichiarazione

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

• expm1 (_ :)
  exp(x) - 1 valutato in modo da preservare l'accuratezza vicino allo zero.

  Dichiarazione

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

• tronco d'albero(_:)
  Il logaritmo naturale di x .

  Dichiarazione

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

• log2 (_ :)
  Il logaritmo base-due di x .

  Dichiarazione

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

• log10 (_ :)
  Il logaritmo base-dieci di x .

  Dichiarazione

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

• log1p (_ :)
  log(1 + x) valutato in modo da preservare l'accuratezza vicino allo zero.

  Dichiarazione

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

• Pow (_: _ :)
  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 tipi complessi, c'è un taglio di ramo sull'asse reale negativo.

  Dichiarazione

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

• Pow (_: _ :)
  x Sollevato alla n .

  Il prodotto di n copie di x .

  Dichiarazione

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

• radice(_:_:)
  n radice di x .

  Per i tipi reali, se x è negativo e n è uniforme, il risultato è nan. Per tipi complessi, c'è un taglio di ramo lungo l'asse reale negativo.

  Dichiarazione

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

• VectorspaceScalar
  Dichiarazione

  public typealias VectorSpaceScalar = Float

• ridimensionato (da :)
  Dichiarazione

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

• Aggiunta (_ :)
  Dichiarazione

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

• sottrazione (_ :)
  Dichiarazione

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

Disponibile dove `Scalar`:` Numeric`

• +(_:_:)
  Aggiunge lo scalare a ogni scalare del tensore e produce la somma.

  Dichiarazione

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

• +(_:_:)
  Aggiunge lo scalare a ogni scalare del tensore e produce la somma.

  Dichiarazione

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

• -(_:_:)
  Sottrae lo scalare da ogni scalare del tensore e produce la differenza.

  Dichiarazione

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

• -(_:_:)
  Sottrae lo scalare da ogni scalare del tensore e produce la differenza

  Dichiarazione

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

• += (_: _ :)
  Aggiunge due tensori e memorizza il risultato nella variabile sul lato sinistro.

  Nota

  += supporta la trasmissione.

  Dichiarazione

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

• += (_: _ :)
  Aggiunge lo scalare a ogni scalare del tensore e memorizza il risultato nella variabile sul lato sinistro.

  Dichiarazione

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

• -= (_: _ :)
  Sottrae il secondo tensore dal primo e memorizza il risultato nella variabile sul lato sinistro.

  Nota

  -= supporta la trasmissione.

  Dichiarazione

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

• -= (_: _ :)
  Sottrae lo scalare da ogni scalare del tensore e memorizza il risultato nella variabile sul lato sinistro.

  Dichiarazione

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

• *(_: _ :)
  Restituisce il tensore prodotto moltiplicando i due tensori.

  Nota

  * Supporta la trasmissione.

  Dichiarazione

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

• *(_: _ :)
  Restituisce il tensore moltiplicandolo con ogni scalare del tensore.

  Dichiarazione

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

• *(_: _ :)
  Moltiplica lo scalare con ogni scalare del tensore e produce il prodotto.

  Dichiarazione

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

• *= (_: _ :)
  Moltiplica due tensori e memorizza il risultato nella variabile sul lato sinistro.

  Nota

  *= supporta la trasmissione.

  Dichiarazione

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

• *= (_: _ :)
  Moltiplica il tensore con lo scalare, trasmette lo scalare e memorizza il risultato nella variabile sul lato sinistro.

  Dichiarazione

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

• /(_: _ :)
  Restituisce il quoziente di dividere il primo tensore per il secondo.

  Nota

  / Supporta la trasmissione.

  Dichiarazione

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

• /(_: _ :)
  Restituisce il quoziente di dividere lo scalare per il tensore, trasmettendo lo scalare.

  Dichiarazione

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

• /(_: _ :)
  Restituisce il quoziente di dividere il tensore per lo scalare, trasmettendo lo scalare.

  Dichiarazione

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

• /= (_: _ :)
  Divide il primo tensore per il secondo e memorizza il quoziente nella variabile sul lato sinistro.

  Dichiarazione

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

• /= (_: _ :)
  Divide il tensore per lo scalare, trasmettendo lo scalare e memorizza il quoziente nella variabile sul lato sinistro.

  Dichiarazione

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

• %(_: _ :)
  Restituisce il resto della divisione del primo tensore per il secondo.

  Nota

  % supporta la trasmissione.

  Dichiarazione

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

• %(_: _ :)
  Restituisce il resto della divisione del tensore per lo scalare, trasmettendo lo scalare.

  Dichiarazione

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

• %(_: _ :)
  Restituisce il resto della divisione dello scalare per il tensore, trasmettendo lo scalare.

  Dichiarazione

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

• %= (_: _ :)
  Divide il primo tensore per il secondo e memorizza il resto nella variabile sul lato sinistro.

  Dichiarazione

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

• %= (_: _ :)
  Divide il tensore per lo scalare e memorizza il resto nella variabile sul lato sinistro.

  Dichiarazione

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

Disponibile dove `Scalar` ==` bool`

• ElementsLogicalNot ()
  Ritorna !self -elemento.

  Dichiarazione

  public func elementsLogicalNot() -> Tensor

• elementslogicaland (_ :)
  Restituisce self && other elementi.

  Nota

  && supporta la trasmissione.

  Dichiarazione

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

• elementslogicaland (_ :)
  Restituisce self && other elementi, trasmettendo other .

  Dichiarazione

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

• ElementsLogicalor (_ :)
  Restituisce self || other elementi.

  Dichiarazione

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

• ElementsLogicalor (_ :)
  Restituisce self || other elementi, trasmettendo other .

  Dichiarazione

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

Disponibile dove `Scalar`:` Tensorflownumeric`

• Clipped (min: max :)
  Restituisce max(min(self, max), min) .

  Dichiarazione

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

• Clipped (min: max :)
  Restituisce max(min(self, max), min) .

  Dichiarazione

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

• Clipped (min: max :)
  Restituisce max(min(self, max), min) .

  Dichiarazione

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

• Clipped (min: max :)
  Restituisce max(min(self, max), min) .

  Dichiarazione

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

Disponibile dove `Scalar`:` Signednumeric`

• -(_ :)
  Restituisce la negazione dell'elemento tensore specificato.

  Dichiarazione

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

Disponibile dove `Scalar`:` Numeric`

• quadrato ()
  Dichiarazione

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

Disponibile dove `Scalar`:` TensorFlowFloatingPoint`

• isfinite
  Restituisce un tensore booleano che indica quali elementi di x sono finiti.

  Dichiarazione

  public var isFinite: Tensor<Bool> { get }

• isinfinite
  Restituisce un tensore booleano che indica quali elementi di x sono infiniti.

  Dichiarazione

  public var isInfinite: Tensor<Bool> { get }

• isnan
  Restituisce un tensore booleano che indica quali elementi di x sono valori nan.

  Dichiarazione

  public var isNaN: Tensor<Bool> { get }

Disponibile dove `Scalar` ==` bool`

• Tutto()
  Restituisce true se tutti gli scalari sono uguali al true . Altrimenti, restituisce false .

  Dichiarazione

  public func all() -> Bool

• Qualunque()
  Restituisce true se qualche scalare è uguale al true . Altrimenti, restituisce false .

  Dichiarazione

  public func any() -> Bool

• Tutto (Streezingaxes :)
  Esegue un funzionamento logico e lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Qualsiasi (Streezingaxes :)
  Esegue un funzionamento logico e lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• tutto (lungo gli assi :)
  Esegue un funzionamento logico e lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• qualsiasi (lungo gli assi :)
  Esegue un'operazione logica o logica lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

Disponibile dove `Scalar`:` numeric` & `comparabile`

• min ()
  Dichiarazione

  @differentiable
  public func min() -> Tensor

• max ()
  Dichiarazione

  @differentiable
  public func max() -> Tensor

• Max (Squeezingaxes :)
  Restituisce i valori massimi lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Max (Squeezingaxes :)
  Restituisce i valori massimi lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Max (Squeezingaxes :)
  Restituisce i valori massimi lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Min (Streezingaxes :)
  Restituisce i valori minimi lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Min (Streezingaxes :)
  Restituisce i valori minimi lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Min (Streezingaxes :)
  Restituisce i valori minimi lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• argmax (SqueezingAxis :)
  Restituisce gli indici dei valori massimi lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• argmin (squeezingaxis :)
  Restituisce gli indici dei valori minimi lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• min (lungo i tassi :)
  Restituisce il minimo lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• min (lungo i tassi :)
  Restituisce il minimo lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• min (lungo i tassi :)
  Restituisce il minimo lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• max (lungo assi :)
  Restituisce il minimo lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• max (lungo assi :)
  Restituisce il minimo lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• max (lungo assi :)
  Restituisce il minimo lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• argmax ()
  Restituisce l'indice del valore massimo degli scalari appiattiti.

  Dichiarazione

  public func argmax() -> Tensor<Int32>

• argmin ()
  Restituisce l'indice del valore minimo degli scalari appiattiti.

  Dichiarazione

  public func argmin() -> Tensor<Int32>

Disponibile dove `Scalar`:` Numeric`

• Somma (Streezingaxes :)
  Restituisce la somma lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank...rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Somma (Streezingaxes :)
  Restituisce la somma lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank...rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Somma (Streezingaxes :)
  Restituisce la somma lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank...rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• somma()
  Dichiarazione

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

• somma (lungo i tassi :)
  Restituisce la somma lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• somma (lungo i tassi :)
  Restituisce la somma lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• somma (lungo i tassi :)
  Restituisce la somma lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Prodotto (Squeezingaxes :)
  Restituisce il prodotto lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank...rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Prodotto (Squeezingaxes :)
  Restituisce il prodotto lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank...rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Prodotto (Squeezingaxes :)
  Restituisce il prodotto lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank...rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• prodotto()
  Dichiarazione

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

• Prodotto (lungo i tassi :)
  Restituisce il prodotto lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Prodotto (lungo i tassi :)
  Restituisce il prodotto lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Prodotto (lungo i tassi :)
  Restituisce il prodotto lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Mean (Streezingaxes :)
  Restituisce la media aritmetica lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank...rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Mean (Streezingaxes :)
  Restituisce la media aritmetica lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank...rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Mean (Streezingaxes :)
  Restituisce la media aritmetica lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank...rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Significare()
  Dichiarazione

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

• Mean (lungo i tassi :)
  Restituisce la media aritmetica lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Mean (lungo i tassi :)
  Restituisce la media aritmetica lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Mean (lungo i tassi :)
  Restituisce la media aritmetica lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• varianza (squeezingax :)
  Restituisce la varianza lungo gli assi specificati. Le dimensioni ridotte vengono rimosse. Non applica la correzione di Bessel.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• varianza (squeezingax :)
  Restituisce la varianza lungo gli assi specificati. Le dimensioni ridotte vengono rimosse. Non applica la correzione di Bessel.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• varianza (squeezingax :)
  Restituisce la varianza lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1. Non applica la correzione di Bessel.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• varianza()
  Dichiarazione

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

• Varianza (lungo i tassi :)
  Restituisce la varianza lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1. Non applica la correzione di Bessel.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Varianza (lungo i tassi :)
  Restituisce la varianza lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1. Non applica la correzione di Bessel.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Varianza (lungo i tassi :)
  Restituisce la varianza lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1. Non applica la correzione di Bessel.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Cumulativesum (Longessis: Exclusive: Reverse :)
  Restituisce la somma cumulativa di questo tensore lungo l'asse specificato. Per impostazione predefinita, questa funzione esegue una somma cumulativa inclusiva, il che significa che il primo elemento dell'input è identico al primo elemento dell'output:

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

  Impostando l'argomento exclusive su true , viene invece eseguita una somma cumulativa esclusiva:

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

  Impostando l'argomento reverse su true , la somma cumulativa viene eseguita nella direzione opposta:

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

  Questo è più efficiente che invertire separatamente il tensore risultante.

  Precondizionismo

  axis deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axis	Asse lungo il quale eseguire l'operazione di somma cumulativa.
  exclusive	Indica se eseguire una somma cumulativa esclusiva.
  reverse	Indica se eseguire la somma cumulativa in ordine invertito.

  Valore restituito

  Risultato dell'operazione di somma cumulativa.

• Cumulativesum (Longessis: Exclusive: Reverse :)
  Restituisce la somma cumulativa di questo tensore lungo l'asse specificato. Per impostazione predefinita, questa funzione esegue una somma cumulativa inclusiva, il che significa che il primo elemento dell'input è identico al primo elemento dell'output:

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

  Impostando l'argomento exclusive su true , viene invece eseguita una somma cumulativa esclusiva:

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

  Impostando l'argomento reverse su true , la somma cumulativa viene eseguita nella direzione opposta:

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

  Questo è più efficiente che invertire separatamente il tensore risultante.

  Precondizionismo

  axis.rank deve essere 0 .

  Precondizionismo

  axis deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axis	Asse lungo il quale eseguire l'operazione di somma cumulativa.
  exclusive	Indica se eseguire una somma cumulativa esclusiva.
  reverse	Indica se eseguire la somma cumulativa in ordine invertito.

  Valore restituito

  Risultato dell'operazione di somma cumulativa.

• CumulativeProduct (Longexis: Exclusive: Reverse :)
  Restituisce il prodotto cumulativo di questo tensore lungo l'asse specificato. Per impostazione predefinita, questa funzione esegue un prodotto cumulativo inclusivo, il che significa che il primo elemento dell'input è identico al primo elemento dell'output:

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

  Impostando l'argomento exclusive su true , viene invece eseguito un prodotto cumulativo esclusivo:

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

  Impostando l'argomento reverse su true , il prodotto cumulativo viene eseguito nella direzione opposta:

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

  Questo è più efficiente che invertire separatamente il tensore risultante.

  Precondizionismo

  axis deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axis	Asse lungo il quale eseguire l'operazione cumulativa del prodotto.
  exclusive	Indica se eseguire un prodotto cumulativo esclusivo.
  reverse	Indica se eseguire il prodotto cumulativo in ordine invertito.

  Valore restituito

  Risultato dell'operazione cumulativa del prodotto.

• CumulativeProduct (Longexis: Exclusive: Reverse :)
  Restituisce il prodotto cumulativo di questo tensore lungo l'asse specificato. Per impostazione predefinita, questa funzione esegue un prodotto cumulativo inclusivo, il che significa che il primo elemento dell'input è identico al primo elemento dell'output:

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

  Impostando l'argomento exclusive su true , viene invece eseguito un prodotto cumulativo esclusivo:

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

  Impostando l'argomento reverse su true , il prodotto cumulativo viene eseguito nella direzione opposta:

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

  Questo è più efficiente che invertire separatamente il tensore risultante.

  Precondizionismo

  axis deve avere il grado 0 .

  Precondizionismo

  axis deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axis	Asse lungo il quale eseguire l'operazione cumulativa del prodotto.
  exclusive	Indica se eseguire un prodotto cumulativo esclusivo.
  reverse	Indica se eseguire il prodotto cumulativo in ordine invertito.

  Valore restituito

  Risultato dell'operazione cumulativa del prodotto.

Disponibile dove `Scalar`:` TensorFlowFloatingPoint`

• StandardDeviation (Squeezingaxes :)
  Restituisce la deviazione standard degli elementi lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1 . Non applica la correzione di Bessel.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• StandardDeviation (Squeezingaxes :)
  Restituisce la deviazione standard degli elementi lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1 . Non applica la correzione di Bessel.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• StandardDeviation (Squeezingaxes :)
  Restituisce la deviazione standard degli elementi lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1 . Non applica la correzione di Bessel.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• StandardDeviation ()
  Restituisce la deviazione standard di tutti gli elementi in questo tensore. Non applica la correzione di Bessel.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

• StandardDeviation (Longexes :)
  Restituisce la deviazione standard degli elementi lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1 . Non applica la correzione di Bessel.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• StandardDeviation (Longexes :)
  Restituisce la deviazione standard degli elementi lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1 . Non applica la correzione di Bessel.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• StandardDeviation (Longexes :)
  Restituisce la deviazione standard degli elementi lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1 . Non applica la correzione di Bessel.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• LogsumExp (Squeezingaxes :)
  Restituisce log(exp(self).sum(squeezingAxes: axes)) . Le dimensioni ridotte vengono rimosse.

  Questa funzione è più numericamente stabile del log(exp(self).sum(squeezingAxes: axes)) direttamente. Evita gli overflow causati exp di grandi input e underflow causati dal calcolo del log di piccoli input.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• LogsumExp (Squeezingaxes :)
  Restituisce log(exp(self).sum(squeezingAxes: axes)) . Le dimensioni ridotte vengono rimosse.

  Questa funzione è più numericamente stabile del log(exp(self).sum(squeezingAxes: axes)) direttamente. Evita gli overflow causati exp di grandi input e underflow causati dal calcolo del log di piccoli input.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• LogsumExp (Squeezingaxes :)
  Restituisce log(exp(self).sum(squeezingAxes: axes)) . Le dimensioni ridotte vengono rimosse.

  Questa funzione è più numericamente stabile del log(exp(self).sum(squeezingAxes: axes)) direttamente. Evita gli overflow causati exp di grandi input e underflow causati dal calcolo del log di piccoli input.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• logSumExp ()
  Restituisce log(exp(self).sum()) . Il risultato è uno scalare.

  Questa funzione è più numericamente stabile del log(exp(self).sum()) direttamente. Evita gli overflow causati exp di grandi input e underflow causati dal calcolo del log di piccoli input.

  Dichiarazione

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

• logsumexp (lungoaxes :)
  Restituisce log(exp(self).sum(alongAxes: axes)) . Le dimensioni ridotte vengono mantenute con il valore 1 .

  Questa funzione è più numericamente stabile del log(exp(self).sum(alongAxes: axes)) direttamente. Evita gli overflow causati exp di grandi input e underflow causati dal calcolo del log di piccoli input.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• logsumexp (lungoaxes :)
  Restituisce log(exp(self).sum(alongAxes: axes)) . Le dimensioni ridotte vengono mantenute con il valore 1 .

  Questa funzione è più numericamente stabile del log(exp(self).sum(alongAxes: axes)) direttamente. Evita gli overflow causati exp di grandi input e underflow causati dal calcolo del log di piccoli input.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• logsumexp (lungoaxes :)
  Restituisce log(exp(self).sum(alongAxes: axes)) . Le dimensioni ridotte vengono mantenute con il valore 1 .

  Questa funzione è più numericamente stabile del log(exp(self).sum(alongAxes: axes)) direttamente. Evita gli overflow causati exp di grandi input e underflow causati dal calcolo del log di piccoli input.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Momenti (Streezingax :)
  Restituisce la media e la varianza di questo tensore lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  axes devono avere il grado 1 .

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Momenti (Streezingax :)
  Restituisce la media e la varianza di questo tensore lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• Momenti (Streezingax :)
  Restituisce la media e la varianza di questo tensore lungo gli assi specificati. Le dimensioni ridotte vengono rimosse.

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• momenti ()
  Restituisce la media e la varianza degli elementi di questo tensore.

  Dichiarazione

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

• momenti (lungo assi :)
  Restituisce la media e la varianza di questo tensore lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1 .

  Precondizionismo

  axes devono avere il grado 1 .

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• momenti (lungo assi :)
  Restituisce la media e la varianza di questo tensore lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1 .

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

• momenti (lungo assi :)
  Restituisce la media e la varianza di questo tensore lungo gli assi specificati. Le dimensioni ridotte vengono mantenute con il valore 1 .

  Precondizionismo

  Ogni valore negli axes deve essere nell'intervallo -rank..<rank .

  Dichiarazione

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

  Parametri

  axes	Le dimensioni da ridurre.

Disponibile dove `Scalar`:` Numeric`

• • (_: _ :)
  Esegue la moltiplicazione della matrice tra due tensori e produce il risultato.

  Dichiarazione

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

Disponibile dove `Scalar`:` TensorFlowFloatingPoint`

• vjpinitDeviceAndPrisecisila (_: DeviceAndPriCisila: :)
  Dichiarazione

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

• batchnormalized (insieme: offset: scala: epsilon :)
  Restituisce un tensore calcolato dalla normalizzazione in batch dell'ingresso lungo l'asse specificato.

  In particolare, i resi (self - mu) / (var + epsilon) * gamma + beta dove mu e var sono rispettivamente la media e la varianza di self lungo 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	La dimensione batch.
  offset	L'offset, noto anche come beta.
  scale	La scala, nota anche come gamma.
  epsilon	Un piccolo valore aggiunto al denominatore per la stabilità numerica.

• concatenare(_:_:)
  Concatena due tensori lungo l'ultimo asse.

  Dichiarazione

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

• somma(_:_:)
  Aggiunge due valori e produce la loro somma.

  Dichiarazione

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

• media(_:_:)
  Media due valori.

  Dichiarazione

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

• moltiplicare(_:_:)
  Moltiplica due valori.

  Dichiarazione

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

• pila(_:_:)
  Impilare due valori.

  Dichiarazione

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

• init (forma :)
  Dichiarazione

  @derivative
  init(shape: scalars)

Disponibile dove `Scalar`:` Equatable`

• == (_: _ :)
  Dichiarazione

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

• ! = (_: _ :)
  Dichiarazione

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

Disponibile dove `Scalar`:` codable`

• codificare (a :)
  Dichiarazione

  public func encode(to encoder: Encoder) throws

• init (da :)
  Dichiarazione

  public init(from decoder: Decoder) throws

Disponibile dove `Scalar`:` Numeric`

• zero
  Il tensore zero scalare.

• zero
  Dichiarazione

  public static var zero: Tensor { get }

• +(_:_:)
  Aggiunge due tensori e produce la loro somma.

  Nota

  + Supporta la trasmissione.

  Dichiarazione

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

• -(_:_:)
  Sottrae un tensore da un altro e produce la loro differenza.

  Nota

  - Supporta la trasmissione.

  Dichiarazione

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

• uno
  Il tensore scalare.

  Dichiarazione

  public static var one: Tensor { get }

• reciproco
  Restituisce il reciproco di self .

  Dichiarazione

  public var reciprocal: Tensor { get }

• .*(_: _ :)
  Moltiplica due tensori per quanto riguarda l'elemento e produce il loro prodotto.

  Nota

  .* Supporta la trasmissione.

  Dichiarazione

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

Disponibile dove `Scalar`:` TensorFlowFloatingPoint`

• Vettore Tangente
  Dichiarazione

  public typealias TangentVector = Tensor

• zeroTangentVectorInitializer
  Dichiarazione

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

• annotare(_:)
  Aggiunge un'annotazione.

  Nota: è supportato solo X10. Per altri backend, viene restituito self umodificato.

  Dichiarazione

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

  Parametri

  annotation

  L'annotazione da aggiungere.

  Valore restituito

  Il tensore annotato.

• vjpannotate (_ :)
  Dichiarazione

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