Tensor

El TensorHandle subyacente.

Descomprime la dimensión dada de un tensor de rango R en múltiples tensores de rango (R-1) . Desempaqueta N tensores de este tensor cortándolos a lo largo de la dimensión axis , donde N se infiere de la forma de este tensor. Por ejemplo, dado un tensor con forma [A, B, C, D] :

• Si axis == 0 , entonces el i -ésimo tensor en la matriz devuelta es el segmento self[i, :, :, :] y cada tensor en esa matriz tendrá forma [B, C, D] . (Tenga en cuenta que la dimensión desempaquetada desapareció, a diferencia de Tensor.split(numSplits:alongAxis) o Tensor.split(sizes:alongAxis) ).
• Si axis == 1 , entonces el i -ésimo tensor en la matriz devuelta es el value[:, i, :, :] y cada tensor en esa matriz tendrá forma [A, C, D] .
• Etc.

Esto es lo opuesto a Tensor.init(stacking:alongAxis:) .

Divide un tensor en múltiples tensores. El tensor se divide a lo largo axis de dimensión en count más pequeños. Esto requiere que count divida uniformemente shape[axis] .

Por ejemplo:

// '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 tensor en múltiples tensores. El tensor se divide en sizes.shape[0] piezas. La forma de la i -ésima pieza tiene la misma forma que este tensor excepto a lo largo axis de dimensión donde el tamaño es sizes[i] .

Por ejemplo:

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

Devuelve un tensor en mosaico, construido colocando este tensor en mosaico.

Este constructor crea un nuevo tensor replicando este tensor multiples veces. La i dimensión del tensor construido tiene elementos self.shape[i] * multiples[i] , y los valores de este tensor se replican multiples[i] veces a lo largo de la i dimensión. Por ejemplo, colocar en mosaico [abcd] por [2] produce [abcdabcd] .

Devuelve un tensor en mosaico, construido colocando este tensor en mosaico.

Este constructor crea un nuevo tensor replicando este tensor multiples veces. La i dimensión del tensor construido tiene elementos self.shape[i] * multiples[i] , y los valores de este tensor se replican multiples[i] veces a lo largo de la i dimensión. Por ejemplo, colocar en mosaico [abcd] por [2] produce [abcdabcd] .

Cambie la forma a la forma del Tensor especificado.

Cambie la forma a la forma especificada.

Cambie la forma al Tensor especificado que representa una forma.

Devuelve una copia del tensor colapsado en un Tensor 1-D, en orden de fila principal.

Devuelve un Tensor expandido de forma, con una dimensión de 1 insertada en los índices de forma especificados.

Devuelve un Tensor expandido de forma, con una dimensión de 1 insertada en los índices de forma especificados.

Devuelve un Tensor de rango elevado con una dimensión principal de 1.

Elimina las dimensiones especificadas de tamaño 1 de la forma de un tensor. Si no se especifica ninguna dimensión, se eliminarán todas las dimensiones de tamaño 1.

Elimina las dimensiones especificadas de tamaño 1 de la forma de un tensor. Si no se especifica ninguna dimensión, se eliminarán todas las dimensiones de tamaño 1.

Devuelve un tensor transpuesto, con dimensiones permutadas en el orden especificado.

Devuelve un tensor transpuesto, con dimensiones permutadas en el orden especificado.

Devuelve un tensor transpuesto, con dimensiones permutadas en el orden especificado.

Devuelve un tensor transpuesto, con dimensiones permutadas en el orden especificado.

Devuelve un tensor transpuesto, con dimensiones permutadas en el orden especificado.

Devuelve un tensor transpuesto, con dimensiones permutadas en el orden especificado.

Devuelve un tensor transpuesto, con dimensiones permutadas en orden inverso.

Devuelve un tensor con dimensiones especificadas invertidas.

Devuelve un tensor con dimensiones especificadas invertidas.

Devuelve un tensor con dimensiones especificadas invertidas.

Devuelve un tensor concatenado a lo largo del eje especificado.

Operador de concatenación.

Devuelve un tensor reuniendo porciones de la entrada en indices a lo largo de la dimensión 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 (vectoriales):

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

En el caso general, produce un tensor resultante donde:

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

donde N = self.rank y M = indices.rank .

La forma del tensor resultante es: self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...] .

Devuelve sectores de este tensor en indices a lo largo de la dimensión axis , ignorando las primeras dimensiones batchDimensionCount que corresponden a las dimensiones de lote. La recolección se realiza a lo largo de la primera dimensión que no es por lotes.

