MinkowskiEngine.utils 包¶

子模块¶

MinkowskiEngine.utils.collation 模块¶

class MinkowskiEngine.utils.collation.SparseCollation(limit_numpoints=- 1, dtype=torch.int32, device=None)¶

基类：object

为坐标、特征、标签生成整理函数。

有关用法，请参阅训练示例。

参数: limit_numpoints (int)：如果为正整数，则限制批次大小，以使输入坐标的数量低于 limit_numpoints。如果为 0 或 False，则连接所有点。默认为 -1。

示例

>>> data_loader = torch.utils.data.DataLoader(
>>>     dataset,
>>>     ...,
>>>     collate_fn=SparseCollation())
>>> for d in iter(data_loader):
>>>     print(d)

MinkowskiEngine.utils.collation.batch_sparse_collate(data, dtype=torch.int32, device=None)¶

可以与 torch.utils.data.DataLoader 结合使用的包装器函数，用于为稀疏张量生成输入。

有关用法，请参阅训练示例。

参数: data：(坐标、特征、标签) 元组的列表。

MinkowskiEngine.utils.collation.batched_coordinates(coords, dtype=torch.int32, device=None)¶

从坐标序列创建 ME.SparseTensor 坐标

给定一个 numpy 或 pytorch 张量坐标列表，返回适合 ME.SparseTensor 的批处理坐标。

参数

coords ( torch.Tensor 或 numpy.ndarray 序列)：坐标列表。

dtype：返回张量的 torch 数据类型。默认为 torch.int32。

返回值

batched_coordindates (torch.Tensor)：批处理坐标。

警告

从 v0.4 开始，批处理索引将预先添加到所有坐标之前。

MinkowskiEngine.utils.collation.sparse_collate(coords, feats, labels=None, dtype=torch.int32, device=None)¶

为稀疏张量创建输入参数文档。

将一组坐标和特征转换为批处理坐标和批处理特征。

参数

coords ( torch.Tensor 或 numpy.ndarray 集)：一组坐标。

feats ( torch.Tensor 或 numpy.ndarray 集)：一组特征。

labels ( torch.Tensor 或 numpy.ndarray 集)：与输入关联的一组标签。

MinkowskiEngine.utils.coords 模块¶

MinkowskiEngine.utils.coords.get_coords_map(x, y)¶

获取稀疏张量 1 和稀疏张量 2 之间的映射。

参数

x (MinkowskiEngine.SparseTensor)：一个稀疏张量，其 x.tensor_stride <= y.tensor_stride。

y (MinkowskiEngine.SparseTensor)：一个稀疏张量，其 x.tensor_stride <= y.tensor_stride。

返回值

x_indices (torch.LongTensor)：x 的索引，对应于 y 的返回索引。

x_indices (torch.LongTensor)：y 的索引，对应于 x 的返回索引。

示例

.. code-block:: python

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

   ins, outs = get_coords_map(sp_tensor, out_sp_tensor)
   for i, o in zip(ins, outs):
      print(f"{i} -> {o}")

MinkowskiEngine.utils.gradcheck 模块¶

MinkowskiEngine.utils.gradcheck.gradcheck(func: Callable[[…], Union[torch.Tensor, Sequence[torch.Tensor]]], inputs: Union[torch.Tensor, Sequence[torch.Tensor]], eps: float = 1e-06, atol: float = 1e-05, rtol: float = 0.001, raise_exception: bool = True, check_sparse_nnz: bool = False, nondet_tol: float = 0.0, check_undefined_grad: bool = True, check_grad_dtypes: bool = False) → bool¶

根据关于 inputs 中浮点或复数类型且具有 requires_grad=True 的张量的解析梯度，检查通过小有限差分计算的梯度。数值梯度和解析梯度之间的检查使用 allclose()。对于复数函数，不存在雅可比行列式的概念。 Gradcheck 验证 Wirtinger 和共轭 Wirtinger 导数的数值和解析值是否一致。梯度计算是在整体函数具有实数值输出的假设下完成的。对于具有复数输出的函数，gradcheck 比较 grad_output 的两个值的数值和解析梯度：1 和 1j。有关更多详细信息，请查看 complex_autograd-doc。 .. note

The default values are designed for :attr:`input` of double precision.
This check will likely fail if :attr:`input` is of less precision, e.g.,
``FloatTensor``.

警告

如果 input 中的任何经过检查的张量具有重叠的内存，即，指向相同内存地址的不同索引(例如，来自 torch.expand())，则此检查可能会失败，因为通过此类索引处的点扰动计算的数值梯度将更改共享相同内存地址的所有其他索引处的值。

参数

func (函数)：一个 Python 函数，它接受 Tensor 输入并返回: 一个 Tensor 或一个 Tensor 元组

inputs (Tensor 或 Tensor 元组)：函数的输入 eps (float，可选)：有限差分的扰动 atol (float，可选)：绝对容差 rtol (float，可选)：相对容差 raise_exception (bool，可选)：指示是否引发异常，如果

检查失败。该异常提供了有关失败的确切性质的更多信息。这在调试 gradchecks 时很有用。

check_sparse_nnz (bool，可选)：如果为 True，则 gradcheck 允许 SparseTensor 输入，: 对于输入端的任何 SparseTensor，gradcheck 将只在非零（nnz）位置执行检查。
nondet_tol (float, optional): 非确定性的容忍度。当运行: 通过微分的相同输入时，结果必须完全匹配（默认值，0.0）或在此容差范围内。
check_undefined_grad (bool, options): 如果为 True，检查是否支持未定义的输出梯度: 并将它们视为零。

