DML_GATHER_OPERATOR_DESC struttura (directml.h)

Raccoglie gli elementi dal tensore di input lungo l'asse, usando IndicesTensor per eseguire il mapping degli indici. Questo operatore esegue lo pseudocode seguente, dove "..." rappresenta una serie di coordinate, con il comportamento esatto determinato dal conteggio delle dimensioni dell'asse e degli indici:

output[...] = input[..., indices[...], ...]

Sintassi

struct DML_GATHER_OPERATOR_DESC {
  const DML_TENSOR_DESC *InputTensor;
  const DML_TENSOR_DESC *IndicesTensor;
  const DML_TENSOR_DESC *OutputTensor;
  UINT                  Axis;
  UINT                  IndexDimensions;
};

Members

InputTensor

Tipo: const DML_TENSOR_DESC*

Tensore da cui leggere.

IndicesTensor

Tipo: const DML_TENSOR_DESC*

Tensore contenente gli indici. DimensionCount di questo tensore deve corrispondere a InputTensor.DimensionCount.

A partire da DML_FEATURE_LEVEL_3_0, questo operatore supporta valori di indice negativi quando si usa un tipo integrale firmato con questo tensore. Gli indici negativi vengono interpretati come relativi alla fine della dimensione dell'asse. Ad esempio, un indice di -1 fa riferimento all'ultimo elemento lungo tale dimensione.

Gli indici non validi restituiranno output non corretti, ma non si verificherà alcun errore e tutte le letture verranno bloccate in modo sicuro all'interno della memoria del tensore di input.

OutputTensor

Tipo: const DML_TENSOR_DESC*

Tensor in cui scrivere i risultati. DimensionCount e DataType di questo tensore devono corrispondere a InputTensor.DimensionCount. L'output previstoTensor.Sizes è la concatenazione dei segmenti iniziali e finali di InputTensor.Sizes suddivisi nell'asse corrente con indicesTensor.Sizes inseriti tra.

OutputTensor.Sizes = {
    InputTensor.Sizes[0..Axis],
    IndicesTensor.Sizes[(IndicesTensor.DimensionCount - IndexDimensions) .. IndicesTensor.DimensionCount],
    InputTensor.Sizes[(Axis+1) .. InputTensor.DimensionCount]
}

Le dimensioni sono allineate a destra in modo che tutti i valori iniziali 1 dalle dimensioni di input vengano ritagliati che altrimenti sovraflowno il DimensionCount di output.

Il numero di dimensioni rilevanti in questo tensore dipende da IndexDimensions e dalla classificazione originale di InputTensor. Il rango originale è il numero di dimensioni precedenti a qualsiasi riempimento con quelli iniziali. Il numero di dimensioni rilevanti nell'output può essere calcolato dal rango originale di InputTensor + IndexDimensions - 1. Questo valore deve essere minore o uguale a DimensionCount of OutputTensor.

Axis

Tipo: UINT

Dimensione dell'asse di InputTensor su cui raccogliere, a intervalli [0, *InputTensor.DimensionCount*).

IndexDimensions

Tipo: UINT

Numero di dimensioni di indice effettive all'interno IndicesTensor di dopo aver ignorato quelli iniziali irrilevanti, che vanno da [0, IndicesTensor.DimensionCount). Ad esempio, dato IndicesTensor.Sizes = { 1, 1, 4, 6 } e IndexDimensions = 3, gli indici significativi effettivi sono { 1, 4, 6 }.

Esempi

Esempio 1. 1D remapping

Axis: 0
IndexDimensions: 1

InputTensor: (Sizes:{4}, DataType:FLOAT32)
    [11,12,13,14]

IndicesTensor: (Sizes:{5}, DataType:UINT32)
    [3,1,3,0,2]

// output[x] = input[indices[x]]
OutputTensor: (Sizes:{5}, DataType:FLOAT32)
    [14,12,14,11,13]

Esempio 2. Output 2D, indici 1D, Asse 0, righe concatenate

Axis: 0
IndexDimensions: 1

InputTensor: (Sizes:{3,2}, DataType:FLOAT32)
    [[1,2], // row 0
     [3,4], // row 1
     [5,6]] // row 2

IndicesTensor: (Sizes:{1, 4}, DataType:UINT32)
    [[0,
      1,
      1,
      2]]

// output[y, x] = input[indices[y], x]
OutputTensor: (Sizes:{4,2}, DataType:FLOAT32)
    [[1,2], // input row 0
     [3,4], // input row 1
     [3,4], // input row 1
     [5,6]] // input row 2

Esempio 3. 2D, Asse 1, scambiare colonne

Axis: 1
IndexDimensions: 2

InputTensor: (Sizes:{3,2}, DataType:FLOAT32)
    [[1,2],
     [3,4],
     [5,6]]

IndicesTensor: (Sizes:{1, 2}, DataType:UINT32)
    [[1,0]]

// output[y, x] = input[y, indices[x]]
OutputTensor: (Sizes:{3,2}, DataType:FLOAT32)
    [[2,1],
     [4,3],
     [6,5]]

Esempio 4. 2D, Asse 1, indici annidati

Axis: 2
IndexDimensions: 2

InputTensor: (Sizes:{1, 3,3}, DataType:FLOAT32)
    [ [[1,2,3],
       [4,5,6],
       [7,8,9]] ]

IndicesTensor: (Sizes:{1, 1,2}, DataType:UINT32)
    [ [[0,2]] ]

// output[z, y, x] = input[z, indices[y, x]]
OutputTensor: (Sizes:{3,1,2}, DataType:FLOAT32)
    [[[1,3]],
     [[4,6]],
     [[7,9]]]

Esempio 5. 2D, Asse 0, indici annidati

Axis: 1
IndexDimensions: 2

InputTensor: (Sizes:{1, 3,2}, DataType:FLOAT32)
    [ [[1,2],
       [3,4],
       [5,6]] ]

IndicesTensor: (Sizes:{1, 2,2}, DataType:UINT32)
    [ [[0,1],
       [1,2]] ]

// output[z, y, x] = input[indices[z, y], x]
OutputTensor: (Sizes:{2,2,2}, DataType:FLOAT32)
    [[[1,2], [3,4]],
     [[3,4], [5,6]]]

Disponibilità

Questo operatore è stato introdotto in DML_FEATURE_LEVEL_1_0.

Vincoli tensor

• IndicesTensor, InputTensor e OutputTensor devono avere lo stesso DimensionCount.
• InputTensor e OutputTensor devono avere lo stesso Tipo di dati.

Supporto di Tensor

DML_FEATURE_LEVEL_4_1 e versioni successive

DML_FEATURE_LEVEL_3_0 e versioni successive

DML_FEATURE_LEVEL_2_1 e versioni successive

DML_FEATURE_LEVEL_1_0 e versioni successive

Requisiti