Tensor

O TensorHandle subjacente.

Descompacta a dimensão fornecida de um tensor de classificação R em vários tensores de classificação (R-1) . Descompacta N tensores deste tensor, fragmentando-o ao longo da dimensão axis , onde N é inferido da forma deste tensor. Por exemplo, dado um tensor com forma [A, B, C, D] :

• Se axis == 0 então o i -ésimo tensor na matriz retornada é a fatia self[i, :, :, :] e cada tensor nessa matriz terá forma [B, C, D] . (Observe que a dimensão descompactada desapareceu, ao contrário de Tensor.split(numSplits:alongAxis) ou Tensor.split(sizes:alongAxis) ).
• Se axis == 1 então o i -ésimo tensor na matriz retornada é o value[:, i, :, :] e cada tensor nessa matriz terá forma [A, C, D] .
• Etc.

Este é o oposto de Tensor.init(stacking:alongAxis:) .

Divide um tensor em vários tensores. O tensor é dividido ao longo axis de dimensão em count de tensores menores. Isso requer que count divida uniformemente shape[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]

Divide um tensor em vários tensores. O tensor é dividido em pedaços sizes.shape[0] . A forma da i -ésima peça tem a mesma forma deste tensor, exceto ao longo axis 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]

Retorna um tensor lado a lado, construído colocando este tensor lado a lado.

Este construtor cria um novo tensor replicando-o multiples vezes. A i 'ésima dimensão do tensor construído possui elementos self.shape[i] * multiples[i] , e os valores deste tensor são replicados multiples[i] vezes ao longo da i 'ésima dimensão. Por exemplo, colocar lado a lado [abcd] por [2] produz [abcdabcd] .

Retorna um tensor lado a lado, construído colocando este tensor lado a lado.

Este construtor cria um novo tensor replicando-o multiples vezes. A i 'ésima dimensão do tensor construído possui elementos self.shape[i] * multiples[i] , e os valores deste tensor são replicados multiples[i] vezes ao longo da i 'ésima dimensão. Por exemplo, colocar lado a lado [abcd] por [2] produz [abcdabcd] .

Remodele para a forma do Tensor especificado.

Remodele para a forma especificada.

Remodele para o Tensor especificado representando uma forma.

Retorne uma cópia do tensor recolhido em um Tensor 1-D, na ordem principal da linha.

Retorna um Tensor de forma expandida, com uma dimensão 1 inserida nos índices de forma especificados.

Retorna um Tensor de forma expandida, com uma dimensão 1 inserida nos índices de forma especificados.

Retorna um Tensor com classificação elevada e dimensão inicial de 1.

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.

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.

Retorna um tensor transposto, com dimensões permutadas na ordem especificada.

Retorna um tensor transposto, com dimensões permutadas na ordem especificada.

Retorna um tensor transposto, com dimensões permutadas na ordem especificada.

Retorna um tensor transposto, com dimensões permutadas na ordem especificada.

Retorna um tensor transposto, com dimensões permutadas na ordem especificada.

Retorna um tensor transposto, com dimensões permutadas na ordem especificada.

Retorna um tensor transposto, com dimensões permutadas em ordem inversa.

Retorna um tensor com dimensões especificadas invertidas.

Retorna um tensor com dimensões especificadas invertidas.

Retorna um tensor com dimensões especificadas invertidas.

Retorna um tensor concatenado ao longo do eixo especificado.

Operador de concatenação.

Retorna um tensor reunindo fatias da entrada em indices ao longo da dimensão do axis

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 e M = indices.rank .

A forma do tensor resultante é: self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...] .

Retorna fatias deste tensor em indices ao longo da dimensão axis , ignorando as primeiras dimensões batchDimensionCount 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)...] .

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 da mask devem corresponder às primeiras K dimensões da forma do tensor . Temos então: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] , onde [i1, ..., iK] é a i ésima entrada true da mask (ordem da linha principal).

O axis pode ser usado com mask 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 às dimensions of the forma do tensor.

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

Transmita para a mesma forma do Tensor especificado.

Extrai uma fatia do tensor definido pelos limites inferior e superior de cada dimensão.

Verifica se cada elemento dos axes denota um eixo self e, caso contrário, interrompe o programa com um diagnóstico.

Verifica se cada elemento dos axes denota um eixo self e, caso contrário, interrompe o programa com um diagnóstico.

Verifica se k denota um eixo self e, caso contrário, interrompe o programa com um diagnóstico.

Cria uma cópia de other no determinado Device .

Cria um tensor com a forma especificada e um valor escalar único e repetido.

Cria um tensor com a forma especificada e um valor escalar único e repetido.

Cria um tensor transmitindo o escalar fornecido para uma determinada classificação com todas as dimensões sendo 1.

Cria um tensor a partir de uma matriz de tensores (que podem ser escalares).

Empilha tensors , ao longo da dimensão axis , em um novo tensor com classificação um acima do tensor atual e cada tensor em tensors .

Dado que todos tensors têm forma [A, B, C] e tensors.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:) .

Concatena tensors ao longo da dimensão axis .

Dado que tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] , então o resultado concatenado tem forma [D0, D1, ... Raxis, ...Dn] , onde Raxis = sum(Daxis(i)) . Ou seja, os dados dos tensores de entrada são unidos ao longo da dimensão do axis .

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]

Substitui elementos deste tensor por other nas pistas onde mask é true .

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 .

Promove um escalar a um tensor com o mesmo dispositivo e precisão do tensor fornecido.

