Tensor

O subjacente TensorHandle .

Desembala a dimensão dada de um rank R tensor em rank múltipla (R-1) tensores. Desembala N tensores deste tensor por lascar-lo ao longo do axis dimensão, onde N é inferida a partir da forma este tensor. Por exemplo, dado um tensor com a forma [A, B, C, D] :

• Se axis == 0 , em seguida, o i -simo tensor na matriz retornada é a fatia self[i, :, :, :] e cada tensor em que matriz terá forma [B, C, D] . (Note-se que a dimensão não embalada ao longo se foi, ao contrário Tensor.split(numSplits:alongAxis) , ou Tensor.split(sizes:alongAxis) ).
• Se axis == 1 , em seguida, o i -simo tensor na matriz retornada é a fatia value[:, i, :, :] e cada tensor em que matriz terá forma [A, C, D] .
• Etc.

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

Divide um tensor em vários tensores. O tensor é dividido ao longo da dimensão axis em count tensores menores. Isto requer que count uniformemente divide 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 sizes.shape[0] peças. A forma do i peça -ésimo tem a mesma forma que este tensor excepto ao longo dimensão axis , 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 ao lado desse tensor.

Este construtor cria um novo tensor, replicando esse tensor multiples vezes. O tensor é construído i 'th dimensão tem self.shape[i] * multiples[i] elementos, e os valores deste tensor são replicados multiples[i] vezes ao longo da i ' th dimensão. Por exemplo, a telha [abcd] por [2] produz [abcdabcd] .

Retorna um tensor lado a lado, construído ao lado desse tensor.

Este construtor cria um novo tensor, replicando esse tensor multiples vezes. O tensor é construído i 'th dimensão tem self.shape[i] * multiples[i] elementos, e os valores deste tensor são replicados multiples[i] vezes ao longo da i ' th dimensão. Por exemplo, a telha [abcd] por [2] produz [abcdabcd] .

Alterar forma para a forma do especificado Tensor .

Remodele para a forma especificada.

Alterar forma ao especificado Tensor representando uma forma de.

Devolver uma cópia do tensor de colapso em uma 1-D Tensor , a fim de linha maior.

Devolve uma expandida em forma de Tensor , com uma dimensão de 1 inserido nos índices forma especificada.

Devolve uma expandida em forma de Tensor , com uma dimensão de 1 inserido nos índices forma especificada.

Retorna uma levantou-rank Tensor com uma dimensão líder 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 na ordem reversa.

Retorna um tensor com as dimensões especificadas invertidas.

Retorna um tensor com as dimensões especificadas invertidas.

Retorna um tensor com as dimensões especificadas invertidas.

Retorna um tensor concatenado ao longo do eixo especificado.

Operador de concatenação.

Retorna um tensor através da recolha de fatias de entrada em indices ao longo do axis dimensão

Para 0-D (escalares) indices :

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

Para 1-D (vector) indices :

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

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

Retornos fatias de este tensor em indices ao longo do axis dimensão, enquanto ignoram os primeiros batchDimensionCount dimensões que correspondem às dimensões de lote. A coleta é executada ao longo da primeira dimensão sem lote.

Realiza funcionalidade semelhante a gathering , a não ser que a forma 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 , ea mask da forma deve coincidir com as primeiras dimensões K do tensor da forma. Temos então: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] , onde [i1, ..., iK] é o i th true entrada de mask (ordem de linha principal).

O axis pode ser usado com mask para indicar o eixo para mascarar a partir. Nesse caso, axis + mask.rank <= tensor.rank ea mask 's shape must match the first eixos + mask.rank dimensions of the forma de 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. Lembre-se de que a forma do tensor de saída pode variar dependendo de quantos valores verdadeiros existem neste tensor. Os índices são produzidos na ordem maior da linha.

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

Broadcast para a mesma forma que o especificado Tensor .

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

Verifica que cada elemento de axes indica um eixo de self , e interrompe o programa com um diagnóstico de outra forma.

Verifica que cada elemento de axes indica um eixo de self , e interrompe o programa com um diagnóstico de outra forma.

Verifica que k indica um eixo de self , e interrompe o programa com um diagnóstico de outra forma.

Cria uma cópia do other no dado Device .

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

Cria um tensor com a forma especificada e um único valor escalar 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).

Pilhas tensors , ao longo do axis dimensão, para um novo posto tensor com um mais elevado do que o tensor de corrente e cada tensor em tensors .

Dado que tensors têm forma [A, B, C] , e tensors.count = N , então:

• Se axis == 0 , em seguida, o tensor resultante terá a forma [N, A, B, C] .
• Se axis == 1 , em seguida, 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]]

Isto é o oposto do Tensor.unstacked(alongAxis:) .

Concatenates tensors ao longo do axis dimensão.

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

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 com other nas pistas, onde mask é true .

Retorna verdadeiro se o tipo escalar físico for de precisão reduzida.

Atualmente, reduziu precisão tipos escalares físicas incluir apenas BFloat16 .

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

Retorna uma cópia do self convertido para BFloat16 tipo escalar física.

Retorna uma cópia do self convertido para Scalar tipo escalar física.

O número de dimensões do Tensor .

A forma do Tensor .

O número de escalares do Tensor .

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

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

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

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

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

Remodele para escalar.

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

Cria um tensor 1D de escalares.

Cria um tensor 1D de escalares.

Cria um tensor com a forma especificada e escalares contíguos na ordem da linha principal.

Cria um tensor com a forma especificada e escalares contíguos na ordem da linha principal.

Cria um tensor com a forma especificada e escalares contíguos na ordem da linha principal.

Cria um tensor com a forma especificada e escalares contíguos na ordem da linha principal.

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 é verdadeiro e a contagem de elemento exceder o dobro do 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 booleanas computando lhs < rhs elemento-wise.

Retorna um tensor de escalares booleanas computando lhs <= rhs elemento-wise.

Retorna um tensor de escalares booleanas por computação lhs > rhs elemento-wise.

Retorna um tensor de escalares booleanas por computação lhs >= rhs elemento-wise.

Retorna um tensor de escalares booleanas computando lhs < rhs elemento-wise.

Retorna um tensor de escalares booleanas computando lhs <= rhs elemento-wise.

Retorna um tensor de escalares booleanas por computação lhs > rhs elemento-wise.

Retorna um tensor de escalares booleanas por computação lhs >= rhs elemento-wise.

Retorna um tensor de escalares booleanas computando lhs < rhs elemento-wise.

Retorna um tensor de escalares booleanas computando lhs <= rhs elemento-wise.

Retorna um tensor de escalares booleanas por computação lhs > rhs elemento-wise.

Retorna um tensor de escalares booleanas por computação lhs >= rhs elemento-wise.

Retorna um tensor de escalares booleanas computando lhs == rhs elemento-wise.

Retorna um tensor de escalares booleanas computando lhs != rhs elemento-wise.

Retorna um tensor de escalares booleanas computando lhs == rhs elemento-wise.

Retorna um tensor de escalares booleanas computando lhs != rhs elemento-wise.

Retorna um tensor de escalares booleanas computando lhs == rhs elemento-wise.

Retorna um tensor de escalares booleanas computando lhs != rhs elemento-wise.

Retorna um tensor de valores booleano que indica se os elementos de self são aproximadamente iguais aos de other .

Retorna true se todos os elementos de self são aproximadamente iguais aos de other .

Executa uma soma de réplica cruzada para este tensor. A mesma soma de réplica cruzada deve acontecer em cada um dos outros dispositivos que participam da soma.

Executar uma conversão do tipo de elemento a elemento a partir de um Bool tensor.

Executar uma conversão elemento-wise 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 têm 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 pela quantidade especificada.

Cria um tensor 1-D que representa uma sequência de um valor inicial até, mas não incluindo, um valor final, avançando pela quantidade especificada.

Cria um tensor one-hot em determinados índices. Os locais representadas por indices tomar valor onValue ( 1 por padrão), enquanto todos os outros locais levá valor offValue ( 0 por padrão). Se a entrada indices é posto n , o novo tensor terá posto n+1 . O novo eixo é criado na dimensão axis (por defeito, o novo eixo é anexado no final).

Se indices é um escalar, a forma do novo tensor será um vetor de comprimento depth .

Se indices é um vector de comprimento features , a forma de saída será: características x profundidade, se o eixo == -1 profundidade x características, se o eixo == 0

Se indices é uma matriz (em lotes) com forma [batch, features] , a forma de saída será: lote x apresenta x profundidade, se características eixo == -1 lote x profundidade x, se o eixo == 1 x profundidade x lote recursos , se eixo == 0

Cria um tensor 1-D que representa uma sequência de um valor inicial, até e incluindo um valor final, 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é e incluindo um valor final, espaçado uniformemente para gerar o número de valores especificados.

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

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

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

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

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

Cria um tensor com a forma especificada executando a inicialização uniforme Glorot (Xavier).

