MinkowskiEngine 包

子包

• MinkowskiEngine.modules 包
  • 子模块
  • MinkowskiEngine.modules.resnet_block 模块
  • MinkowskiEngine.modules.senet_block 模块
  • 模块内容
• MinkowskiEngine.utils 包
  • 子模块
  • MinkowskiEngine.utils.collation 模块
  • MinkowskiEngine.utils.coords 模块
  • MinkowskiEngine.utils.gradcheck 模块
  • MinkowskiEngine.utils.init 模块
  • MinkowskiEngine.utils.quantization 模块
  • 模块内容

子模块

MinkowskiEngine.MinkowskiBroadcast 模块

class MinkowskiEngine.MinkowskiBroadcast.MinkowskiBroadcast

基类: torch.nn.modules.module.Module

将减少的特征广播到所有输入坐标。

\[\mathbf{y}_\mathbf{u} = \mathbf{x}_2 \; \text{for} \; \mathbf{u} \in \mathcal{C}^\text{in}\]

对于所有输入 \(\mathbf{x}_\mathbf{u}\), 逐元素复制值 \(\mathbf{x}_2\)。输出坐标将与输入坐标相同 \(\mathcal{C}^\text{in} = \mathcal{C}^\text{out}\)。第一个输入 \(\mathbf{x}_1\) 仅用于定义输出坐标。

注意

第一个参数采用稀疏张量；第二个参数采用被缩减到原点的特征。这通常可以使用诸如 MinkowskiGlobalPooling 的全局缩减来完成。

forward(input: MinkowskiSparseTensor.SparseTensor, input_glob: MinkowskiSparseTensor.SparseTensor)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiBroadcast.MinkowskiBroadcastAddition

基类: MinkowskiEngine.MinkowskiBroadcast.MinkowskiBroadcastBase

将缩减的特征广播到所有输入坐标。

\[\mathbf{y}_\mathbf{u} = \mathbf{x}_{1, \mathbf{u}} + \mathbf{x}_2 \; \text{for} \; \mathbf{u} \in \mathcal{C}^\text{in}\]

对于所有输入 \(\mathbf{x}_\mathbf{u}\), 加上 \(\mathbf{x}_2\)。输出坐标将与输入坐标相同 \(\mathcal{C}^\text{in} = \mathcal{C}^\text{out}\)。

注意

第一个参数采用稀疏张量；第二个参数采用被缩减到原点的特征。这通常可以使用诸如 MinkowskiGlobalPooling 的全局缩减来完成。

training: bool

class MinkowskiEngine.MinkowskiBroadcast.MinkowskiBroadcastBase(operation_type)

基类: MinkowskiCommon.MinkowskiModuleBase

forward(input: MinkowskiSparseTensor.SparseTensor, input_glob: MinkowskiSparseTensor.SparseTensor)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiBroadcast.MinkowskiBroadcastConcatenation

基类: MinkowskiEngine.MinkowskiBroadcast.MinkowskiBroadcast

将缩减的特征广播到所有输入坐标并连接到输入。

\[\mathbf{y}_\mathbf{u} = [\mathbf{x}_{1,\mathbf{u}}, \mathbf{x}_2] \; \text{for} \; \mathbf{u} \in \mathcal{C}^\text{in}\]

对于所有输入 \(\mathbf{x}_\mathbf{u}\), 连接向量 \(\mathbf{x}_2\)。 \([\cdot, \cdot]\) 是一个连接运算符。输出坐标将与输入坐标相同 \(\mathcal{C}^\text{in} = \mathcal{C}^\text{out}\)。

注意

第一个参数采用稀疏张量；第二个参数采用被缩减到原点的特征。这通常可以使用诸如 MinkowskiGlobalPooling 的全局缩减来完成。

forward(input: MinkowskiSparseTensor.SparseTensor, input_glob: MinkowskiSparseTensor.SparseTensor)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiBroadcast.MinkowskiBroadcastFunction

基类: torch.autograd.function.Function

static backward(ctx, grad_out_feat)

定义一个用于区分操作的公式。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟与 forward() 返回的输出一样多的参数，并且应该返回与 forward() 的输入一样多的张量。每个参数是 w.r.t. 给定输出的梯度，并且每个返回值都应该是 w.r.t. 相应输入的梯度。

上下文可以用于检索在前向传递期间保存的张量。 它还有一个属性 ctx.needs_input_grad，作为一个布尔元组，表示每个输入是否需要梯度。 例如，如果 forward() 的第一个输入需要梯度计算 w.r.t. 输出，则 backward() 将具有 ctx.needs_input_grad[0] = True。

static forward(ctx, input_features: torch.Tensor, input_features_global: torch.Tensor, operation_type: MinkowskiEngineBackend._C.BroadcastMode, in_coords_key: MinkowskiEngineBackend._C.CoordinateMapKey, glob_coords_key: MinkowskiEngineBackend._C.CoordinateMapKey, coords_manager: MinkowskiCoordinateManager.CoordinateManager)

执行操作。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟任意数量的参数（张量或其他类型）。

上下文可以用于存储可在后向传递期间检索的张量。

class MinkowskiEngine.MinkowskiBroadcast.MinkowskiBroadcastMultiplication

基类: MinkowskiEngine.MinkowskiBroadcast.MinkowskiBroadcastBase

将减少的特征广播到所有输入坐标。

\[\mathbf{y}_\mathbf{u} = \mathbf{x}_{1, \mathbf{u}} \times \mathbf{x}_2 \; \text{for} \; \mathbf{u} \in \mathcal{C}^\text{in}\]

对于所有输入 \(\mathbf{x}_\mathbf{u}\), 逐元素乘以 \(\mathbf{x}_2\)。输出坐标将与输入坐标相同 \(\mathcal{C}^\text{in} = \mathcal{C}^\text{out}\)。

注意

第一个参数采用稀疏张量；第二个参数采用被缩减到原点的特征。这通常可以使用诸如 MinkowskiGlobalPooling 的全局缩减来完成。

training: bool

MinkowskiEngine.MinkowskiChannelwiseConvolution 模块

class MinkowskiEngine.MinkowskiChannelwiseConvolution.MinkowskiChannelwiseConvolution(in_channels, kernel_size=- 1, stride=1, dilation=1, bias=False, kernel_generator=None, dimension=- 1)

基类: MinkowskiCommon.MinkowskiModuleBase

bias

conv

dimension

forward(input: MinkowskiSparseTensor.SparseTensor, coords: Optional[Union[torch.IntTensor, MinkowskiEngineBackend._C.CoordinateMapKey, MinkowskiSparseTensor.SparseTensor]] = None)

input (MinkowskiEngine.SparseTensor): 用于应用卷积的输入稀疏张量。

coords ((torch.IntTensor, MinkowskiEngine.CoordinateMapKey, MinkowskiEngine.SparseTensor), optional): 如果提供，则在提供的坐标上生成结果。 默认值为 None。

in_channels

kernel

kernel_generator

out_channels

reset_parameters(is_transpose=False)

training: bool

MinkowskiEngine.MinkowskiCommon 模块

class MinkowskiEngine.MinkowskiCommon.MinkowskiModuleBase

基类: torch.nn.modules.module.Module

training: bool

MinkowskiEngine.MinkowskiCommon.convert_to_int_list(arg: Union[int, collections.abc.Sequence, numpy.ndarray, torch.Tensor], dimension: int)

MinkowskiEngine.MinkowskiCommon.convert_to_int_tensor(arg: Union[int, collections.abc.Sequence, numpy.ndarray, torch.IntTensor], dimension: int)

MinkowskiEngine.MinkowskiCommon.get_minkowski_function(name, variable)

MinkowskiEngine.MinkowskiCommon.get_postfix(tensor: torch.Tensor)

MinkowskiEngine.MinkowskiCommon.prep_args(tensor_stride: Union[int, collections.abc.Sequence, numpy.ndarray, torch.IntTensor], stride: Union[int, collections.abc.Sequence, numpy.ndarray, torch.IntTensor], kernel_size: Union[int, collections.abc.Sequence, numpy.ndarray, torch.IntTensor], dilation: Union[int, collections.abc.Sequence, numpy.ndarray, torch.IntTensor], region_type: Union[int, MinkowskiEngineBackend._C.RegionType], D=- 1)

MinkowskiEngine.MinkowskiConvolution 模块

class MinkowskiEngine.MinkowskiConvolution.MinkowskiConvolution(in_channels, out_channels, kernel_size=-1, stride=1, dilation=1, bias=False, kernel_generator=None, expand_coordinates=False, convolution_mode=<ConvolutionMode.DEFAULT: 0>, dimension=None)

基类: MinkowskiEngine.MinkowskiConvolution.MinkowskiConvolutionBase

用于稀疏张量的卷积层。

\[\mathbf{x}_\mathbf{u} = \sum_{\mathbf{i} \in \mathcal{N}^D(\mathbf{u}, K, \mathcal{C}^\text{in})} W_\mathbf{i} \mathbf{x}_{\mathbf{i} + \mathbf{u}} \;\text{for} \; \mathbf{u} \in \mathcal{C}^\text{out}\]

其中 \(K\) 是内核大小，\(\mathcal{N}^D(\mathbf{u}, K, \mathcal{C}^\text{in})\) 是一组偏移量，这些偏移量距离 \(\mathbf{u}\) 最多 \(\left \lceil{\frac{1}{2}(K - 1)} \right \rceil\)，定义在 \(\mathcal{S}^\text{in}\) 中。

注意

对于偶数 \(K\)，内核偏移量 \(\mathcal{N}^D\) 的实现与上述定义不同。偏移量范围为 \(\mathbf{i} \in [0, K)^D, \; \mathbf{i} \in \mathbb{Z}_+^D\)。

bias

conv

dimension

in_channels

is_transpose

kernel

kernel_generator

out_channels

training: bool

use_mm

class MinkowskiEngine.MinkowskiConvolution.MinkowskiConvolutionBase(in_channels, out_channels, kernel_size=-1, stride=1, dilation=1, bias=False, kernel_generator=None, is_transpose=False, expand_coordinates=False, convolution_mode=<ConvolutionMode.DEFAULT: 0>, dimension=-1)

基类: MinkowskiCommon.MinkowskiModuleBase

bias

conv

dimension

forward(input: MinkowskiSparseTensor.SparseTensor, coordinates: Optional[Union[torch.Tensor, MinkowskiEngineBackend._C.CoordinateMapKey, MinkowskiSparseTensor.SparseTensor]] = None)

input (MinkowskiEngine.SparseTensor): 用于应用卷积的输入稀疏张量。

coordinates ((torch.IntTensor, MinkowskiEngine.CoordinateMapKey, MinkowskiEngine.SparseTensor), optional): 如果提供，则在提供的坐标上生成结果。 默认值为 None。

in_channels

is_transpose

