Reduce the sum and square-sum, compute the statistics, and broadcast it.

Run all_gather on tensors Args: data: any tensor Returns: list[data]: list of data gathered from each rank

Gathers picklable objects from the whole group and returns a list to each caller. Arguments: object (Any): Object to be broadcast fro

input: grad_out: (m, c, nsample) output: (n, c), None

input: grad_out: (n, nsample, c) output: grad_input1: (n, c), grad_input2: (n, c)

input: grad_out: (n, c) output: grad_input: (n, c), grad_position: (n, nsample, c), grad_weight : (n, nsample, c')

input: xyz: (m, 3), new_xyz: (n, 3), input: (m, c), offset: (b), new_offset: (b) output: (n, c)

input: grad_out: (m, c, nsample) output: (n, c), None

input: grad_out: (n, nsample, c) output: grad_input1: (n, c), grad_input2: (n, c)

input: grad_out: (n, c) output: grad_input: (n, c), grad_position: (n, nsample, c), grad_weight : (n, nsample, c')

input: xyz: (m, 3), new_xyz: (n, 3), input: (m, c), offset: (b), new_offset: (b) output: (n, c)

input: grad_out: (n, nsample, c) output: grad_input1: (n, c), grad_input2: (n, c)

input: grad_out: (n, c) output: grad_input: (n, c), grad_position: (n, nsample, c), grad_weight : (n, nsample, c')

input: xyz: (m, 3), new_xyz: (n, 3), input: (m, c), offset: (b), new_offset: (b) output: (n, c)

================================== ballquery_batch_p ================================== */ input xyz: (n, 3) float input batch_idxs: (n) int input bat

Binary Cross entropy loss logits: [B, H, W] Variable, logits at each pixel (between -\infty and +\infty) labels: [B, H, W] Tensor, bi

Flattens predictions in the batch

input: xyz: (n, 3), offset: (b), new_offset: (b) output: idx: (m)

input: xyz: (n, 3), new_xyz: (m, 3), offset: (b), new_offset: (b) output: idx: (m, nsample), dist2: (m, nsample)

input: input: (n, c), idx : (m, nsample) output: (m, nsample, c)

input: input1: (n, c), input2: (n, c), idx: (n, nsample) output: (n, nsample, c)

input: input: (n, c), position: (n, nsample, c), weight : (n, nsample, c'), idx: (n, nsample) output: (n, c)

input: xyz: (m, 3), new_xyz: (n, 3), input: (m, c), offset: (b), new_offset: (b) output: (n, c)

input: xyz: (n, 3), offset: (b + 1), new_offset: (b) output: idx: (m)

input: xyz: (n, 3), new_xyz: (m, 3), offset: (b+1), new_offset: (b+1) output: idx: (m, nsample), dist2: (m, nsample)

input: input: (n, c), idx : (m, nsample) output: (m, nsample, c)

input: input1: (n, c), input2: (n, c), idx: (n, nsample) output: (n, nsample, c)

input: input: (n, c), position: (n, nsample, c), weight : (n, nsample, c'), idx: (n, nsample) output: (n, c)

input: xyz: (m, 3), new_xyz: (n, 3), input: (m, c), offset: (b), new_offset: (b) output: (n, c)

input: xyz: (n, 3), offset: (b), new_offset: (b) output: idx: (m)

input: xyz: (n, 3), new_xyz: (m, 3), offset: (b), new_offset: (b) output: idx: (m, nsample), dist2: (m, nsample)

input: input: (n, c), idx : (m, nsample) output: (m, nsample, c)

input: input1: (n, c), input2: (n, c), idx: (n, nsample) output: (n, nsample, c)

input: input: (n, c), position: (n, nsample, c), weight : (n, nsample, c'), idx: (n, nsample) output: (n, c)

input: xyz: (m, 3), new_xyz: (n, 3), input: (m, c), offset: (b), new_offset: (b) output: (n, c)

:param ctx: :param coords: long (N, dimension + 1) or (N, dimension) dimension = 3 :param batchsize :param mode: int

:param ctx: :param map_rule: cuda int M * (maxActive + 1) :param feats: cuda float N * C :return: output_feats: cuda

:param ctx: :param feats: cuda float M * C :param map_rule: cuda int M * (maxActive + 1) :param nPoint: int :

:param ctx: :param coords: (n, 3) float :param batch_idxs: (n) int :param batch_offsets: (B+1) int :param rad

:param ctx: :param semantic_label: (N), int :param ball_query_idxs: (nActive), int :param start_len: (N, 2), int

:param ctx: :param feats: (sumNPoint, C) float :param proposals_offset: (nProposal + 1) int :return: output_feats (nP

:param ctx: :param proposals_idx: (sumNPoint), int :param proposals_offset: (nProposal + 1), int :param instance_labe

:param ctx: :param inp: (N, C) float :param offsets: (nProposal + 1) int :return: out (nProposal, C) float

:param ctx: :param inp: (N, C) float :param offsets: (nProposal + 1) int :return: out (nProposal, C) float

:param ctx: :param inp: (N, C) float :param offsets: (nProposal + 1) int :return: out (nProposal, C) float

:param ctx: :param xyz: (n, 3) float :param query_xyz: (m, 3), float :param batch_idxs: (n) int :param query_

Parse a 24-bit integer as a RGB color. I.e. Convert to base 256 Args: index: An int. The first 24 bits will be interpreted as a color.