urbanlc.model.pipeline_transforms.AppendBUI#

class urbanlc.model.pipeline_transforms.AppendBUI(index_a: int, index_b: int)#

Compute the Built-Up Index (BUI) for PyTorch Tensor.

Attributes

T_destination

alias of TypeVar('T_destination', bound=Dict[str, Any])

dump_patches

transform_matrix

Methods

add_module(name, module)

Adds a child module to the current module.

apply(fn)

Applies fn recursively to every submodule (as returned by .children()) as well as self.

apply_func(in_tensor, params[, flags])

apply_non_transform(input, params, flags[, ...])

apply_non_transform_box(input, params, flags)

Process boxes corresponding to the inputs that are no transformation applied.

apply_non_transform_boxes(input, params, flags)

apply_non_transform_class(input, params, flags)

Process class tags corresponding to the inputs that are no transformation applied.

apply_non_transform_keypoint(input, params, ...)

Process keypoints corresponding to the inputs that are no transformation applied.

apply_non_transform_mask(input, params, flags)

Process masks corresponding to the inputs that are no transformation applied.

apply_transform(input, params, flags[, ...])

Compute the Built-Up Index (BUI) for PyTorch Tensor.

apply_transform_box(input, params, flags[, ...])

Process boxes corresponding to the inputs that are transformed.

apply_transform_boxes(input, params, flags)

apply_transform_class(input, params, flags)

Process class tags corresponding to the inputs that are transformed.

apply_transform_keypoint(input, params, flags)

Process keypoints corresponding to the inputs that are transformed.

apply_transform_mask(input, params, flags[, ...])

Process masks corresponding to the inputs that are transformed.

bfloat16()

Casts all floating point parameters and buffers to bfloat16 datatype.

buffers([recurse])

Returns an iterator over module buffers.

children()

Returns an iterator over immediate children modules.

compute_transformation(input, params, flags)

cpu()

Moves all model parameters and buffers to the CPU.

cuda([device])

Moves all model parameters and buffers to the GPU.

double()

Casts all floating point parameters and buffers to double datatype.

eval()

Sets the module in evaluation mode.

extra_repr()

Set the extra representation of the module

float()

Casts all floating point parameters and buffers to float datatype.

forward(input[, params])

Perform forward operations.

forward_parameters(batch_shape)

generate_parameters(batch_shape)

generate_transformation_matrix(input, ...)

Generate transformation matrices with the given input and param settings.

get_buffer(target)

Returns the buffer given by target if it exists, otherwise throws an error.

get_extra_state()

Returns any extra state to include in the module's state_dict.

get_parameter(target)

Returns the parameter given by target if it exists, otherwise throws an error.

get_submodule(target)

Returns the submodule given by target if it exists, otherwise throws an error.

half()

Casts all floating point parameters and buffers to half datatype.

identity_matrix(input)

Return 3x3 identity matrix.

inverse_boxes(input, params, flags[, transform])

inverse_classes(input, params, flags[, ...])

inverse_inputs(input, params, flags[, transform])

inverse_keypoints(input, params, flags[, ...])

inverse_masks(input, params, flags[, transform])

ipu([device])

Moves all model parameters and buffers to the IPU.

load_state_dict(state_dict[, strict])

Copies parameters and buffers from state_dict into this module and its descendants.

modules()

Returns an iterator over all modules in the network.

named_buffers([prefix, recurse])

Returns an iterator over module buffers, yielding both the name of the buffer as well as the buffer itself.

named_children()

Returns an iterator over immediate children modules, yielding both the name of the module as well as the module itself.

named_modules([memo, prefix, remove_duplicate])

Returns an iterator over all modules in the network, yielding both the name of the module as well as the module itself.

named_parameters([prefix, recurse])

Returns an iterator over module parameters, yielding both the name of the parameter as well as the parameter itself.

parameters([recurse])

Returns an iterator over module parameters.

register_backward_hook(hook)

Registers a backward hook on the module.

register_buffer(name, tensor[, persistent])

Adds a buffer to the module.

register_forward_hook(hook)

Registers a forward hook on the module.

register_forward_pre_hook(hook)

Registers a forward pre-hook on the module.

register_full_backward_hook(hook)

Registers a backward hook on the module.

register_load_state_dict_post_hook(hook)

Registers a post hook to be run after module's load_state_dict is called.

register_module(name, module)

Alias for add_module().

register_parameter(name, param)

Adds a parameter to the module.

requires_grad_([requires_grad])

Change if autograd should record operations on parameters in this module.

set_extra_state(state)

This function is called from load_state_dict() to handle any extra state found within the state_dict.

set_rng_device_and_dtype(device, dtype)

Change the random generation device and dtype.

share_memory()

See torch.Tensor.share_memory_()

state_dict(*args[, destination, prefix, ...])

Returns a dictionary containing references to the whole state of the module.

to(*args, **kwargs)

Moves and/or casts the parameters and buffers.

to_empty(*, device)

Moves the parameters and buffers to the specified device without copying storage.

train([mode])

Sets the module in training mode.

transform_boxes(input, params, flags[, ...])

transform_classes(input, params, flags[, ...])

transform_inputs(input, params, flags[, ...])

transform_keypoints(input, params, flags[, ...])

transform_masks(input, params, flags[, ...])

transform_output_tensor(output, output_shape)

Standardize output tensors.

transform_tensor(input)

Convert any incoming (H, W), (C, H, W) and (B, C, H, W) into (B, C, H, W).

type(dst_type)

Casts all parameters and buffers to dst_type.

validate_tensor(input)

Check if the input tensor is formatted as expected.

xpu([device])

Moves all model parameters and buffers to the XPU.

zero_grad([set_to_none])

Sets gradients of all model parameters to zero.