kernel

kernel_generator

out_channels

reset_parameters(is_transpose=False)

training: bool

use_mm

class MinkowskiEngine.MinkowskiConvolution.MinkowskiConvolutionFunction

基类: torch.autograd.function.Function

static backward(ctx, grad_out_feat: torch.Tensor)

定义一个用于区分操作的公式。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟与 forward() 返回的输出一样多的输出，并且它应该返回与 forward() 的输入一样多的张量。每个参数是关于给定输出的梯度，并且每个返回值应该是关于相应输入的梯度。

上下文可以用于检索在正向传递期间保存的张量。它还有一个属性 ctx.needs_input_grad 作为一个布尔值元组，表示每个输入是否需要梯度。例如，如果 forward() 的第一个输入需要相对于输出计算的梯度，则 backward() 将具有 ctx.needs_input_grad[0] = True。

static forward(ctx, input_features: torch.Tensor, kernel_weights: torch.Tensor, kernel_generator: MinkowskiKernelGenerator.KernelGenerator, convolution_mode: MinkowskiEngineBackend._C.ConvolutionMode, in_coordinate_map_key: MinkowskiEngineBackend._C.CoordinateMapKey, out_coordinate_map_key: Optional[MinkowskiEngineBackend._C.CoordinateMapKey] = None, coordinate_manager: Optional[MinkowskiCoordinateManager.CoordinateManager] = None)

执行操作。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟任意数量的参数（张量或其他类型）。

上下文可以用于存储可在后向传递期间检索的张量。

class MinkowskiEngine.MinkowskiConvolution.MinkowskiConvolutionTranspose(in_channels, out_channels, kernel_size=-1, stride=1, dilation=1, bias=False, kernel_generator=None, expand_coordinates=False, convolution_mode=<ConvolutionMode.DEFAULT: 0>, dimension=None)

基类: MinkowskiEngine.MinkowskiConvolution.MinkowskiConvolutionBase

一个广义的稀疏转置卷积或反卷积层。

bias

conv

dimension

in_channels

is_transpose

kernel

kernel_generator

out_channels

training: bool

use_mm

class MinkowskiEngine.MinkowskiConvolution.MinkowskiConvolutionTransposeFunction

基类: torch.autograd.function.Function

static backward(ctx, grad_out_feat: torch.Tensor)

定义一个用于区分操作的公式。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟与 forward() 返回的输出一样多的输出，并且它应该返回与 forward() 的输入一样多的张量。每个参数是关于给定输出的梯度，并且每个返回值应该是关于相应输入的梯度。

上下文可以用于检索在正向传递期间保存的张量。它还有一个属性 ctx.needs_input_grad 作为一个布尔值元组，表示每个输入是否需要梯度。例如，如果 forward() 的第一个输入需要相对于输出计算的梯度，则 backward() 将具有 ctx.needs_input_grad[0] = True。

static forward(ctx, input_features: torch.Tensor, kernel_weights: torch.Tensor, kernel_generator: MinkowskiKernelGenerator.KernelGenerator, convolution_mode: MinkowskiEngineBackend._C.ConvolutionMode, in_coordinate_map_key: MinkowskiEngineBackend._C.CoordinateMapKey, out_coordinate_map_key: Optional[MinkowskiEngineBackend._C.CoordinateMapKey] = None, coordinate_manager: Optional[MinkowskiCoordinateManager.CoordinateManager] = None)

执行操作。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟任意数量的参数（张量或其他类型）。

上下文可以用于存储可在后向传递期间检索的张量。

class MinkowskiEngine.MinkowskiConvolution.MinkowskiGenerativeConvolutionTranspose(in_channels, out_channels, kernel_size=-1, stride=1, dilation=1, bias=False, kernel_generator=None, convolution_mode=<ConvolutionMode.DEFAULT: 0>, dimension=None)

基类: MinkowskiEngine.MinkowskiConvolution.MinkowskiConvolutionBase

一种广义的稀疏转置卷积或反卷积层，用于生成新的坐标。

bias

conv

dimension

in_channels

is_transpose

kernel

kernel_generator

out_channels

training: bool

use_mm

MinkowskiEngine.MinkowskiCoordinateManager 模块

class MinkowskiEngine.MinkowskiCoordinateManager.CoordinateManager(D: int = 0, num_threads: int = - 1, coordinate_map_type: Optional[MinkowskiEngineBackend._C.CoordinateMapType] = None, allocator_type: Optional[MinkowskiEngineBackend._C.GPUMemoryAllocatorType] = None, minkowski_algorithm: Optional[MinkowskiEngineBackend._C.MinkowskiAlgorithm] = None)

基类: object

exists_field_to_sparse(field_map_key: MinkowskiEngineBackend._C.CoordinateMapKey, sparse_map_key: MinkowskiEngineBackend._C.CoordinateMapKey)

field_to_sparse_insert_and_map(field_map_key: MinkowskiEngineBackend._C.CoordinateMapKey, sparse_tensor_stride: Union[int, collections.abc.Sequence, numpy.ndarray], sparse_tensor_string_id: str = '') → Tuple[MinkowskiEngineBackend._C.CoordinateMapKey, Tuple[torch.IntTensor, torch.IntTensor]]

使用张量步长创建一个稀疏张量坐标映射。

field_map_key (CoordinateMapKey): 将从中创建新稀疏张量的字段映射。

tensor_stride (list): 定义新的 order-D + 1 稀疏张量的张量步长的 D 元素的列表。

string_id (str): 新稀疏张量坐标映射键的字符串 id。

示例

>>> manager = CoordinateManager(D=1)
>>> coordinates = torch.FloatTensor([[0, 0.1], [0, 2.3], [0, 1.2], [0, 2.4]])
>>> key, (unique_map, inverse_map) = manager.insert(coordinates, [1])

field_to_sparse_keys(field_map_key: MinkowskiEngineBackend._C.CoordinateMapKey)

field_to_sparse_map(field_map_key: MinkowskiEngineBackend._C.CoordinateMapKey, sparse_map_key: MinkowskiEngineBackend._C.CoordinateMapKey)

get_coordinate_field(coords_key_or_tensor_strides) → torch.Tensor

get_coordinates(coords_key_or_tensor_strides) → torch.Tensor

get_field_to_sparse_map(field_map_key: MinkowskiEngineBackend._C.CoordinateMapKey, sparse_map_key: MinkowskiEngineBackend._C.CoordinateMapKey)

get_kernel_map(in_key: MinkowskiEngineBackend._C.CoordinateMapKey, out_key: MinkowskiEngineBackend._C.CoordinateMapKey, stride=1, kernel_size=3, dilation=1, region_type=<RegionType.HYPER_CUBE: 0>, region_offset=None, is_transpose=False, is_pool=False) → dict

CoordinateManager.kernel_map 的别名。将在下一个版本中弃用。

get_unique_coordinate_map_key(tensor_stride: Union[int, list]) → MinkowskiEngineBackend._C.CoordinateMapKey

返回给定张量步长的唯一 coordinate_map_key。

tensor_stride (list): 定义新的 order-D + 1 稀疏张量的张量步长的 D 元素的列表。

insert_and_map(coordinates: torch.Tensor, tensor_stride: Union[int, collections.abc.Sequence, numpy.ndarray] = 1, string_id: str = '') → Tuple[MinkowskiEngineBackend._C.CoordinateMapKey, Tuple[torch.IntTensor, torch.IntTensor]]

创建一个新的坐标映射并返回 (key, (map, inverse_map))。

coordinates: torch.Tensor (Int 张量。如果 coordinate_map_type == CoordinateMapType.GPU，则为 CUDA)，定义坐标。

tensor_stride (list): 定义新的 order-D + 1 稀疏张量的张量步长的 D 元素的列表。

示例

>>> manager = CoordinateManager(D=1)
>>> coordinates = torch.IntTensor([[0, 0], [0, 0], [0, 1], [0, 2]])
>>> key, (unique_map, inverse_map) = manager.insert(coordinates, [1])
>>> print(key) # key is tensor_stride, string_id [1]:""
>>> torch.all(coordinates[unique_map] == manager.get_coordinates(key)) # True
>>> torch.all(coordinates == coordinates[unique_map][inverse_map]) # True

insert_field(coordinates: torch.Tensor, tensor_stride: collections.abc.Sequence, string_id: str = '') → Tuple[MinkowskiEngineBackend._C.CoordinateMapKey, Tuple[torch.IntTensor, torch.IntTensor]]

创建一个新的坐标映射并返回

coordinates: torch.FloatTensor (如果 coordinate_map_type == CoordinateMapType.GPU，则为 CUDA)，定义坐标。

tensor_stride (list): 定义新的 order-D + 1 稀疏张量的张量步长的 D 元素的列表。

示例

>>> manager = CoordinateManager(D=1)
>>> coordinates = torch.FloatTensor([[0, 0.1], [0, 2.3], [0, 1.2], [0, 2.4]])
>>> key, (unique_map, inverse_map) = manager.insert(coordinates, [1])
>>> print(key) # key is tensor_stride, string_id [1]:""
>>> torch.all(coordinates[unique_map] == manager.get_coordinates(key)) # True
>>> torch.all(coordinates == coordinates[unique_map][inverse_map]) # True

interpolation_map_weight(key: MinkowskiEngineBackend._C.CoordinateMapKey, samples: torch.Tensor)

kernel_map(in_key: MinkowskiEngineBackend._C.CoordinateMapKey, out_key: MinkowskiEngineBackend._C.CoordinateMapKey, stride=1, kernel_size=3, dilation=1, region_type=<RegionType.HYPER_CUBE: 0>, region_offset=None, is_transpose=False, is_pool=False) → dict

获取指定坐标键或张量步长的内核输入-输出映射。

返回 dict{kernel_index: in_out_tensor}，其中 in_out_tensor[0] 是对应于 in_out_tensor[1] 的输入行索引，后者是输出的行索引。

number_of_unique_batch_indices() → int

origin() → MinkowskiEngineBackend._C.CoordinateMapKey

origin_field() → MinkowskiEngineBackend._C.CoordinateMapKey

origin_field_map(key: MinkowskiEngineBackend._C.CoordinateMapKey)

origin_map(key: MinkowskiEngineBackend._C.CoordinateMapKey)

size(coordinate_map_key: MinkowskiEngineBackend._C.CoordinateMapKey) → int

stride(coordinate_map_key: MinkowskiEngineBackend._C.CoordinateMapKey, stride: Union[int, collections.abc.Sequence, numpy.ndarray, torch.Tensor], string_id: str = '') → MinkowskiEngineBackend._C.CoordinateMapKey

生成一个新的坐标映射并返回键。

coordinate_map_key (MinkowskiEngine.CoordinateMapKey): 从其生成步进映射的输入映射。

stride: 步长大小。

