code: def matrix_to_quaternion(matrix: torch.Tensor) -> torch.Tensor:
      """
      Convert rotations given as rotation matrices to quaternions.
  
      Args:
          matrix: Rotation matrices as tensor of shape (..., 3, 3).
  
      Returns:
          quaternions with real part first, as tensor of shape (..., 4).
      """
      if matrix.size(-1) != 3 or matrix.size(-2) != 3:
          raise ValueError(
              f"Invalid rotation matrix shape {matrix.shape}."
          )
  
      batch_dim = matrix.shape[:-2]
      m00, m01, m02, m10, m11, m12, m20, m21, m22 = torch.unbind(
          matrix.reshape(batch_dim + (9,)), dim=-1
      )
  
      q_abs = _sqrt_positive_part(
          torch.stack(
              [
                  1.0 + m00 + m11 + m22,
                  1.0 + m00 - m11 - m22,
                  1.0 - m00 + m11 - m22,
                  1.0 - m00 - m11 + m22,
              ],
              dim=-1,
          )
      )
  
      # we produce the desired quaternion multiplied by each of r, i, j, k
      quat_by_rijk = torch.stack(
          [
              # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
              #  `int`.
              torch.stack(
                  [q_abs[..., 0] ** 2, m21 - m12, m02 - m20, m10 - m01],
                  dim=-1,
              ),
              # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
              #  `int`.
              torch.stack(
                  [m21 - m12, q_abs[..., 1] ** 2, m10 + m01, m02 + m20],
                  dim=-1,
              ),
              # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
              #  `int`.
              torch.stack(
                  [m02 - m20, m10 + m01, q_abs[..., 2] ** 2, m12 + m21],
                  dim=-1,
              ),
              # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
              #  `int`.
              torch.stack(
                  [m10 - m01, m20 + m02, m21 + m12, q_abs[..., 3] ** 2],
                  dim=-1,
              ),
          ],
          dim=-2,
      )
  
      # We floor here at 0.1 but the exact level is not important; if q_abs is small,
      # the candidate won't be picked.
      flr = torch.tensor(0.1).to(dtype=q_abs.dtype, device=q_abs.device)
      quat_candidates = quat_by_rijk / (2.0 * q_abs[..., None].max(flr))
  
      # if not for numerical problems, quat_candidates[i] should be same (up to a sign),
      # forall i; we pick the best-conditioned one (with the largest denominator)
      out = quat_candidates[
          F.one_hot(q_abs.argmax(dim=-1), num_classes=4) > 0.5, :
      ].reshape(batch_dim + (4,))
      return standardize_quaternion(out)
  
imports: from typing import Optional
  import torch
  import torch.nn.functional
  from ..common.datatypes import Device
label_desc: Use image node_id 4 for calling a global function with example usage: matrix_to_quaternion(matrix) and returns: standardize_quaternion