DML_GATHER_OPERATOR_DESC-Struktur (directml.h)

Sammelt Elemente aus dem Eingabe tensor entlang der Achse und verwendet IndicesTensor , um Indizes neu zuzuordnen. Dieser Operator führt den folgenden Pseudocode aus, wobei "..." stellt eine Reihe von Koordinaten mit dem genauen Verhalten dar, das durch die Dimensionsanzahl der Achsen und Indizes bestimmt wird:

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

Syntax

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

Member

InputTensor

Typ: const DML_TENSOR_DESC*

Der Tensor, aus dem gelesen werden soll.

IndicesTensor

Typ: const DML_TENSOR_DESC*

Ein Tensor, der die Indizes enthält. Die DimensionCount dieses Tensors muss mit InputTensor.DimensionCount übereinstimmen.

DML_FEATURE_LEVEL_3_0Ab unterstützt dieser Operator negative Indexwerte, wenn ein integraler Vorzeichentyp mit diesem Tensor verwendet wird. Negative Indizes werden als relativ zum Ende der Achsendimension interpretiert. Beispielsweise bezieht sich ein Index von -1 auf das letzte Element entlang dieser Dimension.

Ungültige Indizes führen zu falschen Ausgaben, aber es tritt kein Fehler auf, und alle Lesevorgänge werden sicher im Arbeitsspeicher des Eingabe tensors eingeklemmt.

OutputTensor

Typ: const DML_TENSOR_DESC*

Der Tensor, in den die Ergebnisse geschrieben werden sollen. DimensionCount und DataType dieses Tensors müssen mit InputTensor.DimensionCount übereinstimmen. Die erwarteten OutputTensor.Sizes sind die Verkettung der führenden und nachgestellten Segmente InputTensor.Sizes , die auf der aktuellen Achse mit den eingefügten IndicesTensor.Sizes aufgeteilt werden.

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

Die Dimensionen sind rechtsbündig ausgerichtet, sodass alle führenden 1-Werte aus den Eingabegrößen zugeschnitten werden, was andernfalls die AusgabeDimensionCount überlaufen würde.

Die Anzahl der relevanten Dimensionen in diesem Tensor hängt von IndexDimensions und dem ursprünglichen Rang von InputTensor ab. Der ursprüngliche Rang ist die Anzahl der Dimensionen vor jeder Auffüllung mit führenden. Die Anzahl der relevanten Dimensionen in der Ausgabe kann nach dem ursprünglichen Rang von InputTensor + IndexDimensions - 1 berechnet werden. Dieser Wert muss kleiner oder gleich der DimensionCount von OutputTensor sein.

Axis

Typ: UINT

Die Achsendimension von InputTensor , für die erfasst werden soll, und reicht von [0, *InputTensor.DimensionCount*).

IndexDimensions

Typ: UINT

Die Anzahl der tatsächlichen Indexdimensionen innerhalb von IndicesTensor nach dem Ignorieren irrelevanter führender Dimensionen im Bereich [0, IndicesTensor.DimensionCount). Die tatsächlichen aussagekräftigen Indizes sind z. B. gegeben IndicesTensor.Sizes = { 1, 1, 4, 6 } und IndexDimensions = 3.{ 1, 4, 6 }

Beispiele

Beispiel 1: 1D-Neuzuordnung

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]

Beispiel 2: 2D-Ausgabe, 1D-Indizes, Achse 0, Verketten von Zeilen

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

Beispiel 3: 2D, Achse 1, Austauschen von Spalten

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

Beispiel 4. 2D, Achse 1, geschachtelte Indizes

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

Beispiel 5. 2D, Achse 0, geschachtelte Indizes

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

Verfügbarkeit

Dieser Operator wurde in DML_FEATURE_LEVEL_1_0eingeführt.

Tensoreinschränkungen

• IndicesTensor, InputTensor und OutputTensor müssen über dieselbe DimensionCount verfügen.
• InputTensor und OutputTensor müssen denselben Datentyp aufweisen.

Tensorunterstützung

DML_FEATURE_LEVEL_4_1 und höher

DML_FEATURE_LEVEL_3_0 und höher

DML_FEATURE_LEVEL_2_1 und höher

DML_FEATURE_LEVEL_1_0 und höher

Anforderungen