estrutura DML_ROI_ALIGN_GRAD_OPERATOR_DESC (directml.h)

Calcula gradientes de backpropagation para ROI_ALIGN e ROI_ALIGN1.

Lembre-se de que DML_ROI_ALIGN1_OPERATOR_DESC culturas e redimensiona sub-regiões de um tensor de entrada usando amostragem de vizinho próximo ou interpolação bilinear. Dado um com os mesmos tamanhos que o de saída de um DML_OPERATOR_ROI_ALIGN1equivalente, esse operador produz um com os mesmos tamanhos que o de entrada de DML_OPERATOR_ROI_ALIGN1.

Por exemplo, considere um DML_OPERATOR_ROI_ALIGN1 que executa um vizinho mais próximo dimensionamento de 1,5x na largura e 0,5x na altura, para quatro culturas não sobrepostas de uma entrada com dimensões [1, 1, 4, 4]:

ROITensor
[[0, 0, 2, 2],
 [2, 0, 4, 2],
 [0, 2, 2, 4],
 [2, 2, 4, 4]]

BatchIndicesTensor
[0, 0, 0, 0]

InputTensor
[[[[1,   2, |  3,  4],    RoiAlign1     [[[[ 1,  1,  2]]],
   [5,   6, |  7,  8],       -->         [[[ 3,  3,  4]]],
   ------------------                    [[[ 9,  9, 10]]],
   [9,  10, | 11, 12],                   [[[11, 11, 12]]]]
   [13, 14, | 15, 16]]]]

Observe como o 0º elemento de cada região contribui para dois elementos na saída: o 1º elemento contribui para um elemento na saída e os 2º e 3º elementos contribuem para nenhum elemento da saída.

O DML_OPERATOR_ROI_ALIGN_GRAD correspondente executaria o seguinte:

InputGradientTensor                  OutputGradientTensor
[[[[ 1,  2,  3]]],    ROIAlignGrad   [[[[ 3,  3, |  9,  6],
 [[[ 4,  5,  6]]],         -->          [ 0,  0, |  0,  0],
 [[[ 7,  8,  9]]],                      ------------------
 [[[10, 11, 12]]]]                      [15,  9, | 21, 12],
                                        [ 0,  0, |  0,  0]]]]

Em resumo, DML_OPERATOR_ROI_ALIGN_GRAD se comporta de forma semelhante a uma DML_OPERATOR_RESAMPLE_GRAD executada em cada lote do InputGradientTensor quando as regiões não se sobrepõem.

Para OutputROIGradientTensor, a matemática é um pouco diferente e pode ser resumida pelo pseudocódigo a seguir (supondo que MinimumSamplesPerOutput == 1 e MaximumSamplesPerOutput == 1):

for each region of interest (ROI):
    for each inputGradientCoordinate:
        for each inputCoordinate that contributed to this inputGradient element:
            topYIndex = floor(inputCoordinate.y)
            bottomYIndex = ceil(inputCoordinate.y)
            leftXIndex = floor(inputCoordinate.x)
            rightXIndex = ceil(inputCoordinate.x)

            yLerp = inputCoordinate.y - topYIndex
            xLerp = inputCoordinate.x - leftXIndex

            topLeft = InputTensor[topYIndex][leftXIndex]
            topRight = InputTensor[topYIndex][rightXIndex]
            bottomLeft = InputTensor[bottomYIndex][leftXIndex]
            bottomRight = InputTensor[bottomYIndex][rightXIndex]

            inputGradientWeight = InputGradientTensor[inputGradientCoordinate.y][inputGradientCoordinate.x]
            imageGradY = (1 - xLerp) * (bottomLeft - topLeft) + xLerp * (bottomRight - topRight)
            imageGradX = (1 - yLerp) * (topRight - topLeft) + yLerp * (bottomRight - bottomLeft)

            imageGradY *= inputGradientWeight
            imageGradX *= inputGradientWeight

            OutputROIGradientTensor[roiIndex][0] += imageGradX * (inputWidth - inputGradientCoordinate.x)
            OutputROIGradientTensor[roiIndex][1] += imageGradY * (inputHeight - inputGradientCoordinate.y)
            OutputROIGradientTensor[roiIndex][2] += imageGradX * inputGradientCoordinate.x
            OutputROIGradientTensor[roiIndex][3] += imageGradY * inputGradientCoordinate.y

OutputGradientTensor ou OutputROIGradientTensor podem ser omitidos se apenas um for necessário; mas pelo menos um deve ser fornecido.

Sintaxe

struct DML_ROI_ALIGN_GRAD_OPERATOR_DESC {
  const DML_TENSOR_DESC  *InputTensor;
  const DML_TENSOR_DESC  *InputGradientTensor;
  const DML_TENSOR_DESC  *ROITensor;
  const DML_TENSOR_DESC  *BatchIndicesTensor;
  const DML_TENSOR_DESC  *OutputGradientTensor;
  const DML_TENSOR_DESC  *OutputROIGradientTensor;
  DML_REDUCE_FUNCTION    ReductionFunction;
  DML_INTERPOLATION_MODE InterpolationMode;
  FLOAT                  SpatialScaleX;
  FLOAT                  SpatialScaleY;
  FLOAT                  InputPixelOffset;
  FLOAT                  OutputPixelOffset;
  UINT                   MinimumSamplesPerOutput;
  UINT                   MaximumSamplesPerOutput;
  BOOL                   AlignRegionsToCorners;
};

