Tensore

Il TensorHandle sottostante.

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

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

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

Divide un tensore in più tensori. Il tensore è suddiviso lungo axis dimensionale in count più piccoli. Ciò richiede che count divida equamente shape[axis] .

Per esempio:

// 'value' is a tensor with shape [5, 30]
// Split 'value' into 3 tensors along dimension 1:
let parts = value.split(count: 3, alongAxis: 1)
parts[0] // has shape [5, 10]
parts[1] // has shape [5, 10]
parts[2] // has shape [5, 10]

Divide un tensore in più tensori. Il tensore è suddiviso in pezzi sizes.shape[0] . La forma dell'i i pezzo ha la stessa forma di questo tensore tranne lungo axis dimensionale dove la dimensione è sizes[i] .

Per esempio:

// 'value' is a tensor with shape [5, 30]
// Split 'value' into 3 tensors with sizes [4, 15, 11] along dimension 1:
let parts = value.split(sizes: Tensor<Int32>([4, 15, 11]), alongAxis: 1)
parts[0] // has shape [5, 4]
parts[1] // has shape [5, 15]
parts[2] // has shape [5, 11]

Restituisce un tensore affiancato, costruito affiancando questo tensore.

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

Restituisce un tensore affiancato, costruito affiancando questo tensore.

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

Rimodellare la forma del Tensor specificato.

Rimodellare alla forma specificata.

Riforma al Tensor specificato che rappresenta una forma.

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

Restituisce un Tensor espanso di forma, con una dimensione pari a 1 inserita negli indici di forma specificati.

Restituisce un Tensor espanso di forma, con una dimensione pari a 1 inserita negli indici di forma specificati.

Restituisce un Tensor con aumento di rango con una dimensione iniziale pari a 1.

Rimuove le dimensioni specificate della dimensione 1 dalla forma di un tensore. Se non vengono specificate dimensioni, tutte le dimensioni della dimensione 1 verranno rimosse.

Rimuove le dimensioni specificate della dimensione 1 dalla forma di un tensore. Se non vengono specificate dimensioni, tutte le dimensioni della dimensione 1 verranno rimosse.

Restituisce un tensore trasposto, con le dimensioni permutate nell'ordine specificato.

Restituisce un tensore trasposto, con le dimensioni permutate nell'ordine specificato.

Restituisce un tensore trasposto, con le dimensioni permutate nell'ordine specificato.

Restituisce un tensore trasposto, con le dimensioni permutate nell'ordine specificato.

Restituisce un tensore trasposto, con le dimensioni permutate nell'ordine specificato.

Restituisce un tensore trasposto, con le dimensioni permutate nell'ordine specificato.

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

Restituisce un tensore con le dimensioni specificate invertite.

Restituisce un tensore con le dimensioni specificate invertite.

Restituisce un tensore con le dimensioni specificate invertite.

Restituisce un tensore concatenato lungo l'asse specificato.

Operatore di concatenazione.

Restituisce un tensore raccogliendo porzioni dell'input negli indices lungo la dimensione axis

Per indices 0-D (scalari):

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

Per indices 1-D (vettoriali):

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

Nel caso generale, produce un tensore risultante dove:

result[p_0,             ..., p_{axis-1},
       i_{batch\_dims}, ..., i_{M-1},
       p_{axis + 1},    ..., p_{N-1}] =
self[p_0,             ..., p_{axis-1},
     indices[i_0,     ..., i_{M-1}],
     p_{axis + 1},    ..., p_{N-1}]

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

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

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

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

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

Per esempio:

// 1-D example
// tensor is [0, 1, 2, 3]
// mask is [true, false, true, false]
tensor.gathering(where: mask) // is [0, 2]

// 2-D example
// tensor is [[1, 2], [3, 4], [5, 6]]
// mask is [true, false, true]
tensor.gathering(where: mask) // is [[1, 2], [5, 6]]

In generale, 0 < mask.rank = K <= tensor.rank e la forma della mask deve corrispondere alle prime K dimensioni della forma del tensor . Abbiamo quindi: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] dove [i1, ..., iK] è l' i esima true voce della mask (ordine riga maggiore).

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

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

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

Per esempio:

// 'input' is [[true, false], [true, false]]
// 'input' has 2 true values and so the output has 2 rows.
// 'input' has rank of 2, and so the second dimension of the output has size 2.
input.nonZeroIndices() // is [[0, 0], [1, 0]]