Retorna uma cópia de self convertida para o tipo escalar físico BFloat16 .

Retorna uma cópia de self convertida em tipo escalar físico Scalar .

O número de dimensões do Tensor .

A forma do Tensor .

O número de escalares no Tensor .

A classificação do tensor, representada como Tensor<Int32> .

As dimensões do tensor, representadas como Tensor<Int32> .

O número de escalares no tensor, representado como Tensor<Int32> .

Retorna true se rank for igual a 0 e false caso contrário.

Retorna o elemento escalar único se rank for igual a 0 e nil caso contrário.

Remodele para escalar.

Cria um tensor 0-D a partir de um valor escalar.

Cria um tensor 1D a partir de escalares.

Cria um tensor 1D a partir de escalares.

Cria um tensor com a forma especificada e escalares contíguos em ordem de linha maior.

Cria um tensor com a forma especificada e escalares contíguos em ordem de linha maior.

Cria um tensor com a forma especificada e escalares contíguos em ordem de linha maior.

Cria um tensor com a forma especificada e escalares contíguos em ordem de linha maior.

O tipo dos elementos de um literal de matriz.

Cria um tensor inicializado com os elementos fornecidos.

Uma representação textual do tensor.

Uma representação textual do tensor. Retorna uma descrição resumida se summarize for verdadeiro e a contagem de elementos exceder duas vezes edgeElementCount .

Uma representação textual completa e não impressa do tensor, mostrando todos os escalares.

As anotações que descrevem este tensor.

Um alias para anotações.

Um modo que determina como um tensor é preenchido.

Retorna um tensor preenchido com constante de acordo com os tamanhos de preenchimento especificados.

Retorna um tensor preenchido de acordo com os tamanhos e modo de preenchimento especificados.

Retorna um tensor de escalares booleanos calculando lhs < rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs <= rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs > rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs >= rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs < rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs <= rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs > rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs >= rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs < rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs <= rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs > rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs >= rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs == rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs != rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs == rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs != rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs == rhs elemento a elemento.

Retorna um tensor de escalares booleanos calculando lhs != rhs elemento a elemento.

Retorna um tensor de valores booleanos indicando se os elementos de self são aproximadamente iguais aos de other .

Retorna true se todos os elementos de self forem aproximadamente iguais aos de other .

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.

Execute uma conversão de tipo elemento a elemento de um tensor Bool .

Execute uma conversão elemento a elemento de outro Tensor .

Cria um tensor com todos os escalares definidos como zero.

Cria um tensor com todos os escalares definidos como um.

Cria um tensor com todos os escalares definidos como zero que tem a mesma forma e tipo do tensor fornecido.

Cria um tensor com todos os escalares definidos para um que tenha a mesma forma e tipo do tensor fornecido.

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.

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.

Cria um tensor one-hot em determinados índices. Os locais representados pelos indices assumem valor onValue ( 1 por padrão), enquanto todos os outros locais assumem valor offValue ( 0 por padrão). Se os indices de entrada forem de classificação n , o novo tensor terá classificação n+1 . O novo eixo é criado no axis 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 comprimento depth .

Se indices forem um vetor de features de comprimento, a forma de saída será: recursos x profundidade, se eixo == -1 profundidade x recursos, se eixo == 0

Se 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 == 0

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.

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.

Cria um tensor com a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição uniforme entre lowerBound e upperBound .

Cria um tensor com a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição uniforme entre lowerBound e upperBound .

Cria um tensor com a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição normal.

Cria um tensor com a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição Normal truncada.

Cria um tensor extraindo amostras de uma distribuição categórica.

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 e limit gerada pelo gerador de números aleatórios padrão, onde limit é sqrt(6 / (fanIn + fanOut)) e fanIn / 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”

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ão sqrt(2 / (fanIn + fanOut)) gerado pelo gerador de números aleatórios padrão, onde fanIn / 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”

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 e limit gerada pelo gerador de números aleatórios padrão, onde limit é sqrt(6 / fanIn) e fanIn 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”

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ão sqrt(2 / fanIn)) gerada pelo gerador de números aleatórios padrão, onde fanIn 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”

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 e limit gerada pelo gerador de números aleatórios padrão, onde limit é sqrt(3 / fanIn) e fanIn representa o número de recursos de entrada multiplicados pelo tamanho do campo receptivo.

Referência: “BackProp Eficiente”

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ão sqrt(1 / fanIn) gerado pelo gerador de números aleatórios padrão, onde fanIn representa o número de recursos de entrada multiplicados pelo tamanho do campo receptivo.

Referência: “BackProp Eficiente”

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.

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] , onde K é igual min(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]

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

Retorna self com novos valores diagonais, visto que self é 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 em diagonal .

Diagonal do parâmetro: um tensor com rank - 1 representando os novos valores diagonais.

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

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 internas r , de modo que o tensor seja igual a matmul(q, r) .

Retorna a decomposição de valor singular de self , dado que self é uma matriz opcionalmente em lote.

A decomposição de valor singular (SVD) da matriz self opcionalmente em lote são valores s , u e v , tais que:

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

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

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.

O cosseno de x , interpretado como um ângulo em radianos.

O seno de x , interpretado como um ângulo em radianos.

A tangente de x , interpretada como um ângulo em radianos.

O cosseno inverso de x em radianos.

O seno inverso de x em radianos.

A tangente inversa de x em radianos.

O cosseno hiperbólico de x .

O seno hiperbólico de x .

A tangente hiperbólica de x .