I am trying to implement the backward / gradient pass for the following kernel.
It’s basically an image tensor of [3, H, W] which is split up as org_cloud_x_ptr, org_cloud_y_ptr, org_cloud_z_ptr. And I am iterating through it, checking its neighbourhood, and computing 6 additional tensors of which combined is [6, H, W] which is split up as dxdz_tensor.., which is basically the output of the method. The method is something like below:
// Iterate Image
for (auto yy = 0; yy < height; yy++) {
for (auto xx = 0; xx < width; xx++) {
const float bad_point = std::numeric_limits<float>::quiet_NaN();
const int index = yy * width + xx;
const float px = org_cloud_x_ptr[index];
const float py = org_cloud_y_ptr[index];
const float pz = org_cloud_z_ptr[index];
// Kernel Local Neighbourhood search
for (auto v = yy - search_size; v <= yy + search_size; v += step_size) {
for (auto u = xx - search_size; u <= xx + search_size; u += step_size) {
if (u < 0 || u >= width || v < 0 || v >= height)
continue;
const int index2 = v * width + u;
const float qx = org_cloud_x_ptr[index2];
const float qy = org_cloud_y_ptr[index2];
const float qz = org_cloud_z_ptr[index2];
if (std::isnan(qx) || qz == 0)
continue;
const float dz = qz - pz;
const float dx = qx - px;
const float dy = qy - py;
dxdx_sum += f * dx * dx;
dxdy_sum += f * dx * dy;
dydy_sum += f * dy * dy;
dxdz_sum += f * dx * dz;
dydz_sum += f * dy * dz;
}
}
// Set
dxdz_tensor[index] = dxdx_sum
...
}
}
How would I even start to think about how to write a backward pass / gradient for this?