返回值

如果所有差异都满足 allclose 条件，则为 True

MinkowskiEngine.utils.init 模块¶

MinkowskiEngine.utils.init.kaiming_normal_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu')¶

MinkowskiEngine.utils.quantization 模块¶

MinkowskiEngine.utils.quantization.fnv_hash_vec(arr)¶: FNV64-1A

MinkowskiEngine.utils.quantization.quantize(coords)¶

返回唯一的索引映射和反向索引映射。

参数

coords (numpy.ndarray 或 torch.Tensor): 大小为 \(N \times D\) 的矩阵，其中 \(N\) 是 \(D\) 维空间中点的数量。

返回值

unique_map (numpy.ndarray 或 torch.Tensor): 定义唯一坐标的索引列表。 coords[unique_map] 是唯一坐标。

inverse_map (numpy.ndarray 或 torch.Tensor): 定义反向映射以恢复原始坐标的索引列表。 coords[unique_map[inverse_map]] == coords

示例

>>> unique_map, inverse_map = quantize(coords)
>>> unique_coords = coords[unique_map]
>>> print(unique_coords[inverse_map] == coords)  # True, ..., True
>>> print(coords[unique_map[inverse_map]] == coords)  # True, ..., True

MinkowskiEngine.utils.quantization.quantize_label(coords, labels, ignore_label)¶

MinkowskiEngine.utils.quantization.ravel_hash_vec(arr)¶: 在减去最小坐标后，展开坐标。

MinkowskiEngine.utils.quantization.sparse_quantize(coordinates, features=None, labels=None, ignore_label=- 100, return_index=False, return_inverse=False, return_maps_only=False, quantization_size=None, device='cpu')¶

给定坐标和特征（可选标签），该函数生成量化的（体素化的）坐标。

参数

coordinates (numpy.ndarray 或 torch.Tensor): 大小为 \(N \times D\) 的矩阵，其中 \(N\) 是 \(D\) 维空间中点的数量。

features (numpy.ndarray 或 torch.Tensor, optional): 大小为 \(N \times D_F\) 的矩阵，其中 \(N\) 是点的数量，\(D_F\) 是特征的维度。必须与 coords 具有相同的容器（即，如果 coords 是 torch.Tensor，则 feats 也必须是 torch.Tensor）。

labels (numpy.ndarray 或 torch.IntTensor, optional): 与每个坐标关联的整数标签。必须与 coords 具有相同的容器（即，如果 coords 是 torch.Tensor，则 labels 也必须是 torch.Tensor）。对于将一组点映射到一个标签的分类，请勿输入标签。

ignore_label (int, optional): IGNORE LABEL 的 int 值。 torch.nn.CrossEntropyLoss(ignore_index=ignore_label)

return_index (bool, optional): 如果您想要量化坐标的索引，请设置为 True。默认值为 False。

return_inverse (bool, optional): 如果您想要可以恢复离散化原始坐标的索引，请设置为 True。默认值为 False。当 return_reverse 为 True 时，return_index 必须为 True。

return_maps_only (bool, optional): 如果设置，则返回 unique_map 或可选的反向映射，但不返回坐标。如果您不关心最终坐标，或者如果您使用 device==cuda 并且不需要 GPU 上的坐标，则可以使用。如果设置了 return_inverse，则返回 unique_map 单独或 (unique_map, inverse_map)。

quantization_size (attr:float, optional): 如果设置，将使用量化大小来定义坐标之间的最小距离。

device (attr:str, optional): ‘cpu’ 或 ‘cuda’。

示例
>>> unique_map, inverse_map = sparse_quantize(discrete_coords, return_index=True, return_inverse=True)
>>> unique_coords = discrete_coords[unique_map]
>>> print(unique_coords[inverse_map] == discrete_coords)  # True
quantization_size (float, list, 或 numpy.ndarray, optional): 网格单元的超矩形每条边的长度。

示例

>>> # Segmentation
>>> criterion = torch.nn.CrossEntropyLoss(ignore_index=-100)
>>> coords, feats, labels = MinkowskiEngine.utils.sparse_quantize(
>>>     coords, feats, labels, ignore_label=-100, quantization_size=0.1)
>>> output = net(MinkowskiEngine.SparseTensor(feats, coords))
>>> loss = criterion(output.F, labels.long())
>>>
>>> # Classification
>>> criterion = torch.nn.CrossEntropyLoss(ignore_index=-100)
>>> coords, feats = MinkowskiEngine.utils.sparse_quantize(coords, feats)
>>> output = net(MinkowskiEngine.SparseTensor(feats, coords))
>>> loss = criterion(output.F, labels.long())

MinkowskiEngine.utils.quantization.unique_coordinate_map(coordinates: torch.Tensor, tensor_stride: Union[int, collections.abc.Sequence, numpy.ndarray] = 1) → Tuple[torch.IntTensor, torch.IntTensor]¶

返回坐标的唯一索引和反向索引。

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

示例

>>> coordinates = torch.IntTensor([[0, 0], [0, 0], [0, 1], [0, 2]])
>>> unique_map, inverse_map = unique_coordinates_map(coordinates)
>>> coordinates[unique_map] # unique coordinates
>>> torch.all(coordinates == coordinates[unique_map][inverse_map]) # True

MinkowskiEngine.utils 包¶

子模块¶

MinkowskiEngine.utils.collation 模块¶

MinkowskiEngine.utils.coords 模块¶

MinkowskiEngine.utils.gradcheck 模块¶

MinkowskiEngine.utils.init 模块¶

MinkowskiEngine.utils.quantization 模块¶

模块内容¶