@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
Uma matriz multidimensional de elementos que é uma generalização de vetores e matrizes para dimensões potencialmente superiores.
O parâmetro genérico Scalar
descreve o tipo de escalares no tensor (como Int32
, Float
, etc).
O
TensorHandle
subjacente.Observação
handle
é público para permitir operações definidas pelo usuário, mas normalmente não deve ser usado.Declaração
public let handle: TensorHandle<Scalar>
Declaração
public init(handle: TensorHandle<Scalar>)
Descompacta a dimensão fornecida de um tensor de classificação
R
em vários tensores de classificação(R-1)
. DescompactaN
tensores deste tensor, fragmentando-o ao longo da dimensãoaxis
, ondeN
é inferido da forma deste tensor. Por exemplo, dado um tensor com forma[A, B, C, D]
:- Se
axis == 0
então oi
-ésimo tensor na matriz retornada é a fatiaself[i, :, :, :]
e cada tensor nessa matriz terá forma[B, C, D]
. (Observe que a dimensão descompactada desapareceu, ao contrário deTensor.split(numSplits:alongAxis)
ouTensor.split(sizes:alongAxis)
). - Se
axis == 1
então oi
-ésimo tensor na matriz retornada é ovalue[:, i, :, :]
e cada tensor nessa matriz terá forma[A, C, D]
. - Etc.
Este é o oposto de
Tensor.init(stacking:alongAxis:)
.Condição prévia
axis
deve estar no intervalo[-rank, rank)
, onderank
é a classificação dos tensores fornecidos.Declaração
@differentiable public func unstacked(alongAxis axis: Int = 0) -> [Tensor]
Parâmetros
axis
Dimensão ao longo da qual desempilhar. Valores negativos são envolventes.
Valor de retorno
Matriz contendo os tensores não empilhados.
- Se
Divide um tensor em vários tensores. O tensor é dividido ao longo
axis
de dimensão emcount
de tensores menores. Isso requer quecount
divida uniformementeshape[axis]
.Por exemplo:
// '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]
Condição prévia
count
deve dividir o tamanho doaxis
da dimensão igualmente.Condição prévia
axis
deve estar no intervalo[-rank, rank)
, onderank
é a classificação dos tensores fornecidos.Declaração
@differentiable public func split(count: Int, alongAxis axis: Int = 0) -> [Tensor]
Parâmetros
count
Número de divisões a serem criadas.
axis
A dimensão ao longo da qual dividir este tensor. Valores negativos são envolventes.
Valor de retorno
Uma matriz contendo a parte dos tensores.
Divide um tensor em vários tensores. O tensor é dividido em pedaços
sizes.shape[0]
. A forma dai
-ésima peça tem a mesma forma deste tensor, exceto ao longoaxis
de dimensão onde o tamanho ésizes[i]
.Por exemplo:
// '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]
Condição prévia
Os valores em
sizes
devem somar o tamanho doaxis
de dimensão.Condição prévia
axis
deve estar no intervalo[-rank, rank)
, onderank
é a classificação dos tensores fornecidos.Declaração
@differentiable(wrt: self) public func split(sizes: Tensor<Int32>, alongAxis axis: Int = 0) -> [Tensor]
Parâmetros
sizes
Tensor 1-D contendo o tamanho de cada divisão.
axis
Dimensão ao longo da qual dividir este tensor. Valores negativos são envolventes.
Valor de retorno
Matriz contendo as partes dos tensores.
Declaração
@differentiable(wrt: self) public func split(sizes: [Int], alongAxis axis: Int = 0) -> [Tensor]
Retorna um tensor lado a lado, construído colocando este tensor lado a lado.
Este construtor cria um novo tensor replicando-o
multiples
vezes. Ai
'ésima dimensão do tensor construído possui elementosself.shape[i] * multiples[i]
, e os valores deste tensor são replicadosmultiples[i]
vezes ao longo dai
'ésima dimensão. Por exemplo, colocar lado a lado[abcd]
por[2]
produz[abcdabcd]
.Condição prévia
A forma dosmultiples
deve ser[tensor.rank]
.Condição prévia
Todos os escalares emmultiples
devem ser não negativos.Declaração
@differentiable(wrt: self) public func tiled(multiples: [Int]) -> Tensor
Retorna um tensor lado a lado, construído colocando este tensor lado a lado.
Este construtor cria um novo tensor replicando-o
multiples
vezes. Ai
'ésima dimensão do tensor construído possui elementosself.shape[i] * multiples[i]
, e os valores deste tensor são replicadosmultiples[i]
vezes ao longo dai
'ésima dimensão. Por exemplo, colocar lado a lado[abcd]
por[2]
produz[abcdabcd]
.Condição prévia
A forma dosmultiples
deve ser[tensor.rank]
.Declaração
@differentiable(wrt: self) public func tiled(multiples: Tensor<Int32>) -> Tensor
Remodele para a forma do
Tensor
especificado.Condição prévia
O número de escalares corresponde à nova forma.Declaração
@differentiable(wrt: self) public func reshaped<T>(like other: Tensor<T>) -> Tensor where T : TensorFlowScalar
Remodele para a forma especificada.
Condição prévia
O número de escalares corresponde à nova forma.Declaração
@differentiable(wrt: self) public func reshaped(to newShape: TensorShape) -> Tensor
Remodele para o
Tensor
especificado representando uma forma.Condição prévia
O número de escalares corresponde à nova forma.Declaração
@differentiable(wrt: self) public func reshaped(toShape newShape: Tensor<Int32>) -> Tensor
Retorne uma cópia do tensor recolhido em um
Tensor
1-D, na ordem principal da linha.Declaração
@differentiable(wrt: self) public func flattened() -> Tensor
Retorna um
Tensor
de forma expandida, com uma dimensão 1 inserida nos índices de forma especificados.Declaração
@differentiable(wrt: self) public func expandingShape(at axes: Int...) -> Tensor
Retorna um
Tensor
de forma expandida, com uma dimensão 1 inserida nos índices de forma especificados.Declaração
@differentiable(wrt: self) public func expandingShape(at axes: [Int]) -> Tensor
Retorna um
Tensor
com classificação elevada e dimensão inicial de 1.Declaração
@differentiable(wrt: self) public func rankLifted() -> Tensor
Remove as dimensões especificadas de tamanho 1 da forma de um tensor. Se nenhuma dimensão for especificada, todas as dimensões de tamanho 1 serão removidas.
Declaração
@differentiable(wrt: self) public func squeezingShape(at axes: Int...) -> Tensor
Remove as dimensões especificadas de tamanho 1 da forma de um tensor. Se nenhuma dimensão for especificada, todas as dimensões de tamanho 1 serão removidas.
Declaração
@differentiable(wrt: self) public func squeezingShape(at axes: [Int]) -> Tensor
Retorna um tensor transposto, com dimensões permutadas na ordem especificada.
Declaração
@differentiable(wrt: self) public func transposed(permutation: Tensor<Int32>) -> Tensor
Retorna um tensor transposto, com dimensões permutadas na ordem especificada.
Declaração
@available(*, deprecated, renamed: "transposed(permutation:﹚") @differentiable(wrt: self) public func transposed(withPermutations permutations: Tensor<Int32>) -> Tensor
Retorna um tensor transposto, com dimensões permutadas na ordem especificada.
Declaração
@differentiable(wrt: self) public func transposed(permutation: [Int]) -> Tensor
Retorna um tensor transposto, com dimensões permutadas na ordem especificada.
Declaração
@available(*, deprecated, renamed: "transposed(permutation:﹚") @differentiable(wrt: self) public func transposed(withPermutations permutations: [Int]) -> Tensor
Retorna um tensor transposto, com dimensões permutadas na ordem especificada.
Declaração
@differentiable(wrt: self) public func transposed(permutation: Int...) -> Tensor
Retorna um tensor transposto, com dimensões permutadas na ordem especificada.
Declaração
@available(*, deprecated, renamed: "transposed(permutation:﹚") @differentiable(wrt: self) public func transposed(withPermutations permutations: Int...) -> Tensor
Retorna um tensor transposto, com dimensões permutadas em ordem inversa.
Declaração
@differentiable(wrt: self) public func transposed() -> Tensor
Retorna um tensor com dimensões especificadas invertidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Condição prévia
Não deve haver duplicação nosaxes
.Declaração
@differentiable(wrt: self) public func reversed(inAxes axes: Tensor<Int32>) -> Tensor
Retorna um tensor com dimensões especificadas invertidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Condição prévia
Não deve haver duplicação nosaxes
.Declaração
@differentiable(wrt: self) public func reversed(inAxes axes: [Int]) -> Tensor
Retorna um tensor com dimensões especificadas invertidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Condição prévia
Não deve haver duplicação nosaxes
.Declaração
@differentiable(wrt: self) public func reversed(inAxes axes: Int...) -> Tensor
Retorna um tensor concatenado ao longo do eixo especificado.
Condição prévia
Os tensores devem ter as mesmas dimensões, exceto o eixo especificado.Condição prévia
O eixo deve estar no intervalo-rank..<rank
.Declaração
@differentiable public func concatenated(with other: Tensor, alongAxis axis: Int = 0) -> Tensor
Operador de concatenação.
Observação
++
é um operador personalizado que não existe em Swift, mas existe em Haskell/Scala. Sua adição não é uma mudança linguística insignificante e pode ser controversa. A existência/nomeação de++
será discutida durante uma fase posterior de design da API.Declaração
@differentiable public static func ++ (lhs: Tensor, rhs: Tensor) -> Tensor
Retorna um tensor reunindo fatias da entrada em
indices
ao longo da dimensão doaxis
Para
indices
0-D (escalares):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}]
Para
indices
1-D (vetoriais):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}]
No caso geral, produz um tensor resultante onde:
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}]
onde
N = self.rank
eM = indices.rank
.A forma do tensor resultante é:
self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...]
.Observação
Na CPU, se um índice fora do intervalo for encontrado, um erro será gerado. Na GPU, se um índice fora do intervalo for encontrado, um 0 será armazenado nos valores de saída correspondentes.
Condição prévia
axis
deve estar no intervalo[-rank, rank)
.Declaração
@differentiable(wrt: self) public func gathering<Index: TensorFlowIndex>( atIndices indices: Tensor<Index>, alongAxis axis: Int = 0 ) -> Tensor
Parâmetros
indices
Contém os índices para coletar.
axis
Dimensão ao longo da qual reunir. Valores negativos são envolventes.
Valor de retorno
O tensor reunido.
Retorna fatias deste tensor em
indices
ao longo da dimensãoaxis
, ignorando as primeiras dimensõesbatchDimensionCount
que correspondem às dimensões do lote. A reunião é executada ao longo da primeira dimensão não-lote.Executa funcionalidade semelhante a
gathering
, exceto que a forma do tensor resultante agora éshape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...]
.Condição prévia
axis
deve estar no intervalo-rank..<rank
, ao mesmo tempo que é maior ou igual abatchDimensionCount
.Condição prévia
batchDimensionCount
deve ser menor queindices.rank
.Declaração
@differentiable(wrt: self) public func batchGathering<Index: TensorFlowIndex>( atIndices indices: Tensor<Index>, alongAxis axis: Int = 1, batchDimensionCount: Int = 1 ) -> Tensor
Parâmetros
indices
Contém os índices a serem coletados.
axis
Dimensão ao longo da qual reunir. Valores negativos são envolventes.
batchDimensionCount
Número de dimensões de lote principais a serem ignoradas.
Valor de retorno
O tensor reunido.
Retorna um tensor reunindo os valores após aplicar a máscara booleana fornecida à entrada.
Por exemplo:
// 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]]
Em geral,
0 < mask.rank = K <= tensor.rank
e a forma damask
devem corresponder às primeiras K dimensões da forma dotensor
. Temos então:tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd]
, onde[i1, ..., iK]
é ai
ésima entradatrue
damask
(ordem da linha principal).O
axis
pode ser usado commask
para indicar o eixo a partir do qual mascarar. Nesse caso,axis + mask.rank <= tensor.rank
e a's shape must match the first
mask
devem corresponder àsdimensions of the
forma do tensor.Condição prévia
A
mask
não pode ser escalar:mask.rank != 0
.Declaração
@differentiable(wrt: self) public func gathering(where mask: Tensor<Bool>, alongAxis axis: Int = 0) -> Tensor
Parâmetros
mask
Tensor booleano KD, onde
K <= self.rank
.axis
Tensor inteiro 0-D representando o eixo em
self
a ser mascarado, ondeK + axis <= self.rank
.Valor de retorno
(self.rank - K + 1)
tensor dimensional preenchido por entradas neste tensor correspondentes a valorestrue
emmask
.Retorna as localizações de valores diferentes de zero/verdadeiros neste tensor.
As coordenadas são retornadas em um tensor 2-D onde a primeira dimensão (linhas) representa o número de elementos diferentes de zero e a segunda dimensão (colunas) representa as coordenadas dos elementos diferentes de zero. Tenha em mente que a forma do tensor de saída pode variar dependendo de quantos valores verdadeiros existem neste tensor. Os índices são gerados em ordem de linha principal.
Por exemplo:
// '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]]
Declaração
public func nonZeroIndices() -> Tensor<Int64>
Valor de retorno
Um tensor com forma
(num_true, rank(condition))
.Declaração
@differentiable(wrt: self) public func broadcasted(toShape shape: Tensor<Int32>) -> Tensor
Declaração
@differentiable(wrt: self) public func broadcasted(to shape: TensorShape) -> Tensor
Transmita para a mesma forma do
Tensor
especificado.Condição prévia
O formato especificado deve ser compatível para transmissão.Declaração
@differentiable(wrt: self) public func broadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar
Declaração
public static func .= (lhs: inout Tensor, rhs: Tensor)
Extrai uma fatia do tensor definido pelos limites inferior e superior de cada dimensão.
Declaração
@differentiable(wrt: self) public func slice(lowerBounds: [Int], upperBounds: [Int]) -> Tensor
Parâmetros
lowerBounds
Os limites inferiores em cada dimensão.
upperBounds
Os limites superiores em cada dimensão.
Declaração
@differentiable(wrt: self) public func slice(lowerBounds: Tensor<Int32>, sizes: Tensor<Int32>) -> Tensor
Declaração
@differentiable(wrt: self) public func slice(lowerBounds: [Int], sizes: [Int]) -> Tensor
Declaração
@differentiable(wrt: self) public subscript(ranges: TensorRangeExpression...) -> Tensor { get set }
Verifica se cada elemento dos
axes
denota um eixoself
e, caso contrário, interrompe o programa com um diagnóstico.Declaração
func ensureValid( axes: Tensor<Int32>, function: StaticString = #function, file: StaticString = #file, line: UInt = #line )
Verifica se cada elemento dos
axes
denota um eixoself
e, caso contrário, interrompe o programa com um diagnóstico.Declaração
func ensureValid( axes: [Int], function: StaticString = #function, file: StaticString = #file, line: UInt = #line )
Verifica se
k
denota um eixoself
e, caso contrário, interrompe o programa com um diagnóstico.Declaração
func ensureValid( axis k: Int, function: StaticString = #function, file: StaticString = #file, line: UInt = #line )
Declaração
public init<BatchSamples: Collection>(collating samples: BatchSamples) where BatchSamples.Element == Self
Cria um tensor com a forma especificada e um valor escalar único e repetido.
Declaração
@available(*, deprecated, renamed: "init(repeating:shape:﹚") public init(shape: TensorShape, repeating repeatedValue: Scalar)
Parâmetros
shape
As dimensões do tensor.
repeatedValue
O valor escalar a ser repetido.
Cria um tensor com a forma especificada e um valor escalar único e repetido.
Declaração
@differentiable public init( repeating repeatedValue: Scalar, shape: TensorShape, on device: Device = .default )
Parâmetros
repeatedValue
O valor escalar a ser repetido.
shape
As dimensões do tensor.
Cria um tensor transmitindo o escalar fornecido para uma determinada classificação com todas as dimensões sendo 1.
Declaração
public init(broadcasting scalar: Scalar, rank: Int, on device: Device = .default)
Cria um tensor a partir de uma matriz de tensores (que podem ser escalares).
Declaração
@differentiable public init(_ elements: [Tensor])
Empilha
tensors
, ao longo da dimensãoaxis
, em um novo tensor com classificação um acima do tensor atual e cada tensor emtensors
.Dado que todos
tensors
têm forma[A, B, C]
etensors.count = N
, então:- se
axis == 0
então o tensor resultante terá a forma[N, A, B, C]
. - se
axis == 1
então o tensor resultante terá a forma[A, N, B, C]
. - etc.
Por exemplo:
// '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]]
Este é o oposto de
Tensor.unstacked(alongAxis:)
.Condição prévia
Todos os tensores devem ter a mesma forma.
Condição prévia
axis
deve estar no intervalo[-rank, rank)
, onderank
é a classificação dos tensores fornecidos.Declaração
@differentiable public init(stacking tensors: [Tensor], alongAxis axis: Int = 0)
Parâmetros
tensors
Tensores para empilhar.
axis
Dimensão ao longo da qual empilhar. Valores negativos são envolventes.
Valor de retorno
O tensor empilhado.
- se
Concatena
tensors
ao longo da dimensãoaxis
.Dado que
tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn]
, então o resultado concatenado tem forma[D0, D1, ... Raxis, ...Dn]
, ondeRaxis = sum(Daxis(i))
. Ou seja, os dados dos tensores de entrada são unidos ao longo da dimensão doaxis
.Por exemplo:
// 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]
Observação
Se você estiver concatenando ao longo de um novo eixo, considere usar
Tensor.init(stacking:alongAxis:)
.Condição prévia
Todos os tensores devem ter a mesma classificação e todas as dimensões, exceto
axis
devem ser iguais.Condição prévia
axis
deve estar no intervalo[-rank, rank)
, onderank
é a classificação dos tensores fornecidos.Declaração
@differentiable public init(concatenating tensors: [Tensor], alongAxis axis: Int = 0)
Parâmetros
tensors
Tensores para concatenar.
axis
Dimensão ao longo da qual concatenar. Valores negativos são envolventes.
Valor de retorno
O tensor concatenado.
Substitui elementos deste tensor por
other
nas pistas ondemask
étrue
.Condição prévia
self
eother
devem ter a mesma forma. Seself
eother
forem escalares, entãomask
também deverá ser escalar. Seself
eother
tiverem classificação maior ou igual a1
, entãomask
deve ter a mesma forma queself
ou ser umTensor
1-D tal quemask.scalarCount == self.shape[0]
.Declaração
@differentiable(wrt: (self, other) ) public func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor
Retorna verdadeiro se o tipo escalar físico tiver precisão reduzida.
Atualmente, os tipos escalares físicos de precisão reduzida incluem apenas
BFloat16
.Declaração
public var isReducedPrecision: Bool { get }
Promove um escalar a um tensor com o mesmo dispositivo e precisão do tensor fornecido.
Declaração
@differentiable public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)
Retorna uma cópia de
self
convertida para o tipo escalar físicoBFloat16
.Declaração
public var toReducedPrecision: `Self` { get }
Retorna uma cópia de
self
convertida em tipo escalar físicoScalar
.Declaração
public var toFullPrecision: `Self` { get }
O número de dimensões do
Tensor
.Declaração
public var rank: Int { get }
A forma do
Tensor
.Declaração
public var shape: TensorShape { get }
O número de escalares no
Tensor
.Declaração
public var scalarCount: Int { get }
A classificação do tensor, representada como
Tensor<Int32>
.Declaração
public var rankTensor: Tensor<Int32> { get }
As dimensões do tensor, representadas como
Tensor<Int32>
.Declaração
public var shapeTensor: Tensor<Int32> { get }
O número de escalares no tensor, representado como
Tensor<Int32>
.Declaração
public var scalarCountTensor: Tensor<Int32> { get }
Retorna
true
serank
for igual a 0 efalse
caso contrário.Declaração
public var isScalar: Bool { get }
Retorna o elemento escalar único se
rank
for igual a 0 enil
caso contrário.Declaração
public var scalar: Scalar? { get }
Remodele para escalar.
Condição prévia
O tensor possui exatamente um escalar.Declaração
@differentiable public func scalarized() -> Scalar
Declaração
public var array: ShapedArray<Scalar> { get }
Declaração
@differentiable public var scalars: [Scalar] { get }
Cria um tensor 0-D a partir de um valor escalar.
Declaração
@differentiable public init(_ value: Scalar, on device: Device = .default)
Cria um tensor 1D a partir de escalares.
Declaração
@differentiable public init(_ scalars: [Scalar], on device: Device = .default)
Cria um tensor 1D a partir de escalares.
Declaração
public init<C: Collection>( _ vector: C, on device: Device = .default ) where C.Element == Scalar
Cria um tensor com a forma especificada e escalares contíguos em ordem de linha maior.
Condição prévia
O produto das dimensões da forma deve ser igual ao número de escalares.Declaração
@differentiable public init(shape: TensorShape, scalars: [Scalar], on device: Device = .default)
Parâmetros
shape
A forma do tensor.
scalars
O conteúdo escalar do tensor.
Cria um tensor com a forma especificada e escalares contíguos em ordem de linha maior.
Condição prévia
O produto das dimensões da forma deve ser igual ao número de escalares.Declaração
public init( shape: TensorShape, scalars: UnsafeBufferPointer<Scalar>, on device: Device = .default )
Parâmetros
shape
A forma do tensor.
scalars
O conteúdo escalar do tensor.
Cria um tensor com a forma especificada e escalares contíguos em ordem de linha maior.
Condição prévia
O produto das dimensões da forma deve ser igual ao número de escalares.Cria um tensor com a forma especificada e escalares contíguos em ordem de linha maior.
Condição prévia
O produto das dimensões da forma deve ser igual ao número de escalares.Declaração
public init<C: Collection>( shape: TensorShape, scalars: C, on device: Device = .default ) where C.Element == Scalar
Parâmetros
shape
A forma do tensor.
scalars
O conteúdo escalar do tensor.
O tipo dos elementos de um literal de matriz.
Declaração
public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
Cria um tensor inicializado com os elementos fornecidos.
Declaração
public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)
Uma representação textual do tensor.
Observação
usefullDescription
para uma descrição não impressa mostrando todos os escalares.Declaração
public var description: String { get }
Uma representação textual do tensor. Retorna uma descrição resumida se
summarize
for verdadeiro e a contagem de elementos exceder duas vezesedgeElementCount
.Declaração
public func description( lineWidth: Int = 80, edgeElementCount: Int = 3, summarizing: Bool = false ) -> String
Parâmetros
lineWidth
A largura máxima da linha para impressão. Usado para determinar o número de escalares a serem impressos por linha.
edgeElementCount
O número máximo de elementos a serem impressos antes e depois do resumo por meio de reticências (
...
).summarizing
Se verdadeiro, resumirá a descrição se a contagem de elementos exceder duas vezes
edgeElementCount
.Uma representação textual completa e não impressa do tensor, mostrando todos os escalares.
Declaração
public var fullDescription: String { get }
Declaração
public var playgroundDescription: Any { get }
Declaração
public var customMirror: Mirror { get }
As anotações que descrevem este tensor.
Declaração
public var annotations: String { get }
Um alias para anotações.
Declaração
public var summary: String { get }
Declaração
public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?)
Declaração
public init<C: RandomAccessCollection>( _handles: C ) where C.Element: _AnyTensorHandle
Declaração
public init(_ array: ShapedArray<Scalar>, on device: Device = .default)
Declaração
init(_xla: XLATensor)
Declaração
init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)
Declaração
var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }
Declaração
var xlaTensor: XLATensor { get }
Declaração
@differentiable(wrt: self) public func unbroadcasted(toShape otherShape: Tensor<Int32>) -> Tensor
Declaração
@differentiable(wrt: self) public func unbroadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar
Declaração
@differentiable(wrt: self) public func unbroadcasted(to shape: TensorShape) -> Tensor
Um modo que determina como um tensor é preenchido.
Declaração
public enum PaddingMode
Retorna um tensor preenchido com constante de acordo com os tamanhos de preenchimento especificados.
Declaração
@differentiable(wrt: self) public func padded(forSizes sizes: [(before: Int, after: Int)], with value: Scalar = 0) -> Tensor
Retorna um tensor preenchido de acordo com os tamanhos e modo de preenchimento especificados.
Declaração
@differentiable(wrt: self) public func padded(forSizes sizes: [(before: Int, after: Int)], mode: PaddingMode) -> Tensor
Retorna um tensor de escalares booleanos calculando
lhs < rhs
elemento a elemento.Declaração
public static func .< (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs <= rhs
elemento a elemento.Declaração
public static func .<= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs > rhs
elemento a elemento.Declaração
public static func .> (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs >= rhs
elemento a elemento.Declaração
public static func .>= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs < rhs
elemento a elemento.Observação
.<
suporta transmissão.Declaração
public static func .< (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs <= rhs
elemento a elemento.Observação
.<=
suporta transmissão.Declaração
public static func .<= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs > rhs
elemento a elemento.Observação
.>
suporta transmissão.Declaração
public static func .> (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs >= rhs
elemento a elemento.Observação
.>=
suporta transmissão.Declaração
public static func .>= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs < rhs
elemento a elemento.Observação
.<
suporta transmissão.Declaração
public static func .< (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs <= rhs
elemento a elemento.Observação
.<=
suporta transmissão.Declaração
public static func .<= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs > rhs
elemento a elemento.Observação
.>
suporta transmissão.Declaração
public static func .> (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs >= rhs
elemento a elemento.Observação
.>=
suporta transmissão.Declaração
public static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs == rhs
elemento a elemento.Observação
.==
suporta transmissão.Declaração
public static func .== (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs != rhs
elemento a elemento.Observação
.!=
suporta transmissão.Declaração
public static func .!= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs == rhs
elemento a elemento.Observação
.==
suporta transmissão.Declaração
public static func .== (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs != rhs
elemento a elemento.Observação
.!=
suporta transmissão.Declaração
public static func .!= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs == rhs
elemento a elemento.Observação
.==
suporta transmissão.Declaração
public static func .== (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
Retorna um tensor de escalares booleanos calculando
lhs != rhs
elemento a elemento.Observação
.!=
suporta transmissão.Declaração
public static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
Retorna um tensor de valores booleanos indicando se os elementos de
self
são aproximadamente iguais aos deother
.Condição prévia
self
eother
devem ter a mesma forma.Declaração
public func elementsAlmostEqual( _ other: Tensor, tolerance: Scalar = Scalar.ulpOfOne.squareRoot() ) -> Tensor<Bool>
Retorna
true
se todos os elementos deself
forem aproximadamente iguais aos deother
.Condição prévia
self
eother
devem ter a mesma forma.Declaração
public func isAlmostEqual( to other: Tensor, tolerance: Scalar = Scalar.ulpOfOne.squareRoot() ) -> Bool
Executa uma soma de réplica cruzada para este tensor. A mesma soma de réplicas cruzadas deve acontecer em cada um dos outros dispositivos participantes da soma.
Declaração
public mutating mutating func crossReplicaSum(_ scale: Double)
Declaração
@derivative init(repeating: shape)
Execute uma conversão de tipo elemento a elemento de um tensor
Bool
.Declaração
public init(_ other: Tensor<Bool>)
Execute uma conversão elemento a elemento de outro
Tensor
.Declaração
@differentiable public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar
Declaração
@derivative init(_: <<error type>>)
Declaração
@derivative init(stacking: alongAxis)
Declaração
@derivative init(concatenating: alongAxis)
Cria um tensor com todos os escalares definidos como zero.
Declaração
public init(zeros shape: TensorShape, on device: Device = .default)
Parâmetros
shape
Forma do tensor.
Cria um tensor com todos os escalares definidos como um.
Declaração
public init(ones shape: TensorShape, on device: Device = .default)
Parâmetros
shape
Forma do tensor.
Cria um tensor com todos os escalares definidos como zero que tem a mesma forma e tipo do tensor fornecido.
Declaração
public init(zerosLike other: Tensor)
Parâmetros
other
Tensor cuja forma e tipo de dados serão usados.
Cria um tensor com todos os escalares definidos para um que tenha a mesma forma e tipo do tensor fornecido.
Declaração
public init(onesLike other: Tensor)
Parâmetros
other
Tensor cuja forma e tipo de dados serão usados.
Cria um tensor 1-D que representa uma sequência de um valor inicial até, mas não incluindo, um valor final, avançando pelo valor especificado.
Declaração
public init( rangeFrom start: Scalar, to end: Scalar, stride: Scalar, on device: Device = .default )
Parâmetros
start
O valor inicial a ser usado para a sequência. Se a sequência contiver algum valor, o primeiro será
start
.end
Um valor final para limitar a sequência.
end
nunca é um elemento da sequência resultante.stride
A quantidade a ser executada em cada iteração.
stride
deve ser positivo.Cria um tensor 1-D que representa uma sequência de um valor inicial até, mas não incluindo, um valor final, avançando pelo valor especificado.
Declaração
public init(rangeFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, stride: Tensor<Scalar>)
Parâmetros
start
O valor inicial a ser usado para a sequência. Se a sequência contiver algum valor, o primeiro será
start
.end
Um valor final para limitar a sequência.
end
nunca é um elemento da sequência resultante.stride
A quantidade a ser executada em cada iteração.
stride
deve ser positivo.Cria um tensor one-hot em determinados índices. Os locais representados pelos
indices
assumem valoronValue
(1
por padrão), enquanto todos os outros locais assumem valoroffValue
(0
por padrão). Se osindices
de entrada forem de classificaçãon
, o novo tensor terá classificaçãon+1
. O novo eixo é criado noaxis
da dimensão (por padrão, o novo eixo é anexado no final).Se
indices
for escalar, a forma do novo tensor será um vetor de comprimentodepth
.Se
indices
forem um vetor defeatures
de comprimento, a forma de saída será: recursos x profundidade, se eixo == -1 profundidade x recursos, se eixo == 0Se
indices
forem uma matriz (lote) com forma[batch, features]
, a forma de saída será: lote x recursos x profundidade, se eixo == -1 lote x profundidade x recursos, se eixo == 1 profundidade x lote x recursos , se eixo == 0Declaração
public init( oneHotAtIndices indices: Tensor<Int32>, depth: Int, onValue: Scalar = 1, offValue: Scalar = 0, axis: Int = -1 )
Parâmetros
indices
Um
Tensor
de índices.depth
Um escalar que define a profundidade de uma dimensão quente.
onValue
Um escalar que define o valor no local referido por algum índice em
indices
.offValue
Um escalar que define o valor em um local que não é referido por nenhum índice em
indices
.axis
O eixo a ser preenchido. O padrão é
-1
, um novo eixo mais interno.
Cria um tensor 1-D que representa uma sequência de um valor inicial até um valor final inclusive, espaçado uniformemente para gerar o número de valores especificados.
Declaração
public init( linearSpaceFrom start: Scalar, to end: Scalar, count: Int, on device: Device = .default )
Parâmetros
start
O valor inicial a ser usado para a sequência. Se a sequência contiver algum valor, o primeiro será
start
.end
Um valor final para limitar a sequência.
end
é o último elemento da sequência resultante.count
O número de valores na sequência resultante.
count
deve ser positiva.Cria um tensor 1-D que representa uma sequência de um valor inicial até um valor final inclusive, espaçado uniformemente para gerar o número de valores especificados.
Condição prévia
start
,to
ecount
devem ser tensores contendo um único valor escalar.Declaração
public init(linearSpaceFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, count: Tensor<Int32>)
Parâmetros
start
O valor inicial a ser usado para a sequência. Se a sequência contiver algum valor, o primeiro será
start
.end
Um valor final para limitar a sequência.
end
é o último elemento da sequência resultante.count
O número de valores na sequência resultante.
count
deve ser positiva.
Cria um tensor com a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição uniforme entre
lowerBound
eupperBound
.Declaração
public init( randomUniform shape: TensorShape, lowerBound: Tensor<Scalar>? = nil, upperBound: Tensor<Scalar>? = nil, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
Parâmetros
shape
As dimensões do tensor.
lowerBound
O limite inferior da distribuição.
upperBound
O limite superior da distribuição.
seed
O valor da semente.
Cria um tensor com a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição uniforme entre
lowerBound
eupperBound
.Declaração
public init( randomUniform shape: TensorShape, lowerBound: Tensor<Scalar>? = nil, upperBound: Tensor<Scalar>? = nil, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
Parâmetros
shape
As dimensões do tensor.
lowerBound
O limite inferior da distribuição.
upperBound
O limite superior da distribuição.
seed
O valor da semente.
Cria um tensor com a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição normal.
Declaração
public init( randomNormal shape: TensorShape, mean: Tensor<Scalar>? = nil, standardDeviation: Tensor<Scalar>? = nil, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
Parâmetros
shape
As dimensões do tensor.
mean
A média da distribuição.
standardDeviation
O desvio padrão da distribuição.
seed
O valor da semente.
Cria um tensor com a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição Normal truncada.
Declaração
public init( randomTruncatedNormal shape: TensorShape, mean: Tensor<Scalar>? = nil, standardDeviation: Tensor<Scalar>? = nil, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
Parâmetros
shape
As dimensões do tensor.
mean
A média da distribuição.
standardDeviation
O desvio padrão da distribuição.
seed
O valor da semente.
Cria um tensor extraindo amostras de uma distribuição categórica.
Declaração
public init<T: TensorFlowFloatingPoint>( randomCategorialLogits: Tensor<T>, sampleCount: Int32, seed: TensorFlowSeed = Context.local.randomSeed )
Parâmetros
randomCategorialLogits
Tensor 2-D com forma
[batchSize, classCount]
. Cada fatia[i, :]
representa as probabilidades de log não normalizadas para todas as classes.sampleCount
0-D. Número de amostras independentes a serem extraídas para cada fatia de linha.
seed
O valor da semente.
Valor de retorno
Tensor 2-D com forma
[batchSize, sampleCount]
. Cada fatia[i, :]
contém os rótulos de classe desenhados com intervalo[0, classCount)
.
Cria um tensor com a forma especificada executando a inicialização uniforme Glorot (Xavier).
Ele extrai amostras aleatórias de uma distribuição uniforme entre
-limit
elimit
gerada pelo gerador de números aleatórios padrão, ondelimit
ésqrt(6 / (fanIn + fanOut))
efanIn
/fanOut
representa o número de recursos de entrada e saída multiplicados pelo receptivo tamanho do campo.Referência: “Compreendendo a dificuldade de treinar redes neurais feedforward profundas”
Declaração
public init( glorotUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
Parâmetros
shape
As dimensões do tensor.
seed
O valor da semente.
Cria um tensor com a forma especificada executando a inicialização normal Glorot (Xavier).
Ele extrai amostras aleatórias de uma distribuição normal truncada centrada em
0
com desvio padrãosqrt(2 / (fanIn + fanOut))
gerado pelo gerador de números aleatórios padrão, ondefanIn
/fanOut
representam o número de recursos de entrada e saída multiplicados pelo campo receptivo tamanho.Referência: “Compreendendo a dificuldade de treinar redes neurais feedforward profundas”
Declaração
public init( glorotNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
Parâmetros
shape
As dimensões do tensor.
seed
O valor da semente.
Cria um tensor com a forma especificada executando a inicialização uniforme He (Kaiming).
Ele extrai amostras aleatórias de uma distribuição uniforme entre
-limit
elimit
gerada pelo gerador de números aleatórios padrão, ondelimit
ésqrt(6 / fanIn)
efanIn
representa o número de recursos de entrada multiplicados pelo tamanho do campo receptivo.Referência: “Aprofundando-se nos retificadores: superando o desempenho de nível humano na classificação ImageNet”
Declaração
public init( heUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
Parâmetros
shape
As dimensões do tensor.
seed
O valor da semente.
Cria um tensor com a forma especificada executando a inicialização normal He (Kaiming).
Ele extrai amostras aleatórias de uma distribuição normal truncada centrada em
0
com desvio padrãosqrt(2 / fanIn))
gerada pelo gerador de números aleatórios padrão, ondefanIn
representa o número de recursos de entrada multiplicados pelo tamanho do campo receptivo.Referência: “Aprofundando-se nos retificadores: superando o desempenho de nível humano na classificação ImageNet”
Declaração
public init( heNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
Parâmetros
shape
As dimensões do tensor.
seed
O valor da semente.
Cria um tensor com a forma especificada executando a inicialização uniforme LeCun.
Ele extrai amostras aleatórias de uma distribuição uniforme entre
-limit
elimit
gerada pelo gerador de números aleatórios padrão, ondelimit
ésqrt(3 / fanIn)
efanIn
representa o número de recursos de entrada multiplicados pelo tamanho do campo receptivo.Referência: “BackProp Eficiente”
Declaração
public init( leCunUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
Parâmetros
shape
As dimensões do tensor.
seed
O valor da semente.
Cria um tensor com a forma especificada executando a inicialização normal do LeCun.
Ele extrai amostras aleatórias de uma distribuição normal truncada centrada em
0
com desvio padrãosqrt(1 / fanIn)
gerado pelo gerador de números aleatórios padrão, ondefanIn
representa o número de recursos de entrada multiplicados pelo tamanho do campo receptivo.Referência: “BackProp Eficiente”
Declaração
public init( leCunNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
Parâmetros
shape
As dimensões do tensor.
seed
O valor da semente.
Cria uma matriz ou tensor ortogonal.
Se a forma do tensor a inicializar for bidimensional, ele é inicializado com uma matriz ortogonal obtida a partir da decomposição QR de uma matriz de números aleatórios extraída de uma distribuição normal. Se a matriz tiver menos linhas do que colunas, a saída terá linhas ortogonais. Caso contrário, a saída terá colunas ortogonais.
Se a forma do tensor a ser inicializado for mais que bidimensional, uma matriz de forma
[shape[0] * ... * shape[rank - 2], shape[rank - 1]]
será inicializada. A matriz é subsequentemente remodelada para fornecer um tensor com a forma desejada.Declaração
public init( orthogonal shape: TensorShape, gain: Tensor<Scalar> = Tensor<Scalar>(1), seed: TensorFlowSeed = Context.local.randomSeed )
Parâmetros
shape
A forma do tensor.
gain
Um fator multiplicativo a ser aplicado ao tensor ortogonal.
seed
Uma tupla de dois inteiros para propagar o gerador de números aleatórios.
Retorna a parte diagonal [em lote] de um tensor [em lote]. Para a instância do tensor da forma
[..., M, N]
, a saída é um tensor da forma[..., K]
, ondeK
é igualmin(N, M)
.Por exemplo:
// 't' is [[1, 0, 0, 0] // [0, 2, 0, 0] // [0, 0, 3, 0] // [0, 0, 0, 4]] t.diagonalPart() // [1, 2, 3, 4]
Declaração
@differentiable public func diagonalPart() -> Tensor
Constrói uma matriz diagonal [em lote]. Para a instância do tensor da forma
[..., M]
, a saída é um tensor da forma[..., M, M]
.Por exemplo:
// 't' is [1, 2, 3, 4] t.diagonal() // [[1, 0, 0, 0] // [0, 2, 0, 0] // [0, 0, 3, 0] // [0, 0, 0, 4]]
Declaração
@differentiable public func diagonal() -> Tensor
Retorna
self
com novos valores diagonais, visto queself
é uma matriz opcionalmente em lote.O tensor retornado tem a mesma forma e valores que
self
, exceto pelas diagonais especificadas das matrizes mais internas que são substituídas pelos valores emdiagonal
.Diagonal do parâmetro: um tensor com
rank - 1
representando os novos valores diagonais.Declaração
public func withDiagonal(_ diagonal: Tensor<Scalar>) -> Tensor
Declaração
@differentiable(wrt: self) public func bandPart(_ subdiagonalCount: Int, _ superdiagonalCount: Int) -> Tensor
Retorna uma cópia de um tensor mais interno definido por limites de banda central. A saída é um tensor do mesmo formato da instância
[..., :, :]
.Por exemplo:
// '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]]
Declaração
@differentiable public func bandPart(subdiagonalCount: Int, superdiagonalCount: Int) -> Tensor
Parâmetros
subdiagonalCount
O número de subdiagonais a serem mantidas. Se negativo, mantenha todo o triângulo inferior.
superdiagonalCount
O número de superdiagonais a serem mantidas. Se negativo, mantenha todo o triângulo superior.
Retorna a decomposição QR de cada matriz interna no tensor, um tensor com matrizes ortogonais internas
q
e um tensor com matrizes triangulares superiores internasr
, de modo que o tensor seja igual amatmul(q, r)
.Declaração
public func qrDecomposition(fullMatrices: Bool = false) -> ( q: Tensor<Scalar>, r: Tensor<Scalar> )
Parâmetros
fullMatrices
Se
true
, calculeq
er
em tamanho real. Caso contrário, calcule apenas as colunasmin(shape[rank - 1], shape[rank - 2])
iniciais deq
.Retorna a decomposição de valor singular de
self
, dado queself
é uma matriz opcionalmente em lote.A decomposição de valor singular (SVD) da matriz
self
opcionalmente em lote são valoress
,u
ev
, tais que:self[..., :, :] = u[..., :, :] • s[..., :, :].diagonal() • v[..., :, :].transposed()`
self
must be a tensor with shape
[…, M, N]. Let
K = min(M, N)`.Condição prévia
self
deve ser um tensor com forma[..., M, N]
.Declaração
public func svd(computeUV: Bool = true, fullMatrices: Bool = false) -> ( s: Tensor<Scalar>, u: Tensor<Scalar>?, v: Tensor<Scalar>? )
Parâmetros
computeUV
Se
true
, os vetores singulares esquerdo e direito serão calculados e retornados comou
ev
, respectivamente. Sefalse
, valoresnil
serão retornados comou
ev
.fullMatrices
Se
true
,u
ev
respectivamente têm formas[..., M, M]
e[..., N, N]
. Sefalse
,u
ev
respectivamente têm formas[..., M, K]
e[..., K, N]
. Ignorado quandocomputeUV
é falso.Valor de retorno
- s: Os valores singulares, com forma
[..., K]
. Dentro de cada vetor, os valores singulares são classificados em ordem decrescente. - você: Os vetores singulares à esquerda.
- v: Os vetores singulares à direita.
- s: Os valores singulares, com forma
A raiz quadrada de
x
.Para tipos reais, se
x
for negativo o resultado será.nan
. Para tipos complexos existe um corte de ramo no eixo real negativo.Declaração
@differentiable public static func sqrt(_ x: `Self`) -> Tensor<Scalar>
O cosseno de
x
, interpretado como um ângulo em radianos.Declaração
@differentiable public static func cos(_ x: `Self`) -> Tensor<Scalar>
O seno de
x
, interpretado como um ângulo em radianos.Declaração
@differentiable public static func sin(_ x: `Self`) -> Tensor<Scalar>
A tangente de
x
, interpretada como um ângulo em radianos.Declaração
@differentiable public static func tan(_ x: `Self`) -> Tensor<Scalar>
O cosseno inverso de
x
em radianos.Declaração
@differentiable public static func acos(_ x: `Self`) -> Tensor<Scalar>
O seno inverso de
x
em radianos.Declaração
@differentiable public static func asin(_ x: `Self`) -> Tensor<Scalar>
A tangente inversa de
x
em radianos.Declaração
@differentiable public static func atan(_ x: `Self`) -> Tensor<Scalar>
O cosseno hiperbólico de
x
.Declaração
@differentiable public static func cosh(_ x: `Self`) -> Tensor<Scalar>
O seno hiperbólico de
x
.Declaração
@differentiable public static func sinh(_ x: `Self`) -> Tensor<Scalar>
A tangente hiperbólica de
x
.Declaração
@differentiable public static func tanh(_ x: `Self`) -> Tensor<Scalar>
O cosseno hiperbólico inverso de
x
.Declaração
@differentiable public static func acosh(_ x: `Self`) -> Tensor<Scalar>
O seno hiperbólico inverso de
x
.Declaração
@differentiable public static func asinh(_ x: `Self`) -> Tensor<Scalar>
A tangente hiperbólica inversa de
x
.Declaração
@differentiable public static func atanh(_ x: `Self`) -> Tensor<Scalar>
A função exponencial aplicada a
x
oue**x
.Declaração
@differentiable public static func exp(_ x: `Self`) -> Tensor<Scalar>
Dois elevados à potência
x
.Declaração
@differentiable public static func exp2(_ x: `Self`) -> Tensor<Scalar>
Dez elevado à potência
x
.Declaração
@differentiable public static func exp10(_ x: `Self`) -> Tensor<Scalar>
exp(x) - 1
avaliado de forma a preservar a precisão próxima de zero.Declaração
@differentiable public static func expm1(_ x: `Self`) -> Tensor<Scalar>
O logaritmo natural de
x
.Declaração
@differentiable public static func log(_ x: `Self`) -> Tensor<Scalar>
O logaritmo de base dois de
x
.Declaração
@differentiable public static func log2(_ x: `Self`) -> Tensor<Scalar>
O logaritmo de base dez de
x
.Declaração
@differentiable public static func log10(_ x: `Self`) -> Tensor<Scalar>
log(1 + x)
avaliado de forma a preservar a precisão próxima de zero.Declaração
@differentiable public static func log1p(_ x: `Self`) -> Tensor<Scalar>
exp(y log(x))
calculado sem perda de precisão intermediária.Para tipos reais, se
x
for negativo o resultado será NaN, mesmo quey
tenha um valor integral. Para tipos complexos, há um corte de ramo no eixo real negativo.Declaração
@differentiable public static func pow(_ x: `Self`, _ y: `Self`) -> Tensor<Scalar>
x
elevado àn
potência.O produto de
n
cópias dex
.Declaração
@differentiable public static func pow(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
A
n
raiz dex
.Para tipos reais, se
x
for negativo enn
par, o resultado será NaN. Para tipos complexos, há um corte de ramo ao longo do eixo real negativo.Declaração
@differentiable public static func root(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
Declaração
public typealias VectorSpaceScalar = Float
Declaração
public func scaled(by scale: Float) -> Tensor<Scalar>
Declaração
public func adding(_ scalar: Float) -> Tensor<Scalar>
Declaração
public func subtracting(_ scalar: Float) -> Tensor<Scalar>
Adiciona o escalar a cada escalar do tensor e produz a soma.
Declaração
@differentiable public static func + (lhs: Scalar, rhs: Tensor) -> Tensor
Adiciona o escalar a cada escalar do tensor e produz a soma.
Declaração
@differentiable public static func + (lhs: Tensor, rhs: Scalar) -> Tensor
Subtrai o escalar de cada escalar do tensor e produz a diferença.
Declaração
@differentiable public static func - (lhs: Scalar, rhs: Tensor) -> Tensor
Subtrai o escalar de cada escalar do tensor e produz a diferença
Declaração
@differentiable public static func - (lhs: Tensor, rhs: Scalar) -> Tensor
Adiciona dois tensores e armazena o resultado na variável do lado esquerdo.
Observação
+=
suporta transmissão.Declaração
public static func += (lhs: inout Tensor, rhs: Tensor)
Adiciona o escalar a cada escalar do tensor e armazena o resultado na variável do lado esquerdo.
Declaração
public static func += (lhs: inout Tensor, rhs: Scalar)
Subtrai o segundo tensor do primeiro e armazena o resultado na variável do lado esquerdo.
Observação
-=
suporta transmissão.Declaração
public static func -= (lhs: inout Tensor, rhs: Tensor)
Subtrai o escalar de cada escalar do tensor e armazena o resultado na variável do lado esquerdo.
Declaração
public static func -= (lhs: inout Tensor, rhs: Scalar)
Retorna o tensor produzido pela multiplicação dos dois tensores.
Observação
*
suporta transmissão.Declaração
@differentiable public static func * (lhs: Tensor, rhs: Tensor) -> Tensor
Retorna o tensor multiplicando-o por cada escalar do tensor.
Declaração
@differentiable public static func * (lhs: Scalar, rhs: Tensor) -> Tensor
Multiplica o escalar por cada escalar do tensor e produz o produto.
Declaração
@differentiable public static func * (lhs: Tensor, rhs: Scalar) -> Tensor
Multiplica dois tensores e armazena o resultado na variável do lado esquerdo.
Observação
*=
suporta transmissão.Declaração
public static func *= (lhs: inout Tensor, rhs: Tensor)
Multiplica o tensor pelo escalar, transmitindo o escalar, e armazena o resultado na variável do lado esquerdo.
Declaração
public static func *= (lhs: inout Tensor, rhs: Scalar)
Retorna o quociente da divisão do primeiro tensor pelo segundo.
Observação
/
suporta transmissão.Declaração
@differentiable public static func / (lhs: Tensor, rhs: Tensor) -> Tensor
Retorna o quociente da divisão do escalar pelo tensor, transmitindo o escalar.
Declaração
@differentiable public static func / (lhs: Scalar, rhs: Tensor) -> Tensor
Retorna o quociente da divisão do tensor pelo escalar, transmitindo o escalar.
Declaração
@differentiable public static func / (lhs: Tensor, rhs: Scalar) -> Tensor
Divide o primeiro tensor pelo segundo e armazena o quociente na variável do lado esquerdo.
Declaração
public static func /= (lhs: inout Tensor, rhs: Tensor)
Divide o tensor pelo escalar, transmitindo o escalar, e armazena o quociente na variável do lado esquerdo.
Declaração
public static func /= (lhs: inout Tensor, rhs: Scalar)
Retorna o restante da divisão do primeiro tensor pelo segundo.
Observação
%
suporta transmissão.Declaração
public static func % (lhs: Tensor, rhs: Tensor) -> Tensor
Retorna o restante da divisão do tensor pelo escalar, transmitindo o escalar.
Declaração
public static func % (lhs: Tensor, rhs: Scalar) -> Tensor
Retorna o restante da divisão do escalar pelo tensor, transmitindo o escalar.
Declaração
public static func % (lhs: Scalar, rhs: Tensor) -> Tensor
Divide o primeiro tensor pelo segundo e armazena o restante na variável do lado esquerdo.
Declaração
public static func %= (lhs: inout Tensor, rhs: Tensor)
Divide o tensor pelo escalar e armazena o restante na variável do lado esquerdo.
Declaração
public static func %= (lhs: inout Tensor, rhs: Scalar)
Retorna
!self
elemento a elemento.Declaração
public func elementsLogicalNot() -> Tensor
Retorna
self && other
elemento a elemento.Observação
&&
suporta transmissão.Declaração
public func elementsLogicalAnd(_ other: Tensor) -> Tensor
Retorna
self && other
elemento a elemento, transmitindoother
.Declaração
public func elementsLogicalAnd(_ other: Scalar) -> Tensor
Retorna a
self || other
elemento.Declaração
public func elementsLogicalOr(_ other: Tensor) -> Tensor
Retorna a
self || other
elemento a elemento, transmitindoother
.Declaração
public func elementsLogicalOr(_ other: Scalar) -> Tensor
Retorna
max(min(self, max), min)
.Declaração
@differentiable public func clipped(min: Tensor, max: Tensor) -> Tensor
Retorna
max(min(self, max), min)
.Declaração
@differentiable(wrt: (self, min) ) public func clipped(min: Tensor, max: Scalar) -> Tensor
Retorna
max(min(self, max), min)
.Declaração
@differentiable(wrt: (self, max) ) public func clipped(min: Scalar, max: Tensor) -> Tensor
Retorna
max(min(self, max), min)
.Declaração
@differentiable(wrt: self) public func clipped(min: Scalar, max: Scalar) -> Tensor
Retorna a negação do tensor especificado elemento a elemento.
Declaração
@differentiable public prefix static func - (rhs: Tensor) -> Tensor
Declaração
@differentiable(wrt: self) public func squared() -> Tensor
Retorna um tensor booleano indicando quais elementos de
x
são finitos.Declaração
public var isFinite: Tensor<Bool> { get }
Retorna um tensor booleano indicando quais elementos de
x
são infinitos.Declaração
public var isInfinite: Tensor<Bool> { get }
Retorna um tensor booleano indicando quais elementos de
x
têm valor NaN.Declaração
public var isNaN: Tensor<Bool> { get }
Retorna
true
se todos os escalares forem iguais atrue
. Caso contrário, retornafalse
.Declaração
public func all() -> Bool
Retorna
true
se algum escalar for igual atrue
. Caso contrário, retornafalse
.Declaração
public func any() -> Bool
Executa uma operação AND lógica ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
public func all(squeezingAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Executa uma operação AND lógica ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
public func any(squeezingAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Executa uma operação AND lógica ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
public func all(alongAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Executa uma operação lógica OR ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
public func any(alongAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Declaração
@differentiable public func min() -> Tensor
Declaração
@differentiable public func max() -> Tensor
Retorna os valores máximos ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func max(squeezingAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna os valores máximos ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func max(squeezingAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna os valores máximos ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func max(squeezingAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna os valores mínimos ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func min(squeezingAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna os valores mínimos ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func min(squeezingAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna os valores mínimos ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func min(squeezingAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna os índices dos valores máximos ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
public func argmax(squeezingAxis axis: Int) -> Tensor<Int32>
Parâmetros
axes
As dimensões a reduzir.
Retorna os índices dos valores mínimos ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
public func argmin(squeezingAxis axis: Int) -> Tensor<Int32>
Parâmetros
axes
As dimensões a reduzir.
Retorna o mínimo ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func min(alongAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o mínimo ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func min(alongAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o mínimo ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func min(alongAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o mínimo ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func max(alongAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o mínimo ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func max(alongAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o mínimo ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func max(alongAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o índice do valor máximo dos escalares achatados.
Declaração
public func argmax() -> Tensor<Int32>
Retorna o índice do valor mínimo dos escalares achatados.
Declaração
public func argmin() -> Tensor<Int32>
Retorna a soma ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank...rank
.Declaração
@differentiable(wrt: self) public func sum(squeezingAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a soma ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank...rank
.Declaração
@differentiable(wrt: self) public func sum(squeezingAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a soma ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank...rank
.Declaração
@differentiable(wrt: self) public func sum(squeezingAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Declaração
@differentiable(wrt: self) public func sum() -> Tensor
Retorna a soma ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func sum(alongAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a soma ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func sum(alongAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a soma ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func sum(alongAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o produto ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank...rank
.Declaração
@differentiable(wrt: self) public func product(squeezingAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o produto ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank...rank
.Declaração
@differentiable(wrt: self) public func product(squeezingAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o produto ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank...rank
.Declaração
@differentiable(wrt: self) public func product(squeezingAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Declaração
@differentiable(wrt: self) public func product() -> Tensor
Retorna o produto ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
public func product(alongAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o produto ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
public func product(alongAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o produto ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
public func product(alongAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a média aritmética ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank...rank
.Declaração
@differentiable(wrt: self) public func mean(squeezingAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a média aritmética ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank...rank
.Declaração
@differentiable(wrt: self) public func mean(squeezingAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a média aritmética ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank...rank
.Declaração
@differentiable(wrt: self) public func mean(squeezingAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Declaração
@differentiable(wrt: self) public func mean() -> Tensor
Retorna a média aritmética ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func mean(alongAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a média aritmética ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func mean(alongAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a média aritmética ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func mean(alongAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a variação ao longo dos eixos especificados. As dimensões reduzidas são removidas. Não aplica a correção de Bessel.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func variance(squeezingAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a variação ao longo dos eixos especificados. As dimensões reduzidas são removidas. Não aplica a correção de Bessel.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func variance(squeezingAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a variação ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1. Não aplica a correção de Bessel.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func variance(squeezingAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Declaração
@differentiable(wrt: self) public func variance() -> Tensor
Retorna a variação ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1. Não aplica a correção de Bessel.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func variance(alongAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a variação ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1. Não aplica a correção de Bessel.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func variance(alongAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a variação ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor 1. Não aplica a correção de Bessel.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func variance(alongAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a soma cumulativa deste tensor ao longo do eixo especificado. Por padrão, esta função executa uma soma cumulativa inclusiva, o que significa que o primeiro elemento da entrada é idêntico ao primeiro elemento da saída:
Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])
Ao definir o argumento
exclusive
comotrue
, uma soma cumulativa exclusiva é executada:Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])
Ao definir o argumento
reverse
comotrue
, a soma cumulativa é executada na direção oposta:Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) == Tensor<Float>([a + b + c, a + b, a])
Isto é mais eficiente do que reverter separadamente o tensor resultante.
Condição prévia
axis
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func cumulativeSum( alongAxis axis: Int, exclusive: Bool = false, reverse: Bool = false ) -> Tensor
Parâmetros
axis
Eixo ao longo do qual realizar a operação de soma cumulativa.
exclusive
Indica se deve ser realizada uma soma cumulativa exclusiva.
reverse
Indica se a soma cumulativa deve ser executada em ordem inversa.
Valor de retorno
Resultado da operação de soma acumulada.
Retorna a soma cumulativa deste tensor ao longo do eixo especificado. Por padrão, esta função executa uma soma cumulativa inclusiva, o que significa que o primeiro elemento da entrada é idêntico ao primeiro elemento da saída:
Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])
Ao definir o argumento
exclusive
comotrue
, uma soma cumulativa exclusiva é executada:Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])
Ao definir o argumento
reverse
comotrue
, a soma cumulativa é executada na direção oposta:Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) == Tensor<Float>([a + b + c, a + b, a])
Isto é mais eficiente do que reverter separadamente o tensor resultante.
Condição prévia
axis.rank
deve ser0
.Condição prévia
axis
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func cumulativeSum( alongAxis axis: Tensor<Int32>, exclusive: Bool = false, reverse: Bool = false ) -> Tensor
Parâmetros
axis
Eixo ao longo do qual realizar a operação de soma cumulativa.
exclusive
Indica se deve ser realizada uma soma cumulativa exclusiva.
reverse
Indica se a soma cumulativa deve ser executada em ordem inversa.
Valor de retorno
Resultado da operação de soma acumulada.
Retorna o produto cumulativo deste tensor ao longo do eixo especificado. Por padrão, esta função executa um produto cumulativo inclusivo, o que significa que o primeiro elemento da entrada é idêntico ao primeiro elemento da saída:
Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])
Ao definir o argumento
exclusive
comotrue
, um produto cumulativo exclusivo é executado:Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])
Ao definir o argumento
reverse
comotrue
, o produto cumulativo é executado na direção oposta:Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) == Tensor<Float>([a * b * c, a * b, a])
Isto é mais eficiente do que reverter separadamente o tensor resultante.
Condição prévia
axis
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func cumulativeProduct( alongAxis axis: Int, exclusive: Bool = false, reverse: Bool = false ) -> Tensor
Parâmetros
axis
Eixo ao longo do qual executar a operação de produto cumulativo.
exclusive
Indica se deve ser realizado um produto cumulativo exclusivo.
reverse
Indica se o produto cumulativo deve ser executado na ordem inversa.
Valor de retorno
Resultado da operação cumulativa do produto.
Retorna o produto cumulativo deste tensor ao longo do eixo especificado. Por padrão, esta função executa um produto cumulativo inclusivo, o que significa que o primeiro elemento da entrada é idêntico ao primeiro elemento da saída:
Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])
Ao definir o argumento
exclusive
comotrue
, um produto cumulativo exclusivo é executado:Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])
Ao definir o argumento
reverse
comotrue
, o produto cumulativo é executado na direção oposta:Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) == Tensor<Float>([a * b * c, a * b, a])
Isto é mais eficiente do que reverter separadamente o tensor resultante.
Condição prévia
axis
deve ter classificação0
.Condição prévia
axis
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func cumulativeProduct( alongAxis axis: Tensor<Int32>, exclusive: Bool = false, reverse: Bool = false ) -> Tensor
Parâmetros
axis
Eixo ao longo do qual executar a operação de produto cumulativo.
exclusive
Indica se deve ser realizado um produto cumulativo exclusivo.
reverse
Indica se o produto cumulativo deve ser executado na ordem inversa.
Valor de retorno
Resultado da operação cumulativa do produto.
Retorna o desvio padrão dos elementos ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor
1
. Não aplica a correção de Bessel.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func standardDeviation(squeezingAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o desvio padrão dos elementos ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor
1
. Não aplica a correção de Bessel.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func standardDeviation(squeezingAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o desvio padrão dos elementos ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor
1
. Não aplica a correção de Bessel.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func standardDeviation(squeezingAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o desvio padrão de todos os elementos neste tensor. Não aplica a correção de Bessel.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func standardDeviation() -> Tensor
Retorna o desvio padrão dos elementos ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor
1
. Não aplica a correção de Bessel.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func standardDeviation(alongAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o desvio padrão dos elementos ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor
1
. Não aplica a correção de Bessel.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func standardDeviation(alongAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna o desvio padrão dos elementos ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor
1
. Não aplica a correção de Bessel.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func standardDeviation(alongAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna
log(exp(self).sum(squeezingAxes: axes))
. As dimensões reduzidas são removidas.Esta função é numericamente mais estável do que calcular
log(exp(self).sum(squeezingAxes: axes))
diretamente. Ele evita overflows causados pelo cálculo daexp
de grandes entradas e underflows causados pelo cálculo dolog
de pequenas entradas.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func logSumExp(squeezingAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna
log(exp(self).sum(squeezingAxes: axes))
. As dimensões reduzidas são removidas.Esta função é numericamente mais estável do que calcular
log(exp(self).sum(squeezingAxes: axes))
diretamente. Ele evita overflows causados pelo cálculo daexp
de grandes entradas e underflows causados pelo cálculo dolog
de pequenas entradas.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func logSumExp(squeezingAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna
log(exp(self).sum(squeezingAxes: axes))
. As dimensões reduzidas são removidas.Esta função é numericamente mais estável do que calcular
log(exp(self).sum(squeezingAxes: axes))
diretamente. Ele evita overflows causados pelo cálculo daexp
de grandes entradas e underflows causados pelo cálculo dolog
de pequenas entradas.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func logSumExp(squeezingAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna
log(exp(self).sum())
. O resultado é um escalar.Esta função é numericamente mais estável do que calcular
log(exp(self).sum())
diretamente. Ele evita overflows causados pelo cálculo daexp
de grandes entradas e underflows causados pelo cálculo dolog
de pequenas entradas.Declaração
@differentiable(wrt: self) public func logSumExp() -> Tensor
Retorna
log(exp(self).sum(alongAxes: axes))
. As dimensões reduzidas são mantidas com valor1
.Esta função é numericamente mais estável do que calcular
log(exp(self).sum(alongAxes: axes))
diretamente. Ele evita overflows causados pelo cálculo daexp
de grandes entradas e underflows causados pelo cálculo dolog
de pequenas entradas.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func logSumExp(alongAxes axes: Tensor<Int32>) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna
log(exp(self).sum(alongAxes: axes))
. As dimensões reduzidas são mantidas com valor1
.Esta função é numericamente mais estável do que calcular
log(exp(self).sum(alongAxes: axes))
diretamente. Ele evita overflows causados pelo cálculo daexp
de grandes entradas e underflows causados pelo cálculo dolog
de pequenas entradas.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func logSumExp(alongAxes axes: [Int]) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna
log(exp(self).sum(alongAxes: axes))
. As dimensões reduzidas são mantidas com valor1
.Esta função é numericamente mais estável do que calcular
log(exp(self).sum(alongAxes: axes))
diretamente. Ele evita overflows causados pelo cálculo daexp
de grandes entradas e underflows causados pelo cálculo dolog
de pequenas entradas.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func logSumExp(alongAxes axes: Int...) -> Tensor
Parâmetros
axes
As dimensões a reduzir.
Retorna a média e a variância deste tensor ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
axes
devem ter classificação1
.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func moments(squeezingAxes axes: Tensor<Int32>) -> Moments<Scalar>
Parâmetros
axes
As dimensões a reduzir.
Retorna a média e a variância deste tensor ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func moments(squeezingAxes axes: [Int]) -> Moments<Scalar>
Parâmetros
axes
As dimensões a reduzir.
Retorna a média e a variância deste tensor ao longo dos eixos especificados. As dimensões reduzidas são removidas.
Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func moments(squeezingAxes axes: Int...) -> Moments<Scalar>
Parâmetros
axes
As dimensões a reduzir.
Retorna a média e a variância dos elementos deste tensor.
Declaração
@differentiable(wrt: self) public func moments() -> Moments<Scalar>
Retorna a média e a variância deste tensor ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor
1
.Condição prévia
axes
devem ter classificação1
.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func moments(alongAxes axes: Tensor<Int32>) -> Moments<Scalar>
Parâmetros
axes
As dimensões a reduzir.
Retorna a média e a variância deste tensor ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor
1
.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func moments(alongAxes axes: [Int]) -> Moments<Scalar>
Parâmetros
axes
As dimensões a reduzir.
Retorna a média e a variância deste tensor ao longo dos eixos especificados. As dimensões reduzidas são mantidas com valor
1
.Condição prévia
Cada valor nosaxes
deve estar no intervalo-rank..<rank
.Declaração
@differentiable(wrt: self) public func moments(alongAxes axes: Int...) -> Moments<Scalar>
Parâmetros
axes
As dimensões a reduzir.
Executa a multiplicação de matrizes entre dois tensores e produz o resultado.
Declaração
@differentiable public static func • (lhs: Tensor, rhs: Tensor) -> Tensor
Declaração
static func vjpInitDeviceAndPrecisionLike( _ value: Scalar, deviceAndPrecisionLike tensor: Tensor ) -> (value: Tensor, pullback: (Tensor) -> (Scalar, Tensor))
Retorna um tensor calculado a partir da normalização em lote da entrada ao longo do eixo especificado.
Especificamente, retorna
(self - mu) / (var + epsilon) * gamma + beta
ondemu
evar
são respectivamente a média e a variância deself
ao longoaxis
.Declaração
@differentiable(wrt: (self, offset, scale) public func batchNormalized( alongAxis axis: Int, offset: Tensor = Tensor(0), scale: Tensor = Tensor(1), epsilon: Scalar = 0.001 ) -> Tensor
Parâmetros
axis
A dimensão do lote.
offset
O deslocamento, também conhecido como beta.
scale
A escala, também conhecida como gama.
epsilon
Um pequeno valor adicionado ao denominador para estabilidade numérica.
Concatena dois tensores ao longo do último eixo.
Declaração
@differentiable public static func concatenate(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
Adiciona dois valores e produz sua soma.
Declaração
@differentiable public static func sum(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
Média de dois valores.
Declaração
@differentiable public static func average(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
Multiplica dois valores.
Declaração
@differentiable public static func multiply(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
Empilhe dois valores.
Declaração
@differentiable public static func stack(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
Declaração
@derivative init(shape: scalars)
Declaração
public static func == (lhs: Tensor, rhs: Tensor) -> Bool
Declaração
public static func != (lhs: Tensor, rhs: Tensor) -> Bool
Declaração
public func encode(to encoder: Encoder) throws
Declaração
public init(from decoder: Decoder) throws
O tensor zero escalar.
Declaração
public static var zero: Tensor { get }
Adiciona dois tensores e produz sua soma.
Observação
+
suporta transmissão.Declaração
@differentiable public static func + (lhs: Tensor, rhs: Tensor) -> Tensor
Subtrai um tensor de outro e produz sua diferença.
Observação
-
suporta transmissão.Declaração
@differentiable public static func - (lhs: Tensor, rhs: Tensor) -> Tensor
O tensor escalar um.
Declaração
public static var one: Tensor { get }
Retorna o recíproco elemento a elemento de
self
.Declaração
public var reciprocal: Tensor { get }
Multiplica dois tensores elemento a elemento e produz seu produto.
Observação
.*
suporta transmissão.Declaração
public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor
Declaração
public typealias TangentVector = Tensor
Declaração
public var zeroTangentVectorInitializer: () -> TangentVector { get }
Adiciona uma anotação.
Nota: Somente X10 é compatível. Para outros back-ends,
self
umodificado é retornado.Declaração
@differentiable(wrt: self) public func annotate(_ annotation: String) -> Tensor<Scalar>
Parâmetros
annotation
A anotação a ser adicionada.
Valor de retorno
O tensor anotado.
Declaração
@derivative func vjpAnnotate(_ annotation: String) -> ( value: Tensor<Scalar>, pullback: (Tensor<Scalar>) -> Tensor<Scalar> )