Baseia-se amostras aleatórias de uma distribuição uniforme entre -limit e limit gerado pelo gerador de números aleatórios padrão, onde limit é sqrt(6 / (fanIn + fanOut)) e fanIn / fanOut representam o número de entrada e de saída possui multiplicado pelo receptivo tamanho do campo.

Referência: “Compreender a dificuldade de formação de redes profunda feedforward neural”

Cria um tensor com a forma especificada executando a inicialização normal Glorot (Xavier).

Baseia-se amostras aleatórias de uma distribuição normal truncada centrado em 0 com um desvio padrão sqrt(2 / (fanIn + fanOut)) gerado pelo gerador de padrão de número aleatório, onde fanIn / fanOut representam o número de entrada e de saída possui multiplicado pelo campo receptivo Tamanho.

Referência: “Compreender a dificuldade de formação de redes profunda feedforward neural”

Cria um tensor com a forma especificada executando a inicialização uniforme de He (Kaiming).

Baseia-se amostras aleatórias de uma distribuição uniforme entre -limit e limit gerado pelo gerador de números aleatórios padrão, onde limit é sqrt(6 / fanIn) e fanIn representa o número de entrada possui multiplicada pelo tamanho do campo receptivo.

Referência: “mergulhar profundamente em Rectifiers: Superando Human Performance Nível sobre IMAGEnet Classification”

Cria um tensor com a forma especificada executando a inicialização normal de He (Kaiming).

Baseia-se amostras aleatórias de uma distribuição normal truncada centrado em 0 com desvio padrão sqrt(2 / fanIn)) gerado pelo gerador de números aleatórios padrão, onde fanIn representa o número de entrada possui multiplicada pelo tamanho do campo receptivo.

Referência: “mergulhar profundamente em Rectifiers: Superando Human Performance Nível sobre IMAGEnet Classification”

Cria um tensor com a forma especificada executando a inicialização uniforme LeCun.

Baseia-se amostras aleatórias de uma distribuição uniforme entre -limit e limit gerado pelo gerador de números aleatórios padrão, onde limit é sqrt(3 / fanIn) e fanIn representa o número de entrada possui multiplicada pelo tamanho do campo receptivo.

Referência: “Retropropagação Eficiente”

Cria um tensor com a forma especificada executando a inicialização normal LeCun.

Baseia-se amostras aleatórias de uma distribuição normal truncada centrado em 0 com um desvio padrão sqrt(1 / fanIn) gerado pelo gerador de números aleatórios padrão, onde fanIn representa o número de entrada possui multiplicada pelo tamanho do campo receptivo.

Referência: “Retropropagação Eficiente”

Cria uma matriz ortogonal ou tensor.

Se a forma do tensor a ser inicializado for bidimensional, ele será inicializado com uma matriz ortogonal obtida 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 para inicializar é mais do que bidimensional, uma matriz de forma [shape[0] * ... * shape[rank - 2], shape[rank - 1]] é inicializado. A matriz é posteriormente remodelada para fornecer um tensor com a forma desejada.

Retorna a parte diagonal [em lote] de um tensor [em lote]. Para o exemplo do tensor da forma [..., M, N] , a saída é um tensor da forma [..., K] , em que K é igual a 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 o exemplo 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]]

Retornos self com novos valores de diagonal, dado que self é uma matriz opcionalmente agrupadas.

O tensor devolvido tem a mesma forma e os valores como self , excepto para as diagonais especificadas das matrizes mais profundos que são substituídos pelos valores em diagonal .

Parâmetro diagonal: Um tensor com classificação rank - 1 representando os novos valores diagonais.

Retorna uma cópia de um tensor interno definido pelos limites de uma banda central. A saída é um tensor da mesma forma que o exemplo [..., :, :] .

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 de QR de cada matriz interna no tensor, um tensor com interior matrizes ortogonais q e um tensor com matrizes triangulares interiores superiores r , de tal modo que o tensor é igual a matmul(q, r) .

Devolve o valor de decomposição singular de self , dado que self é uma matriz opcionalmente agrupadas.

A decomposição do valor singular (SVD) da matriz opcionalmente agrupadas self é valores s , u , e v , de tal modo que:

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

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

The square root of x .

For real types, if x is negative the result is .nan . For complex types there is a branch cut on the negative real axis.

The cosine of x , interpreted as an angle in radians.

The sine of x , interpreted as an angle in radians.

The tangent of x , interpreted as an angle in radians.

The inverse cosine of x in radians.