Realiza una funcionalidad similar a gathering , excepto que la forma del tensor resultante ahora es shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] .

Devuelve un tensor reuniendo los valores después de aplicar la máscara booleana proporcionada a la entrada.

Por ejemplo:

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

En general, 0 < mask.rank = K <= tensor.rank y la forma de la mask debe coincidir con las primeras K dimensiones de la forma del tensor . Entonces tenemos: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] , donde [i1, ..., iK] es la i ésima entrada true de mask (orden de fila principal).

El axis podría usarse con mask para indicar el eje desde el que se debe enmascarar. En ese caso, axis + mask.rank <= tensor.rank y la 's shape must match the first mask deben coincidir con las dimensions of the forma del tensor.

Devuelve las ubicaciones de valores distintos de cero/verdaderos en este tensor.

Las coordenadas se devuelven en un tensor 2-D donde la primera dimensión (filas) representa el número de elementos distintos de cero y la segunda dimensión (columnas) representa las coordenadas de los elementos distintos de cero. Tenga en cuenta que la forma del tensor de salida puede variar dependiendo de cuántos valores verdaderos haya en este tensor. Los índices se generan en el orden de las filas principales.

Por ejemplo:

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

Transmitir con la misma forma que el Tensor especificado.

Extrae una porción del tensor definido por los límites superior e inferior para cada dimensión.

Comprueba que cada elemento de axes denota un eje self y, en caso contrario, detiene el programa con un diagnóstico.

Comprueba que cada elemento de axes denota un eje self y, en caso contrario, detiene el programa con un diagnóstico.

Comprueba que k denota un eje de self y, en caso contrario, detiene el programa con un diagnóstico.

Crea una copia de other en el Device dado.

Crea un tensor con la forma especificada y un valor escalar único y repetido.

Crea un tensor con la forma especificada y un valor escalar único y repetido.

Crea un tensor transmitiendo el escalar dado a un rango determinado con todas las dimensiones siendo 1.

Crea un tensor a partir de una matriz de tensores (que a su vez pueden ser escalares).

Apila tensors , a lo largo de la dimensión axis , en un nuevo tensor con rango uno superior al tensor actual y cada tensor en tensors .

Dado que todos tensors tienen forma [A, B, C] y tensors.count = N , entonces:

• Si axis == 0 , entonces el tensor resultante tendrá la forma [N, A, B, C] .
• Si axis == 1 , entonces el tensor resultante tendrá la forma [A, N, B, C] .
• etc.

Por ejemplo:

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

Esto es lo opuesto a Tensor.unstacked(alongAxis:) .

Concatena tensors a lo largo de la dimensión axis .

Dado que tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] , entonces el resultado concatenado tiene forma [D0, D1, ... Raxis, ...Dn] , donde Raxis = sum(Daxis(i)) . Es decir, los datos de los tensores de entrada se unen a lo largo de la dimensión axis .

Por ejemplo:

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

Reemplaza elementos de este tensor con other en los carriles donde mask es true .

Devuelve verdadero si el tipo escalar físico tiene precisión reducida.

Actualmente, los tipos escalares físicos de precisión reducida incluyen solo BFloat16 .

Promueve un escalar a tensor con el mismo dispositivo y precisión que el tensor dado.

Devuelve una copia self al tipo escalar físico BFloat16 .

Devuelve una copia del tipo Scalar físico self .

El número de dimensiones del Tensor .

La forma del Tensor .

El número de escalares en el Tensor .

El rango del tensor, representado como Tensor<Int32> .

Las dimensiones del tensor, representadas como Tensor<Int32> .

El número de escalares en el tensor, representado como Tensor<Int32> .

Devuelve true si rank es igual a 0 y false en caso contrario.

Devuelve el elemento escalar único si rank es igual a 0 y nil en caso contrario.

Reformar a escalar.

Crea un tensor 0-D a partir de un valor escalar.

Crea un tensor 1D a partir de escalares.

Crea un tensor 1D a partir de escalares.

Crea un tensor con la forma especificada y escalares contiguos en orden de fila principal.

Crea un tensor con la forma especificada y escalares contiguos en orden de fila principal.

Crea un tensor con la forma especificada y escalares contiguos en orden de fila principal.

Crea un tensor con la forma especificada y escalares contiguos en orden de fila principal.

El tipo de elementos de un literal de matriz.

Crea un tensor inicializado con los elementos dados.

