Exemple #1
0
    def vertices3d_to_box3d(vertices: Tensor):
        center = vertices.sum(axis=0)
        # right upper left lower in xy plane
        right_index, far_index, high_index = vertices.argmax(axis=0)
        left_index, _, low_index = vertices.argmin(axis=0)
        x_right, y_right, _ = vertices[right_index]
        x_far, y_far, _ = vertices[far_index]
        x_left, y_left, _ = vertices[left_index]
        _, _, z_high = vertices[high_index]
        _, _, z_low = vertices[low_index]

        far_right_x_delta = np.abs(x_right - x_far)
        far_right_y_delta = np.abs(y_right - y_far)
        far_left_x_delta = np.abs(x_left - x_far)
        far_left_y_delta = np.abs(y_left - y_far)
        angle = np.arctan(far_right_x_delta / far_right_y_delta)  #TODO atan2
        y_size = np.sqrt(far_right_x_delta**2 + far_right_y_delta**2)
        x_size = np.sqrt(far_left_x_delta**2 + far_left_y_delta**2)
        z_size = z_high - z_low

        extent = torch.tensor([x_size, y_size, z_size])
        angle = torch.tensor([angle])
        box = torch.cat((center, extent, angle), dim=0)

        return box
def _extremity_game_target_function(context: torch.Tensor,
                                    function_selectors: torch.Tensor,
                                    target_type) -> torch.Tensor:

    func_idxs = function_selectors.argmax(dim=1)
    func_min_or_max = func_idxs % 2
    param_idxs = func_idxs // 2

    min_obj_per_param = context.argmin(
        dim=1)  # index of min property along the row (index of the object)
    max_obj_per_param = context.argmax(dim=1)

    targets = []
    targets2 = []  # previous targets
    for batch in range(context.shape[0]):
        num_object = context.size()[1]
        if func_min_or_max[batch] == 0:
            # batch = batch id
            # min_obj_per_param[batch][param_idxs[batch]]: index of min
            targets2.append(
                context[batch, min_obj_per_param[batch][param_idxs[batch]]])

            # MY CODE
            t_id = torch.zeros(num_object).long()
            o_id = min_obj_per_param[batch][param_idxs[batch]]  # object id
            t_id[o_id] = 1  # one-hot tensor
            targets.append(o_id)
            # print("min_obj_per_param[batch][param_idxs[batch]]: ", min_obj_per_param[batch][param_idxs[batch]])
        else:
            targets2.append(
                context[batch, max_obj_per_param[batch][param_idxs[batch]]])
            # MY CODE
            t_id = torch.zeros(num_object).long()
            o_id = max_obj_per_param[batch][param_idxs[batch]]  # object id

            t_id[o_id] = 1  # one-hot tensor
            targets.append(o_id)
            # print(" max_obj_per_param[batch][param_idxs[batch]]: ", max_obj_per_param[batch][param_idxs[batch]])
    # print("context: ", context)
    # print("targets: ", targets)
    # print("targets2: ", targets2)
    # print(" torch.stack(targets)", torch.stack(targets))
    # print("torch.stack(targets2) : ", torch.stack(targets2) )

    if target_type == "target_properties":
        return torch.stack(targets2)  #
    elif target_type == "target_id":  # target_id
        return torch.stack(targets)
    else:
        print("invalid target type")
        exit()
Exemple #3
0
    def find_bmus(self, distances: torch.Tensor) -> torch.Tensor:
        """
        Find BMU for each batch in `distances`.

        Parameters
        ----------
        distances : torch.Tensor
            The data-to-codebook distances.
        """
        # distances shape: [bs, codebook_size]
        # argmin shape   : [bs, 1]
        min_idxs = distances.argmin(-1)
        # Distances are flattened, so we need to transform 1d indices into 2d map locations
        return idxs_1d_to_2d(min_idxs, self.size[1]).to(distances.device)
Exemple #4
0
def _extremity_game_target_function(
        context: torch.Tensor,
        function_selectors: torch.Tensor) -> torch.Tensor:
    func_idxs = function_selectors.argmax(dim=1)
    func_min_or_max = func_idxs % 2
    param_idxs = func_idxs // 2

    min_obj_per_param = context.argmin(dim=1)
    max_obj_per_param = context.argmax(dim=1)

    targets = []
    for batch in range(context.shape[0]):
        if func_min_or_max[batch] == 0:
            targets.append(
                context[batch, min_obj_per_param[batch][param_idxs[batch]]])
        else:
            targets.append(
                context[batch, max_obj_per_param[batch][param_idxs[batch]]])
    return torch.stack(targets)
Exemple #5
0
 def update(self, pixel_error: torch.Tensor):
     if not self.is_fixed:
         self.optimal_id = pixel_error.argmin()