// 'input' is [[[ true, false], [ true, false]],
//             [[false,  true], [false,  true]],
//             [[false, false], [false,  true]]]
// 'input' has 5 true values and so the output has 5 rows.
// 'input' has rank 3, and so the second dimension of the output has size 3.
input.nonZeroIndices() // is [[0, 0, 0],
                       //     [0, 1, 0],
                       //     [1, 0, 1],
                       //     [1, 1, 1],
                       //     [2, 1, 1]]

Trasmetti nella stessa forma del Tensor specificato.

Estrae una sezione dal tensore definito dai limiti inferiore e superiore per ciascuna dimensione.

Controlla che ogni elemento degli axes indichi un asse di self e altrimenti arresta il programma con una diagnostica.

Controlla che ogni elemento degli axes indichi un asse di self e altrimenti arresta il programma con una diagnostica.

Verifica che k denoti un asse di self e altrimenti interrompe il programma con una diagnostica.

Crea una copia di other sul Device specificato.

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

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

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

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

Impila tensors , lungo la dimensione axis , in un nuovo tensore con rango uno superiore al tensore corrente e ciascun tensore in tensors .

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

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

Per esempio:

// 'x' is [1, 4]
// 'y' is [2, 5]
// 'z' is [3, 6]
Tensor(stacking: [x, y, z]) // is [[1, 4], [2, 5], [3, 6]]
Tensor(stacking: [x, y, z], alongAxis: 1) // is [[1, 2, 3], [4, 5, 6]]

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

Concatena tensors lungo la dimensione axis .

Dato che tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] , allora il risultato concatenato ha forma [D0, D1, ... Raxis, ...Dn] , dove Raxis = sum(Daxis(i)) . Cioè, i dati provenienti dai tensori di input vengono uniti lungo la dimensione axis .

Per esempio:

// t1 is [[1, 2, 3], [4, 5, 6]]
// t2 is [[7, 8, 9], [10, 11, 12]]
Tensor(concatenating: [t1, t2]) // is [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
Tensor(concatenating: [t1, t2], alongAxis: 1) // is [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]

// t3 has shape [2, 3]
// t4 has shape [2, 3]
Tensor(concatenating: [t3, t4]) // has shape [4, 3]
Tensor(concatenating: [t3, t4], alongAxis: 1) // has shape [2, 6]

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

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

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

Promuove uno scalare a tensore con lo stesso dispositivo e precisione del tensore specificato.

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

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

Il numero di dimensioni del Tensor .

La forma del Tensor .

Il numero di scalari nel Tensor .

Rango del tensore, rappresentato come Tensor<Int32> .

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

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

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

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

Rimodellare in scalare.

Crea un tensore 0-D da un valore scalare.

Crea un tensore 1D da scalari.

Crea un tensore 1D da scalari.

Crea un tensore con la forma specificata e scalari contigui nell'ordine della riga maggiore.

Crea un tensore con la forma specificata e scalari contigui nell'ordine della riga maggiore.

Crea un tensore con la forma specificata e scalari contigui nell'ordine della riga maggiore.

Crea un tensore con la forma specificata e scalari contigui nell'ordine della riga maggiore.

Il tipo degli elementi di un valore letterale di array.

Crea un tensore inizializzato con gli elementi specificati.

Una rappresentazione testuale del tensore.

Una rappresentazione testuale del tensore. Restituisce una descrizione riepilogativa se summarize è true e il conteggio degli elementi supera il doppio di edgeElementCount .

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

Le annotazioni che descrivono questo tensore.

Un alias per le annotazioni.

Una modalità che determina come viene imbottito un tensore.

Restituisce un tensore riempito con costante in base alle dimensioni di riempimento specificate.

Restituisce un tensore imbottito in base alle dimensioni e alla modalità di riempimento specificate.

Restituisce un tensore di scalari booleani calcolando lhs < rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs <= rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs > rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs >= rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs < rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs <= rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs > rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs >= rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs < rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs <= rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs > rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs >= rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs == rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs != rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs == rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs != rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs == rhs per elemento.

Restituisce un tensore di scalari booleani calcolando lhs != rhs per elemento.