stride_map(in_key: MinkowskiEngineBackend._C.CoordinateMapKey, stride_key: MinkowskiEngineBackend._C.CoordinateMapKey)

union_map(in_keys: list, out_key)

class MinkowskiEngine.MinkowskiCoordinateManager.CoordsManager(**kwargs)

基类: object

MinkowskiEngine.MinkowskiCoordinateManager.set_coordinate_map_type(coordinate_map_type: MinkowskiEngineBackend._C.CoordinateMapType)

设置默认的坐标映射类型。

如果 NVIDIA GPU 可用，MinkowskiEngine 会自动将 coordinate_map_type 设置为 CUDA。要控制

MinkowskiEngine.MinkowskiCoordinateManager.set_gpu_allocator(backend: MinkowskiEngineBackend._C.GPUMemoryAllocatorType)

设置 GPU 内存分配器

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

默认情况下，Minkowski Engine 使用 ME.GPUMemoryAllocatorType.PYTORCH 进行内存管理。

示例

>>> import MinkowskiEngine as ME
>>> # Set the GPU memory manager backend to raw CUDA calls
>>> ME.set_gpu_allocator(ME.GPUMemoryAllocatorType.CUDA)
>>> # Set the GPU memory manager backend to the pytorch c10 allocator
>>> ME.set_gpu_allocator(ME.GPUMemoryAllocatorType.PYTORCH)

MinkowskiEngine.MinkowskiCoordinateManager.set_memory_manager_backend(backend: MinkowskiEngineBackend._C.GPUMemoryAllocatorType)

set_gpu_allocator 的别名。已弃用，将被删除。

MinkowskiEngine.MinkowskiFunctional 模块

