fbcode/vision/fair/pytorch3d/pytorch3d/ops/cameras_alignment.py

Reviewed By: sgrigory

Differential Revision: D93710806

fbshipit-source-id: da6c1e1e5b7a1c5cdfbf5026993c42c7ec387415

pytorch3d/common/workaround/symeig3x3.py

@@ -82,10 +82,12 @@ class _SymEig3x3(nn.Module):
         q = inputs_trace / 3.0
 
         # Calculate squared sum of elements outside the main diagonal / 2
-        # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and `int`.
-        p1 = ((inputs**2).sum(dim=(-1, -2)) - (inputs_diag**2).sum(-1)) / 2
-        # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and `int`.
-        p2 = ((inputs_diag - q[..., None]) ** 2).sum(dim=-1) + 2.0 * p1.clamp(self._eps)
+        p1 = (
+            torch.square(inputs).sum(dim=(-1, -2)) - torch.square(inputs_diag).sum(-1)
+        ) / 2
+        p2 = torch.square(inputs_diag - q[..., None]).sum(dim=-1) + 2.0 * p1.clamp(
+            self._eps
+        )
 
         p = torch.sqrt(p2 / 6.0)
         B = (inputs - q[..., None, None] * self._identity) / p[..., None, None]
@@ -104,7 +106,9 @@ class _SymEig3x3(nn.Module):
         # Soft dispatch between the degenerate case (diagonal A) and general.
         # diag_soft_cond -> 1.0 when p1 < 6 * eps and diag_soft_cond -> 0.0 otherwise.
         # We use 6 * eps to take into account the error accumulated during the p1 summation
-        diag_soft_cond = torch.exp(-((p1 / (6 * self._eps)) ** 2)).detach()[..., None]
+        diag_soft_cond = torch.exp(-torch.square(p1 / (6 * self._eps))).detach()[
+            ..., None
+        ]
 
         # Eigenvalues are the ordered elements of main diagonal in the degenerate case
         diag_eigenvals, _ = torch.sort(inputs_diag, dim=-1)
@@ -199,8 +203,7 @@ class _SymEig3x3(nn.Module):
             cross_products[..., :1, :]
         )
 
-        # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and `int`.
-        norms_sq = (cross_products**2).sum(dim=-1)
+        norms_sq = torch.square(cross_products).sum(dim=-1)
         max_norms_index = norms_sq.argmax(dim=-1)
 
         # Pick only the cross-product with highest squared norm for each input

pytorch3d/csrc/pulsar/include/renderer.destruct.device.h