Una representación textual del tensor.

Una representación textual del tensor. Devuelve una descripción resumida si summarize es verdadero y el recuento de elementos excede el doble de edgeElementCount .

Una representación textual completa y no muy impresa del tensor, que muestra todos los escalares.

Las anotaciones que describen este tensor.

Un alias para anotaciones.

Un modo que dicta cómo se rellena un tensor.

Devuelve un tensor relleno con una constante según los tamaños de relleno especificados.

Devuelve un tensor acolchado según el modo y los tamaños de relleno especificados.

Devuelve un tensor de escalares booleanos calculando lhs < rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs <= rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs > rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs >= rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs < rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs <= rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs > rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs >= rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs < rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs <= rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs > rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs >= rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs == rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs != rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs == rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs != rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs == rhs por elementos.

Devuelve un tensor de escalares booleanos calculando lhs != rhs por elementos.

Devuelve un tensor de valores booleanos que indica si los elementos de self son aproximadamente iguales a los de other .

Devuelve true si todos los elementos de self son aproximadamente iguales a los de other .

Ejecuta una suma de réplicas cruzadas para este tensor. La misma suma de réplicas cruzadas debe ocurrir en cada uno de los demás dispositivos que participan en la suma.

Realice una conversión de tipo por elementos desde un tensor Bool .

Realice una conversión de elementos desde otro Tensor .

Crea un tensor con todos los escalares establecidos en cero.

Crea un tensor con todos los escalares establecidos en uno.

Crea un tensor con todos los escalares establecidos en cero que tiene la misma forma y tipo que el tensor proporcionado.

Crea un tensor con todos los escalares establecidos en uno que tenga la misma forma y tipo que el tensor proporcionado.

Crea un tensor 1-D que representa una secuencia desde un valor inicial hasta un valor final, pero sin incluirlo, avanzando en la cantidad especificada.

Crea un tensor 1-D que representa una secuencia desde un valor inicial hasta un valor final, pero sin incluirlo, avanzando en la cantidad especificada.

Crea un tensor one-hot en índices dados. Las ubicaciones representadas por indices toman el valor onValue ( 1 de forma predeterminada), mientras que todas las demás ubicaciones toman el valor offValue ( 0 de forma predeterminada). Si los indices de entrada tienen rango n , el nuevo tensor tendrá rango n+1 . El nuevo eje se crea en axis de dimensión (de forma predeterminada, el nuevo eje se agrega al final).

Si indices es un escalar, la forma del nuevo tensor será un vector de longitud depth .

Si indices es un vector de features de longitud, la forma de salida será: características x profundidad, si eje == -1 profundidad x características, si eje == 0

Si indices es una matriz (lote) con forma [batch, features] , la forma de salida será: lote x características x profundidad, si eje == -1 lote x profundidad x características, si eje == 1 profundidad x lote x características , si eje == 0

Crea un tensor 1-D que representa una secuencia desde un valor inicial hasta un valor final incluido, espaciados uniformemente para generar el número de valores especificados.

Crea un tensor 1-D que representa una secuencia desde un valor inicial hasta un valor final incluido, espaciados uniformemente para generar el número de valores especificados.

Crea un tensor con la forma especificada, muestreando aleatoriamente valores escalares de una distribución uniforme entre lowerBound y upperBound .

Crea un tensor con la forma especificada, muestreando aleatoriamente valores escalares de una distribución uniforme entre lowerBound y upperBound .

Crea un tensor con la forma especificada, muestreando aleatoriamente valores escalares de una distribución normal.

Crea un tensor con la forma especificada, muestreando aleatoriamente valores escalares de una distribución Normal truncada.

Crea un tensor extrayendo muestras de una distribución categórica.

Crea un tensor con la forma especificada realizando una inicialización uniforme de Glorot (Xavier).

Extrae muestras aleatorias de una distribución uniforme entre -limit y limit generado por el generador de números aleatorios predeterminado, donde limit es sqrt(6 / (fanIn + fanOut)) y fanIn / fanOut representan el número de características de entrada y salida multiplicadas por el receptivo. tamaño del campo.

Referencia: "Comprender la dificultad de entrenar redes neuronales de retroalimentación profunda"

Crea un tensor con la forma especificada realizando la inicialización normal de Glorot (Xavier).

Extrae muestras aleatorias de una distribución normal truncada centrada en 0 con desviación estándar sqrt(2 / (fanIn + fanOut)) generada por el generador de números aleatorios predeterminado, donde fanIn / fanOut representan el número de características de entrada y salida multiplicadas por el campo receptivo. tamaño.

