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 del 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 del 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 especifican dimensiones, 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 del 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 .