@@ -18,68 +18,89 @@ namespace Renderer {
 
 template <bool DEV>
 HOST void destruct(Renderer* self) {
-  if (self->result_d != NULL)
+  if (self->result_d != NULL) {
     FREE(self->result_d);
+  }
   self->result_d = NULL;
-  if (self->min_depth_d != NULL)
+  if (self->min_depth_d != NULL) {
     FREE(self->min_depth_d);
+  }
   self->min_depth_d = NULL;
-  if (self->min_depth_sorted_d != NULL)
+  if (self->min_depth_sorted_d != NULL) {
     FREE(self->min_depth_sorted_d);
+  }
   self->min_depth_sorted_d = NULL;
-  if (self->ii_d != NULL)
+  if (self->ii_d != NULL) {
     FREE(self->ii_d);
+  }
   self->ii_d = NULL;
-  if (self->ii_sorted_d != NULL)
+  if (self->ii_sorted_d != NULL) {
     FREE(self->ii_sorted_d);
+  }
   self->ii_sorted_d = NULL;
-  if (self->ids_d != NULL)
+  if (self->ids_d != NULL) {
     FREE(self->ids_d);
+  }
   self->ids_d = NULL;
-  if (self->ids_sorted_d != NULL)
+  if (self->ids_sorted_d != NULL) {
     FREE(self->ids_sorted_d);
+  }
   self->ids_sorted_d = NULL;
-  if (self->workspace_d != NULL)
+  if (self->workspace_d != NULL) {
     FREE(self->workspace_d);
+  }
   self->workspace_d = NULL;
-  if (self->di_d != NULL)
+  if (self->di_d != NULL) {
     FREE(self->di_d);
+  }
   self->di_d = NULL;
-  if (self->di_sorted_d != NULL)
+  if (self->di_sorted_d != NULL) {
     FREE(self->di_sorted_d);
+  }
   self->di_sorted_d = NULL;
-  if (self->region_flags_d != NULL)
+  if (self->region_flags_d != NULL) {
     FREE(self->region_flags_d);
+  }
   self->region_flags_d = NULL;
-  if (self->num_selected_d != NULL)
+  if (self->num_selected_d != NULL) {
     FREE(self->num_selected_d);
+  }
   self->num_selected_d = NULL;
-  if (self->forw_info_d != NULL)
+  if (self->forw_info_d != NULL) {
     FREE(self->forw_info_d);
+  }
   self->forw_info_d = NULL;
-  if (self->min_max_pixels_d != NULL)
+  if (self->min_max_pixels_d != NULL) {
     FREE(self->min_max_pixels_d);
+  }
   self->min_max_pixels_d = NULL;
-  if (self->grad_pos_d != NULL)
+  if (self->grad_pos_d != NULL) {
     FREE(self->grad_pos_d);
+  }
   self->grad_pos_d = NULL;
-  if (self->grad_col_d != NULL)
+  if (self->grad_col_d != NULL) {
     FREE(self->grad_col_d);
+  }
   self->grad_col_d = NULL;
-  if (self->grad_rad_d != NULL)
+  if (self->grad_rad_d != NULL) {
     FREE(self->grad_rad_d);
+  }
   self->grad_rad_d = NULL;
-  if (self->grad_cam_d != NULL)
+  if (self->grad_cam_d != NULL) {
     FREE(self->grad_cam_d);
+  }
   self->grad_cam_d = NULL;
-  if (self->grad_cam_buf_d != NULL)
+  if (self->grad_cam_buf_d != NULL) {
     FREE(self->grad_cam_buf_d);
+  }
   self->grad_cam_buf_d = NULL;
-  if (self->grad_opy_d != NULL)
+  if (self->grad_opy_d != NULL) {
     FREE(self->grad_opy_d);
+  }
   self->grad_opy_d = NULL;
-  if (self->n_grad_contributions_d != NULL)
+  if (self->n_grad_contributions_d != NULL) {
     FREE(self->n_grad_contributions_d);
+  }
   self->n_grad_contributions_d = NULL;
 }
 

pytorch3d/csrc/pulsar/include/renderer.norm_sphere_gradients.device.h

@@ -64,8 +64,9 @@ GLOBAL void norm_sphere_gradients(Renderer renderer, const int num_balls) {
   // The sphere only contributes to the camera gradients if it is
   // large enough in screen space.
   if (renderer.ids_sorted_d[idx] > 0 && ii.max.x >= ii.min.x + 3 &&
-      ii.max.y >= ii.min.y + 3)
+      ii.max.y >= ii.min.y + 3) {
     renderer.ids_sorted_d[idx] = 1;
+  }
   END_PARALLEL_NORET();
 };
 

pytorch3d/csrc/pulsar/include/renderer.render.device.h

@@ -139,8 +139,9 @@ GLOBAL void render(
       coord_y < cam_norm.film_border_top + cam_norm.film_height) {
     // Initialize the result.
     if (mode == 0u) {
-      for (uint c_id = 0; c_id < cam_norm.n_channels; ++c_id)
+      for (uint c_id = 0; c_id < cam_norm.n_channels; ++c_id) {
         result[c_id] = bg_col[c_id];
+      }
     } else {
       result[0] = 0.f;
     }
@@ -190,20 +191,22 @@ GLOBAL void render(
             "render|found intersection with sphere %u.\n",
             sphere_id_l[write_idx]);
       }