Membros

InputTensor

Tipo: _Maybenull_ const DML_TENSOR_DESC*

Um tensor que contém os dados de entrada do passe para frente com dimensões { BatchCount, ChannelCount, InputHeight, InputWidth }. Este tensor deve ser fornecido quando OutputROIGradientTensor for fornecido ou quando ReductionFunction == DML_REDUCE_FUNCTION_MAX. Este é o mesmo tensor que seria fornecido para InputTensor para DML_OPERATOR_ROI_ALIGN ou DML_OPERATOR_ROI_ALIGN1.

InputGradientTensor

Tipo: const DML_TENSOR_DESC*

ROITensor

Tipo: const DML_TENSOR_DESC*

Um tensor que contém os dados de ROI (regiões de interesse) — uma série de caixas delimitadoras em coordenadas de ponto flutuante que apontam para as dimensões X e Y do tensor de entrada. As dimensões permitidas de ROITensor são { NumROIs, 4 }, { 1, NumROIs, 4 }ou { 1, 1, NumROIs, 4 }. Para cada ROI, os valores serão as coordenadas de seus cantos superior esquerdo e inferior direito na ordem [x1, y1, x2, y2]. As regiões podem estar vazias, o que significa que todos os pixels de saída vêm da coordenada de entrada única e as regiões podem ser invertidas (por exemplo, x2 a menos que x1), o que significa que a saída recebe uma versão espelhada/invertida da entrada. Essas coordenadas são dimensionadas primeiro por SpatialScaleX e SpatialScaleY, mas se ambas forem 1,0, os retângulos da região simplesmente corresponderão diretamente às coordenadas tensores de entrada. Este é o mesmo tensor que seria fornecido para ROITensor para DML_OPERATOR_ROI_ALIGN ou DML_OPERATOR_ROI_ALIGN1.

BatchIndicesTensor

Tipo: const DML_TENSOR_DESC*

Um tensor que contém os índices de lote dos quais extrair os ROIs. As dimensões permitidas de BatchIndicesTensor são { NumROIs }, { 1, NumROIs }, { 1, 1, NumROIs }ou { 1, 1, 1, NumROIs }. Cada valor é o índice de um lote de InputTensor. O comportamento será indefinido se os valores não estiverem no intervalo [0, BatchCount). Este é o mesmo tensor que seria fornecido para BatchIndicesTensor para DML_OPERATOR_ROI_ALIGN ou DML_OPERATOR_ROI_ALIGN1.

OutputGradientTensor

Tipo: _Maybenull_ const DML_TENSOR_DESC*

Um tensor de saída que contém os gradientes com backpropagated em relação a InputTensor. Normalmente, esse tensor teria os mesmos tamanhos que o de entrada do DML_OPERATOR_ROI_ALIGN1 correspondente no passe para frente. Se OutputROIGradientTensor não for fornecido, OutputGradientTensordeverá ser fornecido.

OutputROIGradientTensor

Tipo: _Maybenull_ const DML_TENSOR_DESC*

Um tensor de saída que contém os gradientes com backpropagated em relação a ROITensor. Esse tensor precisa ter os mesmos tamanhos que ROITensor. Se OutputGradientTensor não for fornecido, OutputROIGradientTensordeverá ser fornecido.

ReductionFunction

Tipo: DML_REDUCE_FUNCTION

Consulte DML_ROI_ALIGN1_OPERATOR_DESC::ReductionFunction.

InterpolationMode

Tipo: DML_INTERPOLATION_MODE

Consulte DML_ROI_ALIGN1_OPERATOR_DESC::InterpolationMode.

SpatialScaleX

Tipo: float

Consulte DML_ROI_ALIGN1_OPERATOR_DESC::SpatialScaleX.

SpatialScaleY

Tipo: float

Consulte DML_ROI_ALIGN1_OPERATOR_DESC::SpatialScaleY.

InputPixelOffset

Tipo: float

Consulte DML_ROI_ALIGN1_OPERATOR_DESC::InputPixelOffset.

OutputPixelOffset

Tipo: float

Consulte DML_ROI_ALIGN1_OPERATOR_DESC::OutputPixelOffset.

MinimumSamplesPerOutput

Tipo: UINT

Consulte DML_ROI_ALIGN1_OPERATOR_DESC::MinimumSamplesPerOutput.

MaximumSamplesPerOutput

Tipo: UINT

Consulte DML_ROI_ALIGN1_OPERATOR_DESC::MaximumSamplesPerOutput.

AlignRegionsToCorners

Tipo: BOOL

Consulte DML_ROI_ALIGN1_OPERATOR_DESC::AlignRegionsToCorners.

Observações

Disponibilidade

Este operador foi introduzido no DML_FEATURE_LEVEL_4_1.

Restrições do Tensor

InputGradientTensor, InputTensor, OutputGradientTensor, OutputROIGradientTensore ROITensor devem ter o mesmo datatype.

Suporte ao Tensor

DML_FEATURE_LEVEL_4_1 e superior

Requisitos