Minkowski坐标管理

Minkowski坐标管理

坐标键

classMinkowskiEngine.CoordsKey（D）

__init__（D）

初始化self. See help(type(self))有关准确的签名。

getKey（）

getTensorStride（）

isKeySet（）

setKey（key）

setTensorStride（tensor_stride）

坐标管理器

Class MinkowskiEngine.CoordsManager（num_threads ： int = -1，memory_manager_backend ： MinkowskiEngineBackend.MemoryManagerBackend = None，D ： int = -1）

__init__（num_threads ： int = -1，memory_manager_backend ： MinkowskiEngineBackend.MemoryManagerBackend = None，D ： int = -1）

初始化self. See help(type(self))有关准确的签名。

create_coords_key（COORDS ： torch.IntTensor，tensor_stride ： INT = 1，force_creation ： BOOL = False，force_remap ： BOOL = False，allow_duplicate_coords ： BOOL = False） → MinkowskiCoords.CoordsKey

get_batch_indices（）

get_batch_size（）

get_coords（coords_key_or_tensor_strides）

get_coords_map（in_key_or_tensor_strides，out_key_or_tensor_strides）

提取映射到输出坐标索引的输入坐标索引。

sp_tensor = ME.SparseTensor(features, coords=coordinates)

out_sp_tensor = stride_2_conv(sp_tensor)

 

cm = sp_tensor.coords_man

# cm = out_sp_tensor.coords_man  # doesn't matter which tensor you pick

ins, outs = cm.get_coords_map(1,  # in stride

                              2)  # out stride

for i, o in zip(ins, outs):

   print(f"{i} -> {o}")

get_coords_size_by_coords_key（coords_key）

get_kernel_map（in_key_or_tensor_strides，out_key_or_tensor_strides，stride = 1，kernel_size = 3，dilation = 1，region_type = 0，region_offset = None，is_transpose = False，is_pool = False，on_gpu = False）

获取指定坐标键或张量stride的内核出入映射。

get_mapping_by_tensor_strides（in_tensor_strides，out_tensor_strides）

get_row_indices_at（coords_key，batch_index）

返回指定批处理索引的torch.LongTensor行索引

sp_tensor = ME.SparseTensor(features, coords=coordinates)

row_indices = sp_tensor.coords_man.get_row_indices_at(sp_tensor.coords_key, batch_index)

get_row_indices_per_batch（coords_key，out_coords_key =None）

返回每个批次的行索引List。

相应的批处理索引可通过get_batch_indices访问。

sp_tensor = ME.SparseTensor(features, coords=coordinates)

row_indices = sp_tensor.coords_man.get_row_indices_per_batch(sp_tensor.coords_key)

get_union_map（in_keys ： List[ MinkowskiCoords.CoordsKey ]，out_key ： MinkowskiCoords.CoordsKey）

生成坐标集的并集，并将映射从输入集返回到新的输出坐标。

精氨酸：

in_keys （List [CoordsKey]）：在其上创建并集的坐标键List。

out_key （CoordsKey）：生成的并列坐标散列图的坐标键的占位符。

返回值：

in_maps（List [Tensor [int]]）：长张量的List，其中包含从输入到联合输出的映射。请参阅示例以获取更多详细信息。 out_maps（List [Tensor [int]]）：长张量的List，其中包含从输入到联合输出的映射。请参阅示例以获取更多详细信息。

例：

>>> # Adding two sparse tensors: A, B

>>> out_key = CoordsKey(coords_man.D)

>>> ins, outs = coords_man.get_union_map((A.coords_key, B.coords_key), out_key)

>>> N = coords_man.get_coords_size_by_coords_key(out_key)

>>> out_F = torch.zeros((N, A.F.size(1)), dtype=A.dtype)

>>> out_F[outs[0]] = A.F[ins[0]]

>>> out_F[outs[1]] += B.F[ins[1]]

initialize（COORDS ： torch.IntTensor，coords_key ： MinkowskiCoords.CoordsKey，force_creation ： BOOL = False，force_remap ： BOOL = False，allow_duplicate_coords ： BOOL = False，return_inverse ： BOOL = False） →torch.LongTensor

permute_label（label，max_label，target_tensor_stride，label_tensor_stride = 1）

print_diagnostics（coords_key ： MinkowskiCoords.CoordsKey）

reduce（）

set_origin_coords_key（coords_key ： MinkowskiCoords.CoordsKey）

stride（coords_key ： MinkowskiCoords.CoordsKey，stride： Union [ int ， collections.abc.Sequence ， numpy.ndarray ， Torch.Tensor ]，force_creation ： bool = False）

transposed_stride（coords_key ： MinkowskiCoords.CoordsKey，stride： Union [ int ， collections.abc.Sequence ， numpy.ndarray ， torch.Tensor ]，kernel_size ： Union [ int ， collections.abc.Sequence ， numpy.ndarray ， torch.Tensor ]，dilation： Union [ int ， collections.abc.Sequence ， numpy.ndarray ， Torch.Tensor ]，force_creation ： bool = False）

坐标GPU内存管理器

classMinkowskiEngine.MemoryManagerBackend

Members:

CUDA

PYTORCH

property name

(self: handle) -> str

 MinkowskiEngine.MinkowskiCoords.set_memory_manager_backend(backend:MinkowskiEngineBackend.MemoryManagerBackend)

设置GPU内存管理器后端

默认情况下，Minkowski引擎将使用pytorch内存池分配临时GPU内存插槽。这使pytorch后端可以有效地重用pytorch后端和Minkowski引擎之间共享的内存池。给定固定的GPU内存，它倾向于允许以较大的批处理量进行训练。但是，pytorch内存管理器往往比直接使用原始CUDA调用分配GPU慢。

默认情况下，Minkowski引擎 ME.MemoryManagerBackend.PYTORCH用于内存管理。

例：

>>> import MinkowskiEngine as ME

>>> # Set the GPU memory manager backend to raw CUDA calls

>>> ME.set_memory_manager_backend(ME.MemoryManagerBackend.CUDA)

>>> # Set the GPU memory manager backend to the pytorch memory pool

>>> ME.set_memory_manager_backend(ME.MemoryManagerBackend.PYTORCH)