Referencia: "Comprender la dificultad de entrenar redes neuronales de retroalimentación profunda"

Crea un tensor con la forma especificada realizando una inicialización uniforme de He (Kaiming).

Extrae muestras aleatorias de una distribución uniforme entre -limit y limit generado por el generador de números aleatorios predeterminado, donde limit es sqrt(6 / fanIn) y fanIn representa el número de características de entrada multiplicadas por el tamaño del campo receptivo.

Referencia: "Profundizando en los rectificadores: superando el rendimiento a nivel humano en la clasificación ImageNet"

Crea un tensor con la forma especificada realizando la inicialización normal He (Kaiming).

Extrae muestras aleatorias de una distribución normal truncada centrada en 0 con desviación estándar sqrt(2 / fanIn)) generada por el generador de números aleatorios predeterminado, donde fanIn representa el número de características de entrada multiplicadas por el tamaño del campo receptivo.

Referencia: "Profundizando en los rectificadores: superando el rendimiento a nivel humano en la clasificación ImageNet"

Crea un tensor con la forma especificada realizando la inicialización uniforme de LeCun.

Extrae muestras aleatorias de una distribución uniforme entre -limit y limit generada por el generador de números aleatorios predeterminado, donde limit es sqrt(3 / fanIn) y fanIn representa el número de características de entrada multiplicadas por el tamaño del campo receptivo.

Referencia: “BackProp eficiente”

Crea un tensor con la forma especificada realizando la inicialización normal de LeCun.

Extrae muestras aleatorias de una distribución normal truncada centrada en 0 con desviación estándar sqrt(1 / fanIn) generada por el generador de números aleatorios predeterminado, donde fanIn representa el número de características de entrada multiplicadas por el tamaño del campo receptivo.

Referencia: “BackProp eficiente”

Crea una matriz ortogonal o tensor.

Si la forma del tensor a inicializar es bidimensional, se inicializa con una matriz ortogonal obtenida de la descomposición QR de una matriz de números aleatorios extraída de una distribución normal. Si la matriz tiene menos filas que columnas, la salida tendrá filas ortogonales. De lo contrario, la salida tendrá columnas ortogonales.

Si la forma del tensor a inicializar es más que bidimensional, se inicializa una matriz de forma [shape[0] * ... * shape[rank - 2], shape[rank - 1]] . Posteriormente se reforma la matriz para dar un tensor de la forma deseada.

Devuelve la parte diagonal [por lotes] de un tensor [por lotes]. Para la instancia tensor de la forma [..., M, N] , la salida es un tensor de la forma [..., K] , donde K es igual a min(N, M) .

Por ejemplo:

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

Construye una matriz diagonal [por lotes]. Para la instancia tensor de la forma [..., M] , la salida es un tensor de la forma [..., M, M] .

Por ejemplo:

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

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

Devuelve self con nuevos valores diagonales, dado que self es una matriz por lotes opcional.

El tensor devuelto tiene la misma forma y valores que self , excepto las diagonales especificadas de las matrices más internas que se sobrescriben con los valores en diagonal .

Diagonal de parámetro: un tensor con rank - 1 que representa los nuevos valores de la diagonal.

Devuelve una copia de un tensor más interno definido por los límites de una banda central. La salida es un tensor de la misma forma que la instancia [..., :, :] .

Por ejemplo:

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

Devuelve la descomposición QR de cada matriz interna en el tensor, un tensor con matrices ortogonales internas q y un tensor con matrices triangulares superiores internas r , de modo que el tensor es igual a matmul(q, r) .

Devuelve la descomposición del valor singular de self , dado que self es una matriz por lotes opcional.

La descomposición en valores singulares (SVD) de la matriz self opcionalmente por lotes son los valores s , u y v , tales que:

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

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

La raíz cuadrada de x .

Para tipos reales, si x es negativo, el resultado es .nan . Para tipos complejos hay un corte de rama en el eje real negativo.

El coseno de x , interpretado como un ángulo en radianes.

El seno de x , interpretado como un ángulo en radianes.

La tangente de x , interpretada como un ángulo en radianes.

El coseno inverso de x en radianes.

El seno inverso de x en radianes.

La tangente inversa de x en radianes.

El coseno hiperbólico de x .

El seno hiperbólico de x .

La tangente hiperbólica de x .