MinkowskiEngine.MinkowskiFunctional.alpha_dropout(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.batch_norm(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.binary_cross_entropy(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.binary_cross_entropy_with_logits(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.celu(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.cross_entropy(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.dropout(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.elu(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.gelu(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.glu(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.gumbel_softmax(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.hardshrink(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.hardsigmoid(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.hardswish(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.hardtanh(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.hinge_embedding_loss(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.kl_div(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.l1_loss(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.leaky_relu(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.linear(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.log_softmax(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.logsigmoid(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.mse_loss(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.multi_margin_loss(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.multilabel_margin_loss(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.multilabel_soft_margin_loss(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.nll_loss(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.normalize(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.poisson_nll_loss(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.prelu(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.relu(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.relu6(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.rrelu(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.selu(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.sigmoid(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.silu(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.smooth_l1_loss(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.soft_margin_loss(input, target, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.softmax(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.softmin(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.softplus(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.softshrink(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.softsign(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.tanh(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.tanhshrink(input, *args, **kwargs)

MinkowskiEngine.MinkowskiFunctional.threshold(input, *args, **kwargs)

MinkowskiEngine.MinkowskiInterpolation 模块

class MinkowskiEngine.MinkowskiInterpolation.MinkowskiInterpolation(return_kernel_map=False, return_weights=False)

基类: MinkowskiCommon.MinkowskiModuleBase

在提供的点上采样线性插值特征。

forward(input: MinkowskiSparseTensor.SparseTensor, tfield: torch.Tensor)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiInterpolation.MinkowskiInterpolationFunction

基类: torch.autograd.function.Function

static backward(ctx, grad_out_feat=None, grad_in_map=None, grad_out_map=None, grad_weights=None)

定义一个用于区分操作的公式。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟与 forward() 返回的输出一样多的输出，并且应该返回与 forward() 的输入一样多的张量。 每个参数是相对于给定输出的梯度，并且每个返回值应该是相对于相应输入的梯度。

上下文可用于检索在正向传递期间保存的张量。它还有一个属性 ctx.needs_input_grad 作为布尔值元组，表示每个输入是否需要梯度。 例如，如果 forward() 的第一个输入需要计算相对于输出的梯度，则 backward() 将具有 ctx.needs_input_grad[0] = True。

static forward(ctx, input_features: torch.Tensor, tfield: torch.Tensor, in_coordinate_map_key: MinkowskiEngineBackend._C.CoordinateMapKey, coordinate_manager: Optional[MinkowskiCoordinateManager.CoordinateManager] = None)

执行操作。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟任意数量的参数（张量或其他类型）。

上下文可以用于存储可在后向传递期间检索的张量。

MinkowskiEngine.MinkowskiKernelGenerator 模块

class MinkowskiEngine.MinkowskiKernelGenerator.KernelGenerator(kernel_size=-1, stride=1, dilation=1, is_transpose: bool = False, region_type: MinkowskiEngineBackend._C.RegionType = <RegionType.HYPER_CUBE: 0>, region_offsets: Optional[torch.Tensor] = None, expand_coordinates: bool = False, axis_types=None, dimension=-1)

基类: object

axis_types

cache

dimension

expand_coordinates

get_kernel(tensor_stride, is_transpose)

kernel_dilation

kernel_size

kernel_stride

kernel_volume

region_offsets

region_type

requires_strided_coordinates

class MinkowskiEngine.MinkowskiKernelGenerator.KernelRegion(kernel_size, kernel_stride, kernel_dilation, region_type, offset, D)

基类: MinkowskiEngine.MinkowskiKernelGenerator.KernelRegion

向命名元组添加功能

MinkowskiEngine.MinkowskiKernelGenerator.convert_region_type(region_type: MinkowskiEngineBackend._C.RegionType, tensor_stride: Union[collections.abc.Sequence, numpy.ndarray, torch.IntTensor], kernel_size: Union[collections.abc.Sequence, numpy.ndarray, torch.IntTensor], up_stride: Union[collections.abc.Sequence, numpy.ndarray, torch.IntTensor], dilation: Union[collections.abc.Sequence, numpy.ndarray, torch.IntTensor], region_offset: Union[collections.abc.Sequence, numpy.ndarray, torch.IntTensor], axis_types: Union[collections.abc.Sequence, numpy.ndarray, torch.IntTensor], dimension: int, center: bool = True)

当 center 为 True 时，自定义 region_offset 将以原点为中心。 目前，对于 HYPER_CUBE, HYPER_CROSS 与奇数内核大小不能使用 center=False。

up_stride: conv_transpose 的步长，否则设置为 1

MinkowskiEngine.MinkowskiKernelGenerator.get_kernel_volume(region_type, kernel_size, region_offset, axis_types, dimension)

当 center 为 True 时，自定义 region_offset 将以原点为中心。 目前，对于 HYPER_CUBE, HYPER_CROSS 与奇数内核大小不能使用 center=False。

MinkowskiEngine.MinkowskiKernelGenerator.save_ctx(ctx, kernel_generator: MinkowskiEngine.MinkowskiKernelGenerator.KernelGenerator, in_coords_key: MinkowskiEngineBackend._C.CoordinateMapKey, out_coords_key: MinkowskiEngineBackend._C.CoordinateMapKey, coordinate_manager: MinkowskiCoordinateManager.CoordinateManager)

MinkowskiEngine.MinkowskiNetwork 模块

class MinkowskiEngine.MinkowskiNetwork.MinkowskiNetwork(D)

基类: torch.nn.modules.module.Module, abc.ABC

MinkowskiNetwork：稀疏卷积网络的抽象类。

注意：所有使用相同坐标的模块必须使用相同的 net_metadata

abstract forward(x)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

init(x)

如果坐标不存在，则初始化坐标

training: bool

MinkowskiEngine.MinkowskiNonlinearity 模块

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiAdaptiveLogSoftmaxWithLoss(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

别名为 torch.nn.modules.adaptive.AdaptiveLogSoftmaxWithLoss

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiAlphaDropout(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

别名为 torch.nn.modules.dropout.AlphaDropout

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiCELU(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

别名为 torch.nn.modules.activation.CELU

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiDropout(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.dropout.Dropout 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiELU(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.ELU 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiGELU(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.GELU 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiHardshrink(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.Hardshrink 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiHardsigmoid(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.Hardsigmoid 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiHardswish(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.Hardswish 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiHardtanh(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.Hardtanh 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiLeakyReLU(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.LeakyReLU 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiLogSigmoid(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.LogSigmoid 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiLogSoftmax(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.LogSoftmax 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase(*args, **kwargs)

基类: MinkowskiCommon.MinkowskiModuleBase

MODULE = None

forward(input)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiPReLU(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.PReLU 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiRReLU(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.RReLU 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiReLU(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.ReLU 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiReLU6(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.ReLU6 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiSELU(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.SELU 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiSiLU(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

是 torch.nn.modules.activation.SiLU 的别名

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiSigmoid(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

别名为 torch.nn.modules.activation.Sigmoid

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiSinusoidal(in_channel, out_channel)

基类: MinkowskiCommon.MinkowskiModuleBase

forward(input: Union[MinkowskiSparseTensor.SparseTensor, MinkowskiTensorField.TensorField])

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiSoftmax(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

别名为 torch.nn.modules.activation.Softmax

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiSoftmin(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

别名为 torch.nn.modules.activation.Softmin

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiSoftplus(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

别名为 torch.nn.modules.activation.Softplus

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiSoftshrink(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

别名为 torch.nn.modules.activation.Softshrink

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiSoftsign(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

别名为 torch.nn.modules.activation.Softsign

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiTanh(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

别名为 torch.nn.modules.activation.Tanh

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiTanhshrink(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

别名为 torch.nn.modules.activation.Tanhshrink

training: bool

class MinkowskiEngine.MinkowskiNonlinearity.MinkowskiThreshold(*args, **kwargs)

基类: MinkowskiEngine.MinkowskiNonlinearity.MinkowskiNonlinearityBase

MODULE

别名为 torch.nn.modules.activation.Threshold

training: bool

MinkowskiEngine.MinkowskiNormalization 模块

class MinkowskiEngine.MinkowskiNormalization.MinkowskiBatchNorm(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

基类: torch.nn.modules.module.Module

用于稀疏张量的批归一化层。

有关更多详细信息，请参见 pytorch torch.nn.BatchNorm1d。

forward(input)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiNormalization.MinkowskiInstanceNorm(num_features)

基类: MinkowskiCommon.MinkowskiModuleBase

用于稀疏张量的实例归一化层。

forward(input: MinkowskiSparseTensor.SparseTensor)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

reset_parameters()

training: bool

class MinkowskiEngine.MinkowskiNormalization.MinkowskiInstanceNormFunction

基类: torch.autograd.function.Function

static backward(ctx, out_grad)

定义一个用于区分操作的公式。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟与 forward() 返回一样多的输出，并且应该返回与 forward() 的输入一样多的张量。每个参数是关于给定输出的梯度，并且每个返回值应该是关于相应输入的梯度。

上下文可以用于检索在前向传播期间保存的张量。它还有一个属性 ctx.needs_input_grad，它是一个布尔值元组，表示是否每个输入都需要梯度。例如，backward() 将有 ctx.needs_input_grad[0] = True，如果 forward() 的第一个输入需要根据输出计算梯度。

static forward(ctx, in_feat: torch.Tensor, in_coords_key: MinkowskiEngineBackend._C.CoordinateMapKey, glob_coords_key: Optional[MinkowskiEngineBackend._C.CoordinateMapKey] = None, coords_manager: Optional[MinkowskiCoordinateManager.CoordinateManager] = None, gpooling_mode=<PoolingMode.GLOBAL_AVG_POOLING_KERNEL: 7>)

执行操作。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟任意数量的参数（张量或其他类型）。

上下文可以用于存储可在后向传递期间检索的张量。

class MinkowskiEngine.MinkowskiNormalization.MinkowskiStableInstanceNorm(num_features)

基类: MinkowskiCommon.MinkowskiModuleBase

forward(x)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

reset_parameters()

training: bool

class MinkowskiEngine.MinkowskiNormalization.MinkowskiSyncBatchNorm(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, process_group=None)

基类: MinkowskiEngine.MinkowskiNormalization.MinkowskiBatchNorm

具有多GPU同步的批归一化层。

classmethod convert_sync_batchnorm(module, process_group=None)

帮助函数，用于将模型中的 MinkowskiEngine.MinkowskiBatchNorm 层转换为 MinkowskiEngine.MinkowskiSyncBatchNorm 层。

参数

module (nn.Module): 包含的模块 process_group (optional): 用于限制同步范围的进程组，默认为整个世界

返回值

原始模块，其中包含转换后的 MinkowskiEngine.MinkowskiSyncBatchNorm 层

示例

>>> # Network with MinkowskiBatchNorm layer
>>> module = torch.nn.Sequential(
>>>            MinkowskiLinear(20, 100),
>>>            MinkowskiBatchNorm1d(100)
>>>          ).cuda()
>>> # creating process group (optional)
>>> # process_ids is a list of int identifying rank ids.
>>> process_group = torch.distributed.new_group(process_ids)
>>> sync_bn_module = convert_sync_batchnorm(module, process_group)

forward(input)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

MinkowskiEngine.MinkowskiOps 模块

class MinkowskiEngine.MinkowskiOps.MinkowskiLinear(in_features, out_features, bias=True)

基类: torch.nn.modules.module.Module

forward(input: Union[MinkowskiSparseTensor.SparseTensor, MinkowskiTensorField.TensorField])

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiOps.MinkowskiStackCat(*args: torch.nn.modules.module.Module)

class MinkowskiEngine.MinkowskiOps.MinkowskiStackCat(arg: OrderedDict[str, Module])

基类: torch.nn.modules.container.Sequential

forward(x)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiOps.MinkowskiStackMean(*args: torch.nn.modules.module.Module)

class MinkowskiEngine.MinkowskiOps.MinkowskiStackMean(arg: OrderedDict[str, Module])

基类: torch.nn.modules.container.Sequential

forward(x)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiOps.MinkowskiStackSum(*args: torch.nn.modules.module.Module)

class MinkowskiEngine.MinkowskiOps.MinkowskiStackSum(arg: OrderedDict[str, Module])

基类: torch.nn.modules.container.Sequential

forward(x)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiOps.MinkowskiStackVar(*args: torch.nn.modules.module.Module)

class MinkowskiEngine.MinkowskiOps.MinkowskiStackVar(arg: OrderedDict[str, Module])

基类: torch.nn.modules.container.Sequential

forward(x)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiOps.MinkowskiToDenseTensor(shape: Optional[torch.Size] = None)

基类: MinkowskiCommon.MinkowskiModuleBase

将（可微分的）稀疏张量转换为 torch 张量。

返回类型具有 BxCxD1xD2x….xDN 格式。

示例

>>> dense_tensor = torch.rand(3, 4, 11, 11, 11, 11)  # BxCxD1xD2x....xDN
>>> dense_tensor.requires_grad = True

>>> # Since the shape is fixed, cache the coordinates for faster inference
>>> coordinates = dense_coordinates(dense_tensor.shape)

>>> network = nn.Sequential(
>>>     # Add layers that can be applied on a regular pytorch tensor
>>>     nn.ReLU(),
>>>     MinkowskiToSparseTensor(coordinates=coordinates),
>>>     MinkowskiConvolution(4, 5, stride=2, kernel_size=3, dimension=4),
>>>     MinkowskiBatchNorm(5),
>>>     MinkowskiReLU(),
>>>     MinkowskiConvolutionTranspose(5, 6, stride=2, kernel_size=3, dimension=4),
>>>     MinkowskiToDenseTensor(
>>>         dense_tensor.shape
>>>     ),  # must have the same tensor stride.
>>> )

>>> for i in range(5):
>>>     print(f"Iteration: {i}")
>>>     output = network(dense_tensor) # returns a regular pytorch tensor
>>>     output.sum().backward()

forward(input: MinkowskiSparseTensor.SparseTensor)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiOps.MinkowskiToFeature

基类: MinkowskiCommon.MinkowskiModuleBase

从稀疏张量中提取特征，并返回一个 pytorch 张量。

可用于简化网络构建。

示例

>>> net = nn.Sequential(MinkowskiConvolution(...), MinkowskiGlobalMaxPooling(...), MinkowskiToFeature(), nn.Linear(...))
>>> torch_tensor = net(sparse_tensor)

forward(x: MinkowskiSparseTensor.SparseTensor)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

class MinkowskiEngine.MinkowskiOps.MinkowskiToSparseTensor(remove_zeros=True, coordinates: Optional[torch.Tensor] = None)

基类: MinkowskiCommon.MinkowskiModuleBase

将（可微分的）稠密张量或 MinkowskiEngine.TensorField 转换为 MinkowskiEngine.SparseTensor。

对于稠密张量，输入必须具有 BxCxD1xD2x….xDN 格式。

remove_zeros (bool)：如果为 True，则移除零值坐标。 如果为 False，则使用所有坐标来填充稀疏张量。 默认为 True。

如果张量的形状未更改，请使用 dense_coordinates 来缓存坐标。 有关用法，请参阅 tests/python/dense.py。

示例

>>> # Differentiable dense torch.Tensor to sparse tensor.
>>> dense_tensor = torch.rand(3, 4, 11, 11, 11, 11)  # BxCxD1xD2x....xDN
>>> dense_tensor.requires_grad = True

>>> # Since the shape is fixed, cache the coordinates for faster inference
>>> coordinates = dense_coordinates(dense_tensor.shape)

>>> network = nn.Sequential(
>>>     # Add layers that can be applied on a regular pytorch tensor
>>>     nn.ReLU(),
>>>     MinkowskiToSparseTensor(remove_zeros=False, coordinates=coordinates),
>>>     MinkowskiConvolution(4, 5, kernel_size=3, dimension=4),
>>>     MinkowskiBatchNorm(5),
>>>     MinkowskiReLU(),
>>> )

>>> for i in range(5):
>>>   print(f"Iteration: {i}")
>>>   soutput = network(dense_tensor)
>>>   soutput.F.sum().backward()
>>>   soutput.dense(shape=dense_tensor.shape)

forward(input: Union[MinkowskiTensorField.TensorField, torch.Tensor])

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

MinkowskiEngine.MinkowskiOps.cat(*sparse_tensors)

连接稀疏张量

连接稀疏张量特征。 所有稀疏张量必须具有相同的 coordinate_map_key（相同的坐标）。 要连接具有不同稀疏模式的稀疏张量，请使用 SparseTensor 二进制运算或 MinkowskiEngine.MinkowskiUnion。

示例

>>> import MinkowskiEngine as ME
>>> sin = ME.SparseTensor(feats, coords)
>>> sin2 = ME.SparseTensor(feats2, coordinate_map_key=sin.coordinate_map_key, coordinate_mananger=sin.coordinate_manager)
>>> sout = UNet(sin)  # Returns an output sparse tensor on the same coordinates
>>> sout2 = ME.cat(sin, sin2, sout)  # Can concatenate multiple sparse tensors

MinkowskiEngine.MinkowskiOps.dense_coordinates(shape: Union[list, torch.Size])

coordinates = dense_coordinates(tensor.shape)

MinkowskiEngine.MinkowskiOps.mean(*sparse_tensors)

计算稀疏张量特征的平均值

对所有稀疏张量特征求和。 所有稀疏张量必须具有相同的 coordinate_map_key（相同的坐标）。 要对具有不同稀疏模式的稀疏张量求和，请使用 SparseTensor 二进制运算或 MinkowskiEngine.MinkowskiUnion。

示例

>>> import MinkowskiEngine as ME
>>> sin = ME.SparseTensor(feats, coords)
>>> sin2 = ME.SparseTensor(feats2, coordinate_map_key=sin.coordinate_map_key, coordinate_manager=sin.coordinate_manager)
>>> sout = UNet(sin)  # Returns an output sparse tensor on the same coordinates
>>> sout2 = ME.mean(sin, sin2, sout)  # Can concatenate multiple sparse tensors

MinkowskiEngine.MinkowskiOps.to_sparse(x: torch.Tensor, format: Optional[str] = None, coordinates=None, device=None)

将批处理张量（维度 0 是批处理维度）转换为 SparseTensor

x (torch.Tensor)：一个批处理张量。第一个维度是批处理维度。

format (str)：张量的格式。它必须包括“B”和“C”，分别表示批处理和通道维度。其余维度必须是“X”。例如，如果使用 BCHW 格式的图像数据，则 format=”BCXX”。如果通道位于最后一个维度的 3D 数据，请使用 format=”BXXXC”，表示批处理 X 高度 X 宽度 X 深度 X 通道。如果未提供，则格式将为“BCX…X”。

device：将在其上生成稀疏张量的设备。如果未提供，则将使用输入张量的设备。

MinkowskiEngine.MinkowskiOps.to_sparse_all(dense_tensor: torch.Tensor, coordinates: Optional[torch.Tensor] = None)

将（可微分的）稠密张量转换为具有所有坐标的稀疏张量。

假设输入具有 BxCxD1xD2x….xDN 格式。

如果张量的形状未更改，请使用 dense_coordinates 来缓存坐标。有关用法，请参阅 tests/python/dense.py

示例

>>> dense_tensor = torch.rand(3, 4, 5, 6, 7, 8)  # BxCxD1xD2xD3xD4
>>> dense_tensor.requires_grad = True
>>> stensor = to_sparse(dense_tensor)

MinkowskiEngine.MinkowskiOps.var(*sparse_tensors)

计算稀疏张量特征的方差

对所有稀疏张量特征求和。 所有稀疏张量必须具有相同的 coordinate_map_key（相同的坐标）。 要对具有不同稀疏模式的稀疏张量求和，请使用 SparseTensor 二进制运算或 MinkowskiEngine.MinkowskiUnion。

示例

>>> import MinkowskiEngine as ME
>>> sin = ME.SparseTensor(feats, coords)
>>> sin2 = ME.SparseTensor(feats2, coordinate_map_key=sin.coordinate_map_key, coordinate_manager=sin.coordinate_manager)
>>> sout = UNet(sin)  # Returns an output sparse tensor on the same coordinates
>>> sout2 = ME.var(sin, sin2, sout)  # Can concatenate multiple sparse tensors

MinkowskiEngine.MinkowskiPooling 模块

class MinkowskiEngine.MinkowskiPooling.MinkowskiAvgPooling(kernel_size=- 1, stride=1, dilation=1, kernel_generator=None, dimension=None)

基类： MinkowskiEngine.MinkowskiPooling.MinkowskiPoolingBase

在内核中对输入特征进行平均。

\[\mathbf{y}_\mathbf{u} = \frac{1}{|\mathcal{N}^D(\mathbf{u}, \mathcal{C}^\text{in})|} \sum_{\mathbf{i} \in \mathcal{N}^D(\mathbf{u}, \mathcal{C}^\text{in})} \mathbf{x}_{\mathbf{u} + \mathbf{i}} \; \text{for} \; \mathbf{u} \in \mathcal{C}^\text{out}\]

对于 \(\mathcal{C}^\text{out}\) 中的每个输出 \(\mathbf{u}\)，对输入特征进行平均。

注意

平均层首先计算输入特征的基数，即每个输出的输入特征数，然后将输入特征的总和除以基数。 对于稠密张量，基数是一个常数，即内核的体积。 但是，对于稀疏张量，基数会根据每个输出的输入特征数而变化。 因此，稀疏张量的平均池化不等同于稠密张量的传统平均池化层。 有关等效层，请参阅 MinkowskiSumPooling。

注意

如果内核大小等于步长大小，例如 kernel_size = [2, 1], stride = [2, 1]，则引擎将更快地生成与池化函数对应的输入输出映射。

如果使用 U 网络架构，请使用相同函数的转置版本进行上采样。 例如，pool = MinkowskiSumPooling(kernel_size=2, stride=2, D=D)，然后使用 unpool = MinkowskiPoolingTranspose(kernel_size=2, stride=2, D=D)。

dimension

is_transpose

kernel_generator

pooling

pooling_mode

training: bool

class MinkowskiEngine.MinkowskiPooling.MinkowskiDirectMaxPoolingFunction

基类: torch.autograd.function.Function

static backward(ctx, grad_out_feat)

定义一个用于区分操作的公式。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟与 forward() 返回的输出一样多的参数，并且它应该返回与 forward() 的输入一样多的张量。 每个参数是相对于给定输出的梯度，并且每个返回值应该是相对于相应输入的梯度。

上下文可用于检索在正向传递期间保存的张量。它还具有一个属性 ctx.needs_input_grad，作为一个布尔值元组，表示每个输入是否需要梯度。例如，如果 forward() 的第一个输入需要相对于输出计算梯度，则 backward() 将具有 ctx.needs_input_grad[0] = True。

静态方法 forward(ctx, in_map: torch.Tensor, out_map: torch.Tensor, in_feat: torch.Tensor, out_nrows: int, is_sorted: bool = False)

执行操作。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟任意数量的参数（张量或其他类型）。

上下文可以用于存储可在后向传递期间检索的张量。

类 MinkowskiEngine.MinkowskiPooling.MinkowskiGlobalAvgPooling(mode=<PoolingMode.GLOBAL_AVG_POOLING_PYTORCH_INDEX: 10>)

基类: MinkowskiEngine.MinkowskiPooling.MinkowskiGlobalPooling

training: bool

类 MinkowskiEngine.MinkowskiPooling.MinkowskiGlobalMaxPooling(mode=<PoolingMode.GLOBAL_MAX_POOLING_PYTORCH_INDEX: 11>)

基类: MinkowskiEngine.MinkowskiPooling.MinkowskiGlobalPooling

将所有输入特征最大池化到一个位于原点的输出特征。

\[\mathbf{y} = \max_{\mathbf{i} \in \mathcal{C}^\text{in}} \mathbf{x}_{\mathbf{i}}\]

forward(input, coordinates: Optional[Union[torch.IntTensor, MinkowskiEngineBackend._C.CoordinateMapKey, MinkowskiSparseTensor.SparseTensor]] = None)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

类 MinkowskiEngine.MinkowskiPooling.MinkowskiGlobalPooling(mode: MinkowskiEngineBackend._C.PoolingMode = <PoolingMode.GLOBAL_AVG_POOLING_PYTORCH_INDEX: 10>)

基类: MinkowskiCommon.MinkowskiModuleBase

将所有输入特征池化到一个输出。

forward(input: MinkowskiSparseTensor.SparseTensor, coordinates: Optional[Union[torch.IntTensor, MinkowskiEngineBackend._C.CoordinateMapKey, MinkowskiSparseTensor.SparseTensor]] = None)

定义每次调用时执行的计算。

应由所有子类覆盖。

注意

虽然前向传递的配方需要在该函数中定义，但是应该调用 Module 实例，而不是调用这个函数，因为前者负责运行注册的钩子，而后者会默默地忽略它们。

training: bool

类 MinkowskiEngine.MinkowskiPooling.MinkowskiGlobalPoolingFunction

基类: torch.autograd.function.Function

静态方法 backward(ctx, grad_out_feat)

定义一个用于区分操作的公式。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，然后是 forward() 返回的输出数量。它应该返回与 forward() 的输入数量一样多的张量。每个参数都是相对于给定输出的梯度，并且每个返回值都应该是相对于相应输入的梯度。

该上下文可用于检索在正向传递期间保存的张量。它还有一个属性 ctx.needs_input_grad，它是一个布尔值元组，表示每个输入是否需要梯度。例如，如果第一个输入到 forward() 需要计算相对于输出的梯度，则 backward() 将具有 ctx.needs_input_grad[0] = True。

静态方法 forward(ctx, input_features: torch.Tensor, pooling_mode: MinkowskiEngineBackend._C.PoolingMode, in_coordinate_map_key: MinkowskiEngineBackend._C.CoordinateMapKey, out_coordinate_map_key: Optional[MinkowskiEngineBackend._C.CoordinateMapKey] = None, coordinate_manager: Optional[MinkowskiCoordinateManager.CoordinateManager] = None)

执行操作。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟任意数量的参数（张量或其他类型）。

上下文可以用于存储可在后向传递期间检索的张量。

类 MinkowskiEngine.MinkowskiPooling.MinkowskiGlobalSumPooling(mode=<PoolingMode.GLOBAL_SUM_POOLING_PYTORCH_INDEX: 9>)

基类: MinkowskiEngine.MinkowskiPooling.MinkowskiGlobalPooling

training: bool

类 MinkowskiEngine.MinkowskiPooling.MinkowskiLocalPoolingFunction

基类: torch.autograd.function.Function

静态方法 backward(ctx, grad_out_feat)

定义一个用于区分操作的公式。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，然后是 forward() 返回的输出数量。它应该返回与 forward() 的输入数量一样多的张量。每个参数都是相对于给定输出的梯度，并且每个返回值都应该是相对于相应输入的梯度。

该上下文可用于检索在正向传递期间保存的张量。它还有一个属性 ctx.needs_input_grad，它是一个布尔值元组，表示每个输入是否需要梯度。例如，如果第一个输入到 forward() 需要计算相对于输出的梯度，则 backward() 将具有 ctx.needs_input_grad[0] = True。

静态方法 forward(ctx, input_features: torch.Tensor, pooling_mode: MinkowskiEngineBackend._C.PoolingMode, kernel_generator: MinkowskiKernelGenerator.KernelGenerator, in_coordinate_map_key: MinkowskiEngineBackend._C.CoordinateMapKey, out_coordinate_map_key: Optional[MinkowskiEngineBackend._C.CoordinateMapKey] = None, coordinate_manager: Optional[MinkowskiCoordinateManager.CoordinateManager] = None)

执行操作。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟任意数量的参数（张量或其他类型）。

上下文可以用于存储可在后向传递期间检索的张量。

类 MinkowskiEngine.MinkowskiPooling.MinkowskiLocalPoolingTransposeFunction

基类: torch.autograd.function.Function

静态方法 backward(ctx, grad_out_feat)

定义一个用于区分操作的公式。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，然后是 forward() 返回的输出数量。它应该返回与 forward() 的输入数量一样多的张量。每个参数都是相对于给定输出的梯度，并且每个返回值都应该是相对于相应输入的梯度。

该上下文可用于检索在正向传递期间保存的张量。它还有一个属性 ctx.needs_input_grad，它是一个布尔值元组，表示每个输入是否需要梯度。例如，如果第一个输入到 forward() 需要计算相对于输出的梯度，则 backward() 将具有 ctx.needs_input_grad[0] = True。

静态 forward(ctx, input_features: torch.Tensor, pooling_mode: MinkowskiEngineBackend._C.PoolingMode, kernel_generator: MinkowskiKernelGenerator.KernelGenerator, in_coordinate_map_key: MinkowskiEngineBackend._C.CoordinateMapKey, out_coordinate_map_key: Optional[MinkowskiEngineBackend._C.CoordinateMapKey] = None, coordinate_manager: Optional[MinkowskiCoordinateManager.CoordinateManager] = None)

执行操作。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟任意数量的参数（张量或其他类型）。

上下文可以用于存储可在后向传递期间检索的张量。

类 MinkowskiEngine.MinkowskiPooling.MinkowskiMaxPooling(kernel_size, stride=1, dilation=1, kernel_generator=None, dimension=None)

基类： MinkowskiEngine.MinkowskiPooling.MinkowskiPoolingBase

稀疏张量的最大池化层。

\[y^c_\mathbf{u} = \max_{\mathbf{i} \in \mathcal{N}^D(\mathbf{u}, \mathcal{C}^\text{in})} x^c_{\mathbf{u} + \mathbf{i}} \; \text{对于} \; \mathbf{u} \in \mathcal{C}^\text{out}\]

其中 \(y^c_\mathbf{u}\) 是通道 \(c\) 和坐标 \(\mathbf{u}\) 处的特征。

注意

如果内核大小等于步长大小，例如 kernel_size = [2, 1], stride = [2, 1]，则引擎将更快地生成与池化函数对应的输入输出映射。

如果使用 U 网络架构，请使用相同函数的转置版本进行上采样。 例如，pool = MinkowskiSumPooling(kernel_size=2, stride=2, D=D)，然后使用 unpool = MinkowskiPoolingTranspose(kernel_size=2, stride=2, D=D)。

dimension

is_transpose

kernel_generator

pooling

pooling_mode

training: bool

类 MinkowskiEngine.MinkowskiPooling.MinkowskiPoolingBase(kernel_size, stride=1, dilation=1, kernel_generator=None, is_transpose=False, pooling_mode=<PoolingMode.LOCAL_AVG_POOLING: 1>, dimension=-1)

基类: MinkowskiCommon.MinkowskiModuleBase

dimension

forward(input: MinkowskiSparseTensor.SparseTensor, coordinates: Optional[Union[torch.IntTensor, MinkowskiEngineBackend._C.CoordinateMapKey, MinkowskiSparseTensor.SparseTensor]] = None)

input (MinkowskiEngine.SparseTensor): 用于应用卷积的输入稀疏张量。

coordinates ((torch.IntTensor, MinkowskiEngine.CoordsKey, MinkowskiEngine.SparseTensor), 可选): 如果提供，则在提供的坐标上生成结果。 默认为None。

is_transpose

kernel_generator

pooling

pooling_mode

training: bool

类 MinkowskiEngine.MinkowskiPooling.MinkowskiPoolingTranspose(kernel_size, stride, dilation=1, kernel_generator=None, expand_coordinates=False, dimension=None)

基类： MinkowskiEngine.MinkowskiPooling.MinkowskiPoolingBase

稀疏张量的池化转置层。

解池化特征并将其除以促成的非零元素的数量。

dimension

is_transpose

kernel_generator

pooling

pooling_mode

training: bool

类 MinkowskiEngine.MinkowskiPooling.MinkowskiSumPooling(kernel_size, stride=1, dilation=1, kernel_generator=None, dimension=None)

基类： MinkowskiEngine.MinkowskiPooling.MinkowskiPoolingBase

对内核中的所有输入特征求和。

\[\mathbf{y}_\mathbf{u} = \sum_{\mathbf{i} \in \mathcal{N}^D(\mathbf{u}, \mathcal{C}^\text{in})} \mathbf{x}_{\mathbf{u} + \mathbf{i}} \; \text{对于} \; \mathbf{u} \in \mathcal{C}^\text{out}\]

对于 \(\mathcal{C}^\text{out}\) 中的每个输出 \(\mathbf{u}\)，对输入特征进行平均。

注意

平均层首先计算输入特征的基数，每个输出的输入特征数量，并将输入特征的总和除以基数。 对于密集张量，基数是一个常数，即内核的体积。 但是，对于稀疏张量，基数根据每个输出的输入特征数量而变化。 因此，用基数平均输入特征可能不等同于密集张量的传统平均池化。 该层提供了一种不将总和除以基数的替代方案。

注意

如果内核大小等于步长大小，例如 kernel_size = [2, 1], stride = [2, 1]，则引擎将更快地生成与池化函数对应的输入输出映射。

如果使用 U 网络架构，请使用相同函数的转置版本进行上采样。 例如，pool = MinkowskiSumPooling(kernel_size=2, stride=2, D=D)，然后使用 unpool = MinkowskiPoolingTranspose(kernel_size=2, stride=2, D=D)。

dimension

is_transpose

kernel_generator

pooling

pooling_mode

training: bool

MinkowskiEngine.MinkowskiPruning 模块

类 MinkowskiEngine.MinkowskiPruning.MinkowskiPruning

基类: MinkowskiCommon.MinkowskiModuleBase

从 MinkowskiEngine.SparseTensor 中删除指定的坐标。

forward(input: MinkowskiSparseTensor.SparseTensor, mask: torch.Tensor)

参数

input (MinkowskiEnigne.SparseTensor): 一个从中删除坐标的稀疏张量。

mask (torch.BoolTensor): 指定要保留哪个坐标的掩码向量。 坐标为 False 的坐标将被删除。

返回值

具有 C = 对应于 mask == True 的坐标的 MinkowskiEngine.SparseTensor F = 来自 mask == True 的特征的副本。

示例

>>> # Define inputs
>>> input = SparseTensor(feats, coords=coords)
>>> # Any boolean tensor can be used as the filter
>>> mask = torch.rand(feats.size(0)) < 0.5
>>> pruning = MinkowskiPruning()
>>> output = pruning(input, mask)

training: bool

类 MinkowskiEngine.MinkowskiPruning.MinkowskiPruningFunction

基类: torch.autograd.function.Function

static backward(ctx, grad_out_feat: torch.Tensor)

定义一个用于区分操作的公式。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，然后是与 forward() 返回的输出一样多的参数，并且应该返回与 forward() 的输入一样多的张量。每个参数是关于给定输出的梯度，并且每个返回值应该是关于相应输入的梯度。

上下文可以用于检索在正向传递期间保存的张量。它还有一个属性 ctx.needs_input_grad，它是一个布尔值元组，表示每个输入是否需要梯度。例如，如果 forward() 的第一个输入需要计算关于输出的梯度，则 backward() 将具有 ctx.needs_input_grad[0] = True。

static forward(ctx, in_feat: torch.Tensor, mask: torch.Tensor, in_coords_key: MinkowskiEngineBackend._C.CoordinateMapKey, out_coords_key: Optional[MinkowskiEngineBackend._C.CoordinateMapKey] = None, coords_manager: Optional[MinkowskiCoordinateManager.CoordinateManager] = None)

执行操作。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟任意数量的参数（张量或其他类型）。

上下文可以用于存储可在后向传递期间检索的张量。

MinkowskiEngine.MinkowskiSparseTensor 模块

class MinkowskiEngine.MinkowskiSparseTensor.SparseTensor(features: torch.Tensor, coordinates: Optional[torch.Tensor] = None, tensor_stride: Union[int, collections.abc.Sequence, numpy.ndarray, torch.IntTensor] = 1, coordinate_map_key: Optional[MinkowskiEngineBackend._C.CoordinateMapKey] = None, coordinate_manager: Optional[MinkowskiCoordinateManager.CoordinateManager] = None, quantization_mode: MinkowskiTensor.SparseTensorQuantizationMode = <SparseTensorQuantizationMode.RANDOM_SUBSAMPLE: 0>, allocator_type: Optional[MinkowskiEngineBackend._C.GPUMemoryAllocatorType] = None, minkowski_algorithm: Optional[MinkowskiEngineBackend._C.MinkowskiAlgorithm] = None, requires_grad=None, device=None)

基类: MinkowskiTensor.Tensor

一个稀疏张量类。可以通过 MinkowskiEngine.SparseTensor 访问。

SparseTensor 类是 MinkowskiEngine 中的基本张量。有关稀疏张量的定义，请访问 术语页面。我们使用 COOrdinate (COO) 格式来保存稀疏张量 [1]。这种表示形式只是矩阵 \(C\) 中坐标的连接和相关特征 \(F\)。

\[\begin{split}\mathbf{C} = \begin{bmatrix} b_1 & x_1^1 & x_1^2 & \cdots & x_1^D \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ b_N & x_N^1 & x_N^2 & \cdots & x_N^D \end{bmatrix}, \; \mathbf{F} = \begin{bmatrix} \mathbf{f}_1^T\\ \vdots\\ \mathbf{f}_N^T \end{bmatrix}\end{split}\]

其中 \(\mathbf{x}_i \in \mathcal{Z}^D\) 是一个 \(D\) 维坐标，\(b_i \in \mathcal{Z}_+\) 表示相应的批次索引。\(N\) 是稀疏张量中非零元素的数量，每个元素具有坐标 \((b_i, x_i^1, x_i^1, \cdots, x_i^D)\) 和相关的特征 \(\mathbf{f}_i\)。在内部，我们将批次索引作为额外的空间维度进行处理。

示例

>>> coords, feats = ME.utils.sparse_collate([coords_batch0, coords_batch1], [feats_batch0, feats_batch1])
>>> A = ME.SparseTensor(features=feats, coordinates=coords)
>>> B = ME.SparseTensor(features=feats, coordinate_map_key=A.coordiante_map_key, coordinate_manager=A.coordinate_manager)
>>> C = ME.SparseTensor(features=feats, coordinates=coords, quantization_mode=ME.SparseTensorQuantizationMode.UNWEIGHTED_AVERAGE)
>>> D = ME.SparseTensor(features=feats, coordinates=coords, quantization_mode=ME.SparseTensorQuantizationMode.RANDOM_SUBSAMPLE)
>>> E = ME.SparseTensor(features=feats, coordinates=coords, tensor_stride=2)

警告

要将 GPU 后端用于坐标管理，coordinates 必须是 GPU 上的 torch 张量。在使用 CPU coordinates 初始化 MinkowskiEngine.SparseTensor 之后应用 to(device) 将浪费时间和计算资源来创建一个不必要的 CPU CoordinateMap，因为 GPU CoordinateMap 也会从头开始创建。

警告

在 MinkowskiEngine 0.4 版本之前，我们将批次索引放在最后一列。因此，直接操作坐标将与最新版本不兼容。相反，请使用 MinkowskiEngine.utils.batched_coordinates 或 MinkowskiEngine.utils.sparse_collate 来创建批处理坐标。

此外，要批量访问坐标或特征，请使用稀疏张量的函数 coordinates_at(batch_index : int)，features_at(batch_index : int)。或者访问所有批处理坐标和特征，使用稀疏张量的 decomposed_coordinates, decomposed_features, decomposed_coordinates_and_features。

示例

>>> coords, feats = ME.utils.sparse_collate([coords_batch0, coords_batch1], [feats_batch0, feats_batch1])
>>> A = ME.SparseTensor(feats=feats, coords=coords)
>>> coords_batch0 = A.coordinates_at(batch_index=0)
>>> feats_batch1 = A.features_at(batch_index=1)
>>> list_of_coords, list_of_featurs = A.decomposed_coordinates_and_features

cat_slice(X)

参数

X (MinkowskiEngine.SparseTensor): 一个离散化原始输入的稀疏张量。

返回值

tensor_field (MinkowskiEngine.TensorField): 生成输入 X 和 self 的原始连续坐标上的特征连接所得到的张量场。

示例

>>> # coords, feats from a data loader
>>> print(len(coords))  # 227742
>>> sinput = ME.SparseTensor(coordinates=coords, features=feats, quantization_mode=SparseTensorQuantizationMode.UNWEIGHTED_AVERAGE)
>>> print(len(sinput))  # 161890 quantization results in fewer voxels
>>> soutput = network(sinput)
>>> print(len(soutput))  # 161890 Output with the same resolution
>>> ofield = soutput.cat_slice(sinput)
>>> assert soutput.F.size(1) + sinput.F.size(1) == ofield.F.size(1)  # concatenation of features

coordinate_map_key

dense(shape=None, min_coordinate=None, contract_stride=True)

将 MinkowskiEngine.SparseTensor 转换为 torch 稠密张量。

参数

shape (torch.Size, optional): 输出张量的大小。

min_coordinate (torch.IntTensor, optional): 输出稀疏张量的最小坐标。必须可被当前的 tensor_stride 整除。如果给出 0，它将使用原点作为最小坐标。

contract_stride (bool, optional): 输出坐标将除以张量步长，以使特征在空间上是连续的。默认为 True。

返回值

tensor (torch.Tensor): 大小为 [批次维度, 特征维度, 空间维度…, 空间维度] 的 torch 张量。可以通过 min_coordinate + tensor_stride * [稠密张量的坐标] 访问每个特征的坐标。

min_coordinate (torch.IntTensor): 定义输出张量的最小坐标的 D 维向量。

tensor_stride (torch.IntTensor): 定义张量元素之间步长的 D 维向量。

features_at_coordinates(query_coordinates: torch.Tensor)

提取指定连续坐标矩阵处的特征。

参数

query_coordinates (torch.FloatTensor): 大小为 \(N \times (D + 1)\) 的坐标矩阵，其中 \(D\) 是空间维度的大小。

返回值

queried_features (torch.Tensor): 大小为 \(N \times D_F\) 的特征矩阵，其中 \(D_F\) 是特征中的通道数。对于当前稀疏张量中不存在的坐标，相应的特征行将为零。

initialize_coordinates(coordinates, features, coordinate_map_key)

inverse_mapping

quantization_mode

slice(X)

参数

X (MinkowskiEngine.SparseTensor): 一个离散化原始输入的稀疏张量。

返回值

tensor_field (MinkowskiEngine.TensorField): 结果张量场包含生成输入 X 的连续坐标上的特征。

示例

>>> # coords, feats from a data loader
>>> print(len(coords))  # 227742
>>> tfield = ME.TensorField(coordinates=coords, features=feats, quantization_mode=SparseTensorQuantizationMode.UNWEIGHTED_AVERAGE)
>>> print(len(tfield))  # 227742
>>> sinput = tfield.sparse() # 161890 quantization results in fewer voxels
>>> soutput = MinkUNet(sinput)
>>> print(len(soutput))  # 161890 Output with the same resolution
>>> ofield = soutput.slice(tfield)
>>> assert isinstance(ofield, ME.TensorField)
>>> len(ofield) == len(coords)  # recovers the original ordering and length
>>> assert isinstance(ofield.F, torch.Tensor)  # .F returns the features

sparse(min_coords=None, max_coords=None, contract_coords=True)

将 MinkowskiEngine.SparseTensor 转换为 torch 稀疏张量。

参数

min_coords (torch.IntTensor, 可选): 输出稀疏张量的最小坐标。必须可被当前的 tensor_stride 整除。

max_coords (torch.IntTensor, 可选): 输出稀疏张量的最大坐标（包含）。必须可被当前的 tensor_stride 整除。

contract_coords (bool, 可选): 如果为 True，输出坐标将被张量步长除以，以使特征连续。

返回值

spare_tensor (torch.sparse.Tensor): self 的 torch 稀疏张量表示，格式为 [Batch Dim, Spatial Dims…, Feature Dim]。可以通过 min_coord + tensor_stride * [密集张量的坐标] 访问每个特征的坐标。

min_coords (torch.IntTensor): 定义输出稀疏张量的最小坐标的 D 维向量。如果 contract_coords 为 True，则 min_coords 也会被收缩。

tensor_stride (torch.IntTensor): 定义张量元素之间步长的 D 维向量。

unique_index

MinkowskiEngine.MinkowskiTensor 模块

class MinkowskiEngine.MinkowskiTensor.SparseTensorOperationMode(value)

基类：enum.Enum

SparseTensor 内部实例化模式的枚举类。

SEPARATE_COORDINATE_MANAGER: 始终创建一个新的坐标管理器。

SHARE_COORDINATE_MANAGER: 始终使用全局定义的坐标管理器。必须通过 MinkowskiEngine.SparseTensor.clear_global_coordinate_manager 手动清除坐标管理器。

SEPARATE_COORDINATE_MANAGER = 0

SHARE_COORDINATE_MANAGER = 1

class MinkowskiEngine.MinkowskiTensor.SparseTensorQuantizationMode(value)

基类：enum.Enum

RANDOM_SUBSAMPLE: 随机对每个量化块中的一个坐标进行子采样。UNWEIGHTED_AVERAGE: 平均量化块内的所有特征。UNWEIGHTED_SUM: 相等地对量化块内的所有特征求和。NO_QUANTIZATION: 不应用量化。不应在正常操作中使用。

MAX_POOL = 4

NO_QUANTIZATION = 3

RANDOM_SUBSAMPLE = 0

UNWEIGHTED_AVERAGE = 1

UNWEIGHTED_SUM = 2

class MinkowskiEngine.MinkowskiTensor.Tensor

基类: object

一个稀疏张量类。可以通过 MinkowskiEngine.SparseTensor 访问。

SparseTensor 类是 MinkowskiEngine 中的基本张量。有关稀疏张量的定义，请访问术语页面。我们使用 COOrdinate (COO) 格式来保存稀疏张量 [1]。这种表示形式只是矩阵 \(C\) 中的坐标和关联的特征 \(F\) 的串联。

\[\begin{split}\mathbf{C} = \begin{bmatrix} b_1 & x_1^1 & x_1^2 & \cdots & x_1^D \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ b_N & x_N^1 & x_N^2 & \cdots & x_N^D \end{bmatrix}, \; \mathbf{F} = \begin{bmatrix} \mathbf{f}_1^T\\ \vdots\\ \mathbf{f}_N^T \end{bmatrix}\end{split}\]

其中 \(\mathbf{x}_i \in \mathcal{Z}^D\) 是一个 \(D\) 维坐标，\(b_i \in \mathcal{Z}_+\) 表示相应的批次索引。\(N\) 是稀疏张量中非零元素的数量，每个元素具有坐标 \((b_i, x_i^1, x_i^1, \cdots, x_i^D)\) 和相关的特征 \(\mathbf{f}_i\)。在内部，我们将批次索引作为额外的空间维度进行处理。

示例

>>> coords, feats = ME.utils.sparse_collate([coords_batch0, coords_batch1], [feats_batch0, feats_batch1])
>>> A = ME.SparseTensor(features=feats, coordinates=coords)
>>> B = ME.SparseTensor(features=feats, coordinate_map_key=A.coordiante_map_key, coordinate_manager=A.coordinate_manager)
>>> C = ME.SparseTensor(features=feats, coordinates=coords, quantization_mode=ME.SparseTensorQuantizationMode.UNWEIGHTED_AVERAGE)
>>> D = ME.SparseTensor(features=feats, coordinates=coords, tensor_stride=2)

警告

要将 GPU 后端用于坐标管理，coordinates 必须是 GPU 上的 torch 张量。在使用 CPU coordinates 初始化 MinkowskiEngine.SparseTensor 后应用 to(device) 会浪费时间和计算来创建 CPU CoordinateMap，因为 GPU CoordinateMap 将从头开始创建。

警告

在 MinkowskiEngine 0.4 版本之前，我们将批次索引放在最后一列。因此，直接操作坐标将与最新版本不兼容。相反，请使用 MinkowskiEngine.utils.batched_coordinates 或 MinkowskiEngine.utils.sparse_collate 来创建批处理坐标。

此外，要批量访问坐标或特征，请使用稀疏张量的函数 coordinates_at(batch_index : int)，features_at(batch_index : int)。或者访问所有批处理坐标和特征，使用稀疏张量的 decomposed_coordinates, decomposed_features, decomposed_coordinates_and_features。

示例

>>> coords, feats = ME.utils.sparse_collate([coords_batch0, coords_batch1], [feats_batch0, feats_batch1])
>>> A = ME.SparseTensor(feats=feats, coords=coords)
>>> coords_batch0 = A.coordinates_at(batch_index=0)
>>> feats_batch1 = A.features_at(batch_index=1)
>>> list_of_coords, list_of_featurs = A.decomposed_coordinates_and_features

property C

coords 的别名。

property D

attr:D 的别名

property F

feats 的别名。

property coordinate_manager

coordinate_map_key

property coordinates

当前稀疏张量的坐标。坐标表示为 \(N \times (D + 1)\) 维矩阵，其中 \(N\) 是空间中的点数，\(D\) 是空间的维度（例如，3D 为 3，3D + 时间为 4）。矩阵 C 列的附加维度用于批次索引，该索引在内部被视为附加空间维度，以分离批次中的不同实例。

coordinates_and_features_at(batch_index)

返回指定批次索引处的坐标和特征矩阵。

返回指定 batch_index 处的坐标和特征矩阵。坐标矩阵是一个 torch.IntTensor \(C \in \mathcal{R}^{N \times D}\)，其中 \(N\) 是 \(D\) 维空间中指定批次索引中非零元素的数量。特征矩阵是一个 torch.Tensor \(C \in \mathcal{R}^{N \times N_F}\) 矩阵，其中 \(N\) 是指定批次索引中非零元素的数量，\(N_F\) 是通道的数量。

注意

每个批次中特征的顺序是不确定的。要检索生成分解特征的顺序，请使用 decomposition_permutations。

coordinates_at(batch_index)

返回指定批次索引处的坐标。

返回指定批次索引处的 torch.IntTensor \(C \in \mathcal{R}^{N_i \times D}\) 坐标，其中 \(N_i\) 是 \(i\) 维空间中非零元素的数量。

注意

每个批次中坐标的顺序是不确定的。使用 decomposed_coordinates_and_features 检索具有相同顺序的坐标特征。要检索生成分解坐标的顺序，请使用 decomposition_permutations。

property decomposed_coordinates

返回每个批次的坐标列表。

返回一个 torch.IntTensor 列表，其中每个列表包含每个批次的坐标 \(C \in \mathcal{R}^{N_i \times D}\)，其中 \(N_i\) 是 \(i\) 维空间中非零元素的数量。

注意

每个批次中坐标的顺序是不确定的。使用 decomposed_coordinates_and_features 检索具有相同顺序的坐标特征。要检索生成分解坐标的顺序，请使用 decomposition_permutations。

属性 decomposed_coordinates_and_features

返回每个批次的坐标列表和特征列表。abs

注意

分解坐标和特征的顺序在每个批次内是不确定的。要检索分解特征生成的顺序，请使用 decomposition_permutations。

属性 decomposed_features

返回每个批次的特征列表。

返回一个 torch.Tensor 列表，其中每个列表包含每个批次的特征 \(C \in \mathcal{R}^{N_i \times N_F}\)，其中 \(N_i\) 是 \(i\) 维空间中非零元素的数量。

注意

特征的顺序在每个批次内是不确定的。使用 decomposed_coordinates_and_features 以相同的顺序检索坐标和特征。要检索分解特征生成的顺序，请使用 decomposition_permutations。

属性 decomposition_permutations

返回每个批次的索引列表，其中索引定义了批次分解的排列。

示例

>>> # coords, feats, labels are given. All follow the same order
>>> stensor = ME.SparseTensor(feats, coords)
>>> conv = ME.MinkowskiConvolution(in_channels=3, out_nchannel=3, kernel_size=3, dimension=3)
>>> list_of_featurs = stensor.decomposed_features
>>> list_of_permutations = stensor.decomposition_permutations
>>> # list_of_features == [feats[inds] for inds in list_of_permutations]
>>> list_of_decomposed_labels = [labels[inds] for inds in list_of_permutations]
>>> for curr_feats, curr_labels in zip(list_of_features, list_of_decomposed_labels):
>>>     loss += torch.functional.mse_loss(curr_feats, curr_labels)

detach()

属性 device

属性 dimension

attr:D 的别名

double()

属性 dtype

属性 features

当前稀疏张量的特征。特征是 \(N \times D_F\)，其中 \(N\) 是空间中点的数量，\(D_F\) 是每个特征向量的维度。请参考 coords 来访问关联的坐标。

features_at(batch_index)

返回指定批次索引处的特征矩阵。

返回一个 torch.Tensor \(C \in \mathcal{R}^{N \times N_F}\) 特征矩阵，其中 \(N\) 是指定批次索引中非零元素的数量，\(N_F\) 是通道的数量。

注意

特征的顺序在每个批次内是不确定的。使用 decomposed_coordinates_and_features 以相同的顺序检索坐标和特征。要检索分解特征生成的顺序，请使用 decomposition_permutations。

float()

get_device()

inverse_mapping

quantization_mode

属性 requires_grad

requires_grad_(requires_grad: bool = True)

属性 shape

size()

属性 tensor_stride

unique_index

MinkowskiEngine.MinkowskiTensor.clear_global_coordinate_manager()

清除全局坐标管理器缓存。

当您使用操作模式：MinkowskiEngine.SparseTensor.SparseTensorOperationMode.SHARE_COORDINATE_MANAGER 时，您必须在每次前向/后向传播后显式清除坐标管理器。

MinkowskiEngine.MinkowskiTensor.global_coordinate_manager()

返回当前的全局坐标管理器

MinkowskiEngine.MinkowskiTensor.set_global_coordinate_manager(coordinate_manager)

设置全局坐标管理器。

MinkowskiEngine.CoordinateManager 将设置为全局坐标管理器的坐标管理器。

MinkowskiEngine.MinkowskiTensor.set_sparse_tensor_operation_mode(operation_mode: MinkowskiEngine.MinkowskiTensor.SparseTensorOperationMode)

定义稀疏张量坐标管理器的操作模式。

默认情况下，MinkowskiEngine.SparseTensor.SparseTensor 实例化会创建一个新的坐标管理器，该管理器不与其他稀疏张量共享。 通过使用 MinkowskiEngine.SparseTensorOperationMode.SHARE_COORDINATE_MANAGER 设置此函数，您可以与其他稀疏张量全局共享坐标管理器。 但是，您必须在使用后显式清除坐标管理器。 请参考 MinkowskiEngine.clear_global_coordinate_manager。

参数

operation_mode（MinkowskiEngine.SparseTensorOperationMode）：稀疏张量坐标管理器的操作模式。 默认为 MinkowskiEngine.SparseTensorOperationMode.SEPARATE_COORDINATE_MANAGER。

示例

>>> import MinkowskiEngine as ME
>>> ME.set_sparse_tensor_operation_mode(ME.SparseTensorOperationMode.SHARE_COORDINATE_MANAGER)
>>> ...
>>> a = ME.SparseTensor(...)
>>> b = ME.SparseTensor(...)  # coords_man shared
>>> ...  # one feed forward and backward
>>> ME.clear_global_coordinate_manager()  # Must use to clear the coordinates after one forward/backward

MinkowskiEngine.MinkowskiTensor.sparse_tensor_operation_mode() → MinkowskiEngine.MinkowskiTensor.SparseTensorOperationMode

返回当前稀疏张量操作模式。

MinkowskiEngine.MinkowskiTensorField 模块

class MinkowskiEngine.MinkowskiTensorField.TensorField(features: torch.Tensor, coordinates: Optional[torch.Tensor] = None, tensor_stride: Union[int, collections.abc.Sequence, numpy.ndarray, torch.IntTensor] = 1, coordinate_field_map_key: Optional[MinkowskiEngineBackend._C.CoordinateMapKey] = None, coordinate_manager: Optional[MinkowskiCoordinateManager.CoordinateManager] = None, quantization_mode: MinkowskiTensor.SparseTensorQuantizationMode = <SparseTensorQuantizationMode.UNWEIGHTED_AVERAGE: 1>, allocator_type: Optional[MinkowskiEngineBackend._C.GPUMemoryAllocatorType] = None, minkowski_algorithm: Optional[MinkowskiEngineBackend._C.MinkowskiAlgorithm] = None, requires_grad=None, device=None)

基类: MinkowskiTensor.Tensor

属性 C

coords 的别名。

coordinate_field_map_key

属性 coordinates

当前稀疏张量的坐标。坐标表示为 \(N \times (D + 1)\) 维矩阵，其中 \(N\) 是空间中的点数，\(D\) 是空间的维度（例如，3D 为 3，3D + 时间为 4）。矩阵 C 列的附加维度用于批次索引，该索引在内部被视为附加空间维度，以分离批次中的不同实例。

inverse_mapping(sparse_tensor_map_key: MinkowskiEngineBackend._C.CoordinateMapKey)

quantization_mode

sparse(tensor_stride: Union[int, collections.abc.Sequence, numpy.array] = 1, coordinate_map_key: Optional[MinkowskiEngineBackend._C.CoordinateMapKey] = None, quantization_mode=None)

将当前稀疏张量场转换为稀疏张量。

MinkowskiEngine.MinkowskiUnion 模块

class MinkowskiEngine.MinkowskiUnion.MinkowskiUnion

基类: torch.nn.modules.module.Module

创建所有稀疏张量的联合并添加重叠的特征。

参数

None

警告

此函数是实验性的，并且用法可能会在未来的更新中更改。

forward(*inputs)

参数

可变数量的 MinkowskiEngine.SparseTensor。

返回值

一个 MinkowskiEngine.SparseTensor，其坐标是所有输入坐标的并集，特征是与坐标对应的所有特征的总和。

示例

>>> # Define inputs
>>> input1 = SparseTensor(
>>>     torch.rand(N, in_channels, dtype=torch.double), coords=coords)
>>> # All inputs must share the same coordinate manager
>>> input2 = SparseTensor(
>>>     torch.rand(N, in_channels, dtype=torch.double),
>>>     coords=coords + 1,
>>>     coords_manager=input1.coordinate_manager,  # Must use same coords manager
>>>     force_creation=True  # The tensor stride [1, 1] already exists.
>>> )
>>> union = MinkowskiUnion()
>>> output = union(input1, iput2)

training: bool

class MinkowskiEngine.MinkowskiUnion.MinkowskiUnionFunction

基类: torch.autograd.function.Function

static backward(ctx, grad_out_feat)

定义一个用于区分操作的公式。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，然后是和 forward() 返回的输出一样多的参数，并且它应该返回和 forward() 的输入一样多的张量。每个参数是关于给定输出的梯度，并且每个返回值应该是关于相应输入的梯度。

上下文可以用于检索在正向传递期间保存的张量。它还具有一个属性 ctx.needs_input_grad，它是一个布尔值的元组，表示每个输入是否需要梯度。例如，如果 forward() 的第一个输入需要计算关于输出的梯度，则 backward() 将具有 ctx.needs_input_grad[0] = True。

static forward(ctx, in_coords_keys: list, out_coords_key: MinkowskiEngineBackend._C.CoordinateMapKey, coordinate_manager: MinkowskiCoordinateManager.CoordinateManager, *in_feats)

执行操作。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟任意数量的参数（张量或其他类型）。

上下文可以用于存储可在后向传递期间检索的张量。

MinkowskiEngine.diagnostics 模块

MinkowskiEngine.diagnostics.parse_nvidia_smi()

MinkowskiEngine.diagnostics.print_diagnostics()

MinkowskiEngine.sparse_matrix_functions 模块

class MinkowskiEngine.sparse_matrix_functions.MinkowskiSPMMAverageFunction

基类: torch.autograd.function.Function

static backward(ctx, grad: torch.Tensor)

定义一个用于区分操作的公式。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，然后是和 forward() 返回的输出一样多的参数，并且它应该返回和 forward() 的输入一样多的张量。每个参数是关于给定输出的梯度，并且每个返回值应该是关于相应输入的梯度。

上下文可以用于检索在正向传递期间保存的张量。它还具有一个属性 ctx.needs_input_grad，它是一个布尔值的元组，表示每个输入是否需要梯度。例如，如果 forward() 的第一个输入需要计算梯度，则 backward() 将具有 ctx.needs_input_grad[0] = True。

static forward(ctx, rows: torch.Tensor, cols: torch.Tensor, size: torch.Size, mat: torch.Tensor, cuda_spmm_alg: int = 1)

执行操作。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟任意数量的参数（张量或其他类型）。

上下文可以用于存储可在后向传递期间检索的张量。

class MinkowskiEngine.sparse_matrix_functions.MinkowskiSPMMFunction

基类: torch.autograd.function.Function

static backward(ctx, grad: torch.Tensor)

定义一个用于区分操作的公式。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，然后是和 forward() 返回的输出一样多的参数，并且它应该返回和 forward() 的输入一样多的张量。每个参数是关于给定输出的梯度，并且每个返回值应该是关于相应输入的梯度。

上下文可以用于检索在正向传递期间保存的张量。它还具有一个属性 ctx.needs_input_grad，它是一个布尔值的元组，表示每个输入是否需要梯度。例如，如果 forward() 的第一个输入需要计算梯度，则 backward() 将具有 ctx.needs_input_grad[0] = True。

static forward(ctx, rows: torch.Tensor, cols: torch.Tensor, vals: torch.Tensor, size: torch.Size, mat: torch.Tensor, cuda_spmm_alg: int = 1)

执行操作。

此函数将被所有子类覆盖。

它必须接受一个上下文 ctx 作为第一个参数，后跟任意数量的参数（张量或其他类型）。

上下文可以用于存储可在后向传递期间检索的张量。

MinkowskiEngine.sparse_matrix_functions.spmm(rows: torch.Tensor, cols: torch.Tensor, vals: torch.Tensor, size: torch.Size, mat: torch.Tensor, is_sorted: bool = False, cuda_spmm_alg: int = 1) → torch.Tensor

MinkowskiEngine.sparse_matrix_functions.spmm_average(rows: torch.Tensor, cols: torch.Tensor, size: torch.Size, mat: torch.Tensor, cuda_spmm_alg: int = 1) -> (<class 'torch.Tensor'>, <class 'torch.Tensor'>, <class 'torch.Tensor'>)

模块内容