-      if (ii.min.x == MAX_USHORT)
+      if (ii.min.x == MAX_USHORT) {
         // This is an invalid sphere (out of image). These spheres have
         // maximum depth. Since we ordered the spheres by earliest possible
         // intersection depth we re certain that there will no other sphere
         // that is relevant after this one.
         loading_done = true;
+      }
     }
     // Reset n_pixels_done.
     n_pixels_done = 0;
     thread_block.sync(); // Make sure n_loaded is updated.
     if (n_loaded > RENDER_BUFFER_LOAD_THRESH) {
       // The load buffer is full enough. Draw.
-      if (thread_block.thread_rank() == 0)
+      if (thread_block.thread_rank() == 0) {
         n_balls_loaded += n_loaded;
+      }
       max_closest_possible_intersection = 0.f;
       // This excludes threads outside of the image boundary. Also, it reduces
       // block artifacts.
@@ -290,8 +293,9 @@ GLOBAL void render(
       uint warp_done = thread_warp.ballot(done);
       int warp_done_bit_cnt = POPC(warp_done);
 #endif //__CUDACC__ && __HIP_PLATFORM_AMD__
-      if (thread_warp.thread_rank() == 0)
+      if (thread_warp.thread_rank() == 0) {
         ATOMICADD_B(&n_pixels_done, warp_done_bit_cnt);
+      }
       // This sync is necessary to keep n_loaded until all threads are done with
       // painting.
       thread_block.sync();
@@ -299,8 +303,9 @@ GLOBAL void render(
     }
     thread_block.sync();
   }
-  if (thread_block.thread_rank() == 0)
+  if (thread_block.thread_rank() == 0) {
     n_balls_loaded += n_loaded;
+  }
   PULSAR_LOG_DEV_PIX(
       PULSAR_LOG_RENDER_PIX,
       "render|loaded %d balls in total.\n",
@@ -386,8 +391,9 @@ GLOBAL void render(
             static_cast<float>(tracker.get_n_hits());
   } else {
     float sm_d_normfac = FRCP(FMAX(sm_d, FEPS));
-    for (uint c_id = 0; c_id < cam_norm.n_channels; ++c_id)
+    for (uint c_id = 0; c_id < cam_norm.n_channels; ++c_id) {
       result[c_id] *= sm_d_normfac;
+    }
     int write_loc = (coord_y - cam_norm.film_border_top) * cam_norm.film_width *
             (3 + 2 * n_track) +
         (coord_x - cam_norm.film_border_left) * (3 + 2 * n_track);

pytorch3d/csrc/pulsar/pytorch/renderer.cpp

@@ -860,8 +860,9 @@ std::tuple<torch::Tensor, torch::Tensor> Renderer::forward(
             ? (cudaStream_t) nullptr
 #endif
             : (cudaStream_t) nullptr);
-    if (mode == 1)
+    if (mode == 1) {
       results[batch_i] = results[batch_i].slice(2, 0, 1, 1);
+    }
     forw_infos[batch_i] = from_blob(
         this->renderer_vec[batch_i].forw_info_d,
         {this->renderer_vec[0].cam.film_height,

pytorch3d/csrc/pulsar/pytorch/renderer.h

@@ -128,8 +128,9 @@ struct Renderer {
     stream << "pulsar::Renderer[";
     // Device info.
     stream << self.device_type;
-    if (self.device_index != -1)
+    if (self.device_index != -1) {
       stream << ", ID " << self.device_index;
+    }
     stream << "]";
     return stream;
   }

pytorch3d/csrc/rasterize_meshes/rasterize_meshes_cpu.cpp

@@ -106,6 +106,8 @@ auto ComputeFaceAreas(const torch::Tensor& face_verts) {
   return face_areas;
 }
 
+namespace {
+
 // Helper function to use with std::find_if to find the index of any
 // values in the top k struct which match a given idx.
 struct IsNeighbor {
@@ -118,7 +120,6 @@ struct IsNeighbor {
   int neighbor_idx;
 };
 
-namespace {
 void RasterizeMeshesNaiveCpu_worker(
     const int start_yi,
     const int end_yi,

pytorch3d/ops/cameras_alignment.py

@@ -223,8 +223,7 @@ def _align_camera_extrinsics(
         # of centered A and centered B
         Ac = A - Amu
         Bc = B - Bmu
-        # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and `int`.
-        align_t_s = (Ac * Bc).mean() / (Ac**2).mean().clamp(eps)
+        align_t_s = (Ac * Bc).mean() / torch.square(Ac).mean().clamp(eps)
     else:
         # set the scale to identity
         align_t_s = 1.0

pytorch3d/ops/points_alignment.py

@@ -182,8 +182,7 @@ def iterative_closest_point(
         t_history.append(SimilarityTransform(R, T, s))
 
         # compute the root mean squared error
-        # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and `int`.
-        Xt_sq_diff = ((Xt - Xt_nn_points) ** 2).sum(2)
+        Xt_sq_diff = torch.square(Xt - Xt_nn_points).sum(2)
         rmse = oputil.wmean(Xt_sq_diff[:, :, None], mask_X).sqrt()[:, 0, 0]
 
         # compute the relative rmse

pytorch3d/ops/sample_farthest_points.py

@@ -179,9 +179,7 @@ def sample_farthest_points_naive(
             # and all the other points. If a point has already been selected
             # it's distance will be 0.0 so it will not be selected again as the max.
             dist = points[n, selected_idx, :] - points[n, : lengths[n], :]
-            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
-            #  `int`.
-            dist_to_last_selected = (dist**2).sum(-1)  # (P - i)
+            dist_to_last_selected = torch.square(dist).sum(-1)  # (P - i)
 
             # If closer than currently saved distance to one of the selected
             # points, then updated closest_dists

pytorch3d/renderer/splatter_blend.py

@@ -132,15 +132,13 @@ def _get_splat_kernel_normalization(
 
     epsilon = 0.05
     normalization_constant = torch.exp(
-        # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and `int`.
-        -(offsets**2).sum(dim=1) / (2 * sigma**2)
+        -torch.square(offsets).sum(dim=1) / (2 * sigma**2)
     ).sum()
 
     # We add an epsilon to the normalization constant to ensure the gradient will travel
     # through non-boundary pixels' normalization factor, see Sec. 3.3.1 in "Differentia-
     # ble Surface Rendering via Non-Differentiable Sampling", Cole et al.
-    # pyre-fixme[58]: `/` is not supported for operand types `float` and `Tensor`.
-    return (1 + epsilon) / normalization_constant
+    return torch.div(1 + epsilon, normalization_constant)
 
 
 def _compute_occlusion_layers(
@@ -264,8 +262,9 @@ def _compute_splatting_colors_and_weights(
         torch.floor(pixel_coords_screen[..., :2]) - pixel_coords_screen[..., :2] + 0.5
     ).view((N, H, W, K, 1, 2))
 
-    # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and `int`.
-    dist2_p_q = torch.sum((q_to_px_center + offsets) ** 2, dim=5)  # (N, H, W, K, 9)
+    dist2_p_q = torch.sum(
+        torch.square(q_to_px_center + offsets), dim=5
+    )  # (N, H, W, K, 9)
     splat_weights = torch.exp(-dist2_p_q / (2 * sigma**2))
     alpha = colors[..., 3:4]
     splat_weights = (alpha * splat_kernel_normalization * splat_weights).unsqueeze(
@@ -417,12 +416,12 @@ def _normalize_and_compose_all_layers(
     device = splatted_colors_per_occlusion_layer.device
 
     # Normalize each of bg/surface/fg splat layers separately.
-    normalization_scales = 1.0 / (
-        # pyre-fixme[58]: `/` is not supported for operand types `float` and `Tensor`.
+    normalization_scales = torch.div(
+        1.0,
         torch.maximum(
             splatted_weights_per_occlusion_layer,
             torch.tensor([1.0], device=device),
-        )
+        ),
     )  # (N, H, W, 1, 3)
 
     normalized_splatted_colors = (

pytorch3d/transforms/se3.py

@@ -195,15 +195,15 @@ def _se3_V_matrix(
     V = (
         torch.eye(3, dtype=log_rotation.dtype, device=log_rotation.device)[None]
         + log_rotation_hat
-        # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and `int`.
-        * ((1 - torch.cos(rotation_angles)) / (rotation_angles**2))[:, None, None]
+        * ((1 - torch.cos(rotation_angles)) / torch.square(rotation_angles))[
+            :, None, None
+        ]
         + (
             log_rotation_hat_square
-            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
-            #  `int`.
-            * ((rotation_angles - torch.sin(rotation_angles)) / (rotation_angles**3))[
-                :, None, None
-            ]
+            * (
+                (rotation_angles - torch.sin(rotation_angles))
+                / torch.pow(rotation_angles, 3)
+            )[:, None, None]
         )
     )
 
@@ -215,8 +215,7 @@ def _get_se3_V_input(log_rotation: torch.Tensor, eps: float = 1e-4):
     A helper function that computes the input variables to the `_se3_V_matrix`
     function.
     """
-    # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and `int`.
-    nrms = (log_rotation**2).sum(-1)
+    nrms = torch.square(log_rotation).sum(-1)
     rotation_angles = torch.clamp(nrms, eps).sqrt()
     log_rotation_hat = hat(log_rotation)
     log_rotation_hat_square = torch.bmm(log_rotation_hat, log_rotation_hat)