Conformance tooling

torch_lattice_conformance.cli.main(argv=None)

Return type:

None

Parameters:

argv (Sequence[str] | None)

class torch_lattice_conformance.generate.SparseInputSpec(channels, batch_size, spatial_shape, rows_per_batch, dtype=torch.float32, stride=(1, 1, 1))

Bases: object

Parameters:

• channels (int)

• batch_size (int)

• spatial_shape (tuple[int, int, int])

• rows_per_batch (tuple[int, ...])

• dtype (dtype)

• stride (tuple[int, int, int])

channels: int

batch_size: int

spatial_shape: tuple[int, int, int]

rows_per_batch: tuple[int, ...]

dtype: dtype = torch.float32

stride: tuple[int, int, int] = (1, 1, 1)

class torch_lattice_conformance.generate.FuzzCase(name, family, seed, output_kind, input_mode, rtol, atol, metadata)

Bases: object

Parameters:

• name (str)

• family (Literal['sparse_classifier', 'sparse_feature_chain', 'sparse_branch', 'target_branch', 'transpose_chain', 'generative_transpose', 'point_voxel', 'quantized_classifier'])

• seed (int)

• output_kind (Literal['dense', 'sparse'])

• input_mode (Literal['sparse_kwargs', 'dense_kwargs'])

• rtol (float)

• atol (float)

• metadata (dict[str, Any])

name: str

family: Literal['sparse_classifier', 'sparse_feature_chain', 'sparse_branch', 'target_branch', 'transpose_chain', 'generative_transpose', 'point_voxel', 'quantized_classifier']

seed: int

output_kind: Literal['dense', 'sparse']

input_mode: Literal['sparse_kwargs', 'dense_kwargs']

rtol: float

atol: float

metadata: dict[str, Any]

class torch_lattice_conformance.generate.SparseChainModel(stages, *, global_pool=None, head=None)

Bases: Module

Parameters:

• stages (list[nn.Module])

• global_pool (nn.Module | None)

• head (nn.Module | None)

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Parameters:

x (SparseTensor)

class torch_lattice_conformance.generate.SparseBranchModel(left, right, tail, *, merge, join)

Bases: Module

Parameters:

• left (nn.Module)

• right (nn.Module)

• tail (nn.Module)

• merge (Literal['add', 'cat'])

• join (Literal['inner', 'outer'])

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

SparseTensor

Parameters:

x (SparseTensor)

class torch_lattice_conformance.generate.TargetBranchModel(pre, target_conv)

Bases: Module

Parameters:

• pre (nn.Module)

• target_conv (spnn.TargetConv3d)

forward(x, target)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

SparseTensor

Parameters:

• x (SparseTensor)

• target (SparseTensor)

class torch_lattice_conformance.generate.PointVoxelRoundTrip(*, voxel_size, origin, reduction, interpolation)

Bases: Module

Parameters:

• voxel_size (tuple[float, float, float])

• origin (tuple[float, float, float])

• reduction (Literal['sum', 'mean'])

• interpolation (Literal['nearest', 'linear'])

forward(points, features, batch_indices, active_rows)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

Parameters:

• points (Tensor)

• features (Tensor)

• batch_indices (Tensor)

• active_rows (Tensor)

torch_lattice_conformance.generate.main()

Return type:

None

torch_lattice_conformance.e2e.main()

Return type:

None

class torch_lattice_conformance.e2e.SparseClassifier

Bases: Module

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

Parameters:

x (SparseTensor)

class torch_lattice_conformance.e2e.QuantizedClassifier

Bases: Module

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

Parameters:

x (SparseTensor)

class torch_lattice_conformance.e2e.TargetBranch

Bases: Module

forward(x, target)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

SparseTensor

Parameters:

• x (SparseTensor)

• target (SparseTensor)

class torch_lattice_conformance.e2e.PointVoxel(*args, **kwargs)

Bases: Module

Parameters:

• args (Any)

• kwargs (Any)

forward(points, features, batch_indices, active_rows)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

Parameters:

• points (Tensor)

• features (Tensor)

• batch_indices (Tensor)

• active_rows (Tensor)

class torch_lattice_conformance.e2e.TransposeConvolution

Bases: Module

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

SparseTensor

Parameters:

x (SparseTensor)

class torch_lattice_conformance.e2e.GenerativeTransposeConvolution

Bases: Module

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

SparseTensor

Parameters:

x (SparseTensor)

class torch_lattice_conformance.migration.CompatCase(family, seed, output_kind)

Bases: object

Parameters:

• family (Literal['pointwise_chain', 'branch_add', 'branch_cat', 'global_pool', 'batchnorm_chain', 'spatial_subm_mapping', 'stride2_forward'])

• seed (int)

• output_kind (Literal['sparse', 'dense'])

family: Literal['pointwise_chain', 'branch_add', 'branch_cat', 'global_pool', 'batchnorm_chain', 'spatial_subm_mapping', 'stride2_forward']

seed: int

output_kind: Literal['sparse', 'dense']

torch_lattice_conformance.migration.main()

Return type:

None