Restituisce un tensore di valori booleani che indica se gli elementi di self sono approssimativamente uguali a quelli di other .

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

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

Eseguire una conversione del tipo per elemento da un tensore Bool .

Esegui una conversione a livello di elemento da un altro Tensor .

Crea un tensore con tutti gli scalari impostati su zero.

Crea un tensore con tutti gli scalari impostati su uno.

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

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

Crea un tensore 1D che rappresenta una sequenza da un valore iniziale a un valore finale escluso, con incrementi della quantità specificata.

Crea un tensore 1D che rappresenta una sequenza da un valore iniziale a un valore finale escluso, con incrementi della quantità specificata.

Crea un tensore one-hot a determinati indici. Le posizioni rappresentate dagli indices assumono valore onValue ( 1 per impostazione predefinita), mentre tutte le altre posizioni assumono valore offValue ( 0 per impostazione predefinita). Se gli indices di input sono di rango n , il nuovo tensore avrà rango n+1 . Il nuovo asse viene creato in corrispondenza axis dimensione (per impostazione predefinita, il nuovo asse viene aggiunto alla fine).

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

Se indices è un vettore di lunghezza features , la forma di output sarà: caratteristiche x profondità, se asse == -1 profondità x caratteristiche, se asse == 0

Se indices è una matrice (batch) con forma [batch, features] , la forma di output sarà: batch x features x profondità, se asse == -1 batch x profondità x features, se asse == 1 profondità x batch x features , se asse == 0

Crea un tensore 1D che rappresenta una sequenza da un valore iniziale fino a un valore finale incluso, distanziato uniformemente per generare il numero di valori specificati.

Crea un tensore 1D che rappresenta una sequenza da un valore iniziale fino a un valore finale incluso, distanziato uniformemente per generare il numero di valori specificati.

Crea un tensore con la forma specificata, campionando in modo casuale valori scalari da una distribuzione uniforme tra lowerBound e upperBound .

Crea un tensore con la forma specificata, campionando in modo casuale valori scalari da una distribuzione uniforme tra lowerBound e upperBound .

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

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

Crea un tensore estraendo campioni da una distribuzione categoriale.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Riferimento: “Efficient BackProp”

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

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

Riferimento: “Efficient BackProp”

Crea una matrice ortogonale o tensore.

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

Se la forma del tensore da inizializzare è più che bidimensionale, viene inizializzata una matrice di forma [shape[0] * ... * shape[rank - 2], shape[rank - 1]] . La matrice viene successivamente rimodellata per dare un tensore della forma desiderata.

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

Per esempio:

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

Costruisce un array diagonale [batch]. Per l'istanza tensore della forma [..., M] , l'output è un tensore della forma [..., M, M] .

Per esempio:

// 't' is [1, 2, 3, 4]

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

Restituisce self con nuovi valori diagonali, dato che self è una matrice raggruppata facoltativamente.

Il tensore restituito ha la stessa forma e gli stessi valori di self , ad eccezione delle diagonali specificate delle matrici più interne che vengono sovrascritte dai valori in diagonal .

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

Restituisce una copia di un tensore più interno definito dai limiti di una banda centrale. L'output è un tensore della stessa forma dell'istanza [..., :, :] .

Per esempio:

// 't' is [[ 0,  1,  2, 3]
//         [-1,  0,  1, 2]
//         [-2, -1,  0, 1]
//         [-3, -2, -1, 0]]

t.bandPart(1, -1)
// [[ 0,  1,  2, 3]
//  [-1,  0,  1, 2]
//  [ 0, -1,  0, 1]
//  [ 0,  0, -1, 0]]

t.bandPart(2, 1)
// [[ 0,  1,  0, 0]
//  [-1,  0,  1, 0]
//  [-2, -1,  0, 1]
//  [ 0, -2, -1, 0]]

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

Restituisce la scomposizione del valore singolare di self , dato che self è una matrice raggruppata facoltativamente.

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

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

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

La radice quadrata di x .

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

Il coseno di x , interpretato come un angolo in radianti.

Il seno di x , interpretato come un angolo in radianti.

La tangente di x , interpretata come un angolo in radianti.

L'inverso del coseno di x in radianti.

Il seno inverso di x in radianti.

La tangente inversa di x in radianti.

Il coseno iperbolico di x .

Il seno iperbolico di x .

La tangente iperbolica di x .