MatrixDiagV3

clase final pública MatrixDiagV3

Devuelve un tensor diagonal por lotes con valores diagonales por lotes dados.

Devuelve un tensor con el contenido en `diagonal` como `k[0]`-ésima a `k[1]`-ésima diagonal de una matriz, con todo lo demás rellenado con `padding`. `num_rows` y `num_cols` especifican la dimensión de la matriz más interna de la salida. Si no se especifican ambos, la operación supone que la matriz más interna es cuadrada e infiere su tamaño a partir de "k" y la dimensión más interna de "diagonal". Si solo se especifica uno de ellos, la operación asume que el valor no especificado es el más pequeño posible según otros criterios.

Sea `diagonal` tener dimensiones `r` `[I, J, ..., L, M, N]`. El tensor de salida tiene rango `r+1` con forma `[I, J, ..., L, M, num_rows, num_cols]` cuando solo se proporciona una diagonal (`k` es un número entero o `k[0] ==k[1]`). De lo contrario, tiene rango `r` con forma `[I, J, ..., L, num_rows, num_cols]`.

La segunda dimensión más interna de "diagonal" tiene un doble significado. Cuando `k` es escalar o `k[0] == k[1]`, `M` es parte del tamaño del lote [I, J, ..., M] y el tensor de salida es:

output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, n-max(d_upper, 0)] ; if n - m == d_upper
     padding_value                             ; otherwise
De lo contrario, `M` se trata como el número de diagonales de la matriz en el mismo lote (`M = k[1]-k[0]+1`), y el tensor de salida es:
output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
     padding_value                                     ; otherwise
donde `d = n - m`, `diag_index = [k] - d` y `index_in_diag = n - max(d, 0) + offset`.

El "desplazamiento" es cero, excepto cuando la alineación de la diagonal es hacia la derecha.

offset = max_diag_len - diag_len(d) ; if (`align` in {RIGHT_LEFT, RIGHT_RIGHT
                                            and `d >= 0`) or
                                          (`align` in {LEFT_RIGHT, RIGHT_RIGHT}
                                            and `d <= 0`)
          0                          ; otherwise
 }
 donde `diag_len(d) = min(cols - max(d, 0), filas + min(d, 0))`.

Por ejemplo:

# The main diagonal.
 diagonal = np.array([[1, 2, 3, 4],            # Input shape: (2, 4)
                      [5, 6, 7, 8]])
 tf.matrix_diag(diagonal) ==> [[[1, 0, 0, 0],  # Output shape: (2, 4, 4)
                                [0, 2, 0, 0],
                                [0, 0, 3, 0],
                                [0, 0, 0, 4]],
                               [[5, 0, 0, 0],
                                [0, 6, 0, 0],
                                [0, 0, 7, 0],
                                [0, 0, 0, 8]]]
 
 # A superdiagonal (per batch).
 diagonal = np.array([[1, 2, 3],  # Input shape: (2, 3)
                      [4, 5, 6]])
 tf.matrix_diag(diagonal, k = 1)
   ==> [[[0, 1, 0, 0],  # Output shape: (2, 4, 4)
         [0, 0, 2, 0],
         [0, 0, 0, 3],
         [0, 0, 0, 0]],
        [[0, 4, 0, 0],
         [0, 0, 5, 0],
         [0, 0, 0, 6],
         [0, 0, 0, 0]]]
 
 # A tridiagonal band (per batch).
 diagonals = np.array([[[0, 8, 9],  # Input shape: (2, 2, 3)
                        [1, 2, 3],
                        [4, 5, 0]],
                       [[0, 2, 3],
                        [6, 7, 9],
                        [9, 1, 0]]])
 tf.matrix_diag(diagonals, k = (-1, 1))
   ==> [[[1, 8, 0],  # Output shape: (2, 3, 3)
         [4, 2, 9],
         [0, 5, 3]],
        [[6, 2, 0],
         [9, 7, 3],
         [0, 1, 9]]]
 
 # LEFT_RIGHT alignment.
 diagonals = np.array([[[8, 9, 0],  # Input shape: (2, 2, 3)
                        [1, 2, 3],
                        [0, 4, 5]],
                       [[2, 3, 0],
                        [6, 7, 9],
                        [0, 9, 1]]])
 tf.matrix_diag(diagonals, k = (-1, 1), align="LEFT_RIGHT")
   ==> [[[1, 8, 0],  # Output shape: (2, 3, 3)
         [4, 2, 9],
         [0, 5, 3]],
        [[6, 2, 0],
         [9, 7, 3],
         [0, 1, 9]]]
 
 # Rectangular matrix.
 diagonal = np.array([1, 2])  # Input shape: (2)
 tf.matrix_diag(diagonal, k = -1, num_rows = 3, num_cols = 4)
   ==> [[0, 0, 0, 0],  # Output shape: (3, 4)
        [1, 0, 0, 0],
        [0, 2, 0, 0]]
 
 # Rectangular matrix with inferred num_cols and padding_value = 9.
 tf.matrix_diag(diagonal, k = -1, num_rows = 3, padding_value = 9)
   ==> [[9, 9],  # Output shape: (3, 2)
        [1, 9],
        [9, 2]]

Clases anidadas

clase MatrixDiagV3.Opciones Atributos opcionales para MatrixDiagV3

Constantes

Cadena OP_NOMBRE El nombre de esta operación, como la conoce el motor central de TensorFlow.

Métodos públicos

Estático MatrixDiagV3.Options
alinear (alinear cadenas)
Salida <T>
como salida ()
Devuelve el identificador simbólico del tensor.
estático <T extiende TType > MatrixDiagV3 <T>
crear (alcance alcance , operando <T> diagonal, operando < TInt32 > k, operando < TInt32 > numRows, operando < TInt32 > numCols, operando <T> paddingValue, opciones... opciones)
Método de fábrica para crear una clase que envuelve una nueva operación MatrixDiagV3.
Salida <T>
producción ()
Tiene rango `r+1` cuando `k` es un número entero o `k[0] == k[1]`, rango `r` en caso contrario.

Métodos heredados

Constantes

Cadena final estática pública OP_NAME

El nombre de esta operación, como la conoce el motor central de TensorFlow.

Valor constante: "MatrixDiagV3"

Métodos públicos

MatrixDiagV3.Options estática pública alineada (alineación de cadenas)

Parámetros
alinear Algunas diagonales son más cortas que `max_diag_len` y es necesario rellenarlas. `align` es una cadena que especifica cómo se deben alinear las superdiagonales y subdiagonales, respectivamente. Hay cuatro alineaciones posibles: "RIGHT_LEFT" (predeterminado), "LEFT_RIGHT", "LEFT_LEFT" y "RIGHT_RIGHT". "RIGHT_LEFT" alinea las superdiagonales a la derecha (rellena la fila con la izquierda) y las subdiagonales a la izquierda (rellena la fila con la derecha). Es el formato de embalaje que utiliza LAPACK. cuSPARSE usa "LEFT_RIGHT", que es la alineación opuesta.

Salida pública <T> como Salida ()

Devuelve el identificador simbólico del tensor.

Las entradas a las operaciones de TensorFlow son salidas de otra operación de TensorFlow. Este método se utiliza para obtener un identificador simbólico que representa el cálculo de la entrada.

público estático MatrixDiagV3 <T> crear ( alcance alcance, operando <T> diagonal, operando < TInt32 > k, operando < TInt32 > numRows, operando < TInt32 > numCols, operando <T> paddingValue, opciones... opciones)

Método de fábrica para crear una clase que envuelve una nueva operación MatrixDiagV3.

Parámetros
alcance alcance actual
diagonal Rango `r`, donde `r >= 1`
k Desplazamientos diagonales. El valor positivo significa superdiagonal, 0 se refiere a la diagonal principal y el valor negativo significa subdiagonales. `k` puede ser un único número entero (para una única diagonal) o un par de números enteros que especifican los extremos inferior y superior de una banda de matriz. `k[0]` no debe ser mayor que `k[1]`.
número de filas El número de filas de la matriz de salida. Si no se proporciona, la operación asume que la matriz de salida es una matriz cuadrada e infiere el tamaño de la matriz a partir de k y la dimensión más interna de "diagonal".
numCols El número de columnas de la matriz de salida. Si no se proporciona, la operación asume que la matriz de salida es una matriz cuadrada e infiere el tamaño de la matriz a partir de k y la dimensión más interna de "diagonal".
valor de relleno El número con el que rellenar el área fuera de la banda diagonal especificada. El valor predeterminado es 0.
opciones lleva valores de atributos opcionales
Devoluciones
  • una nueva instancia de MatrixDiagV3

Salida pública <T> salida ()

Tiene rango `r+1` cuando `k` es un número entero o `k[0] == k[1]`, rango `r` en caso contrario.