# Learning3D: a collection of point cloud networks rather than a framework

> Learning3D is a PyTorch library that gathers point cloud algorithms from the literature into one importable package, with pretrained weights and a loss function library. It is a menu rather than a framework: the modules are usable independently, and the documentation expects you to know which network fits your task.

**vinits5/learning3d** — This is a complete package of recent deep learning methods for 3D point clouds in pytorch (with pretrained models).

- Repository: https://github.com/vinits5/learning3d
- Stars: 857 · Forks: 109
- Language: Python
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/vinits5-learning3d

## Six tasks, one package, and a decision you have to make yourself

Learning3D collects deep learning methods for 3D point clouds into a single Python package. The task coverage is listed as a table, and the spread tells you what kind of project this is. Classification includes PointNet, DGCNN, PPFNet, PointConv, CurveNet and IAE. Segmentation covers PointNet and DGCNN. Reconstruction lists the Point Completion Network. Registration carries PointNetLK, PCRNet, DCP, PRNet, RPM-Net and DeepGMR. Flow estimation has FlowNet3D, and inlier estimation has MaskNet and MaskNet++.

Six tasks, sixteen or so named networks. That is the shape of the project: a curated shelf of published architectures with a consistent calling convention, not a framework with a training loop, a config system and a plugin model.

The practical consequence is that you still have to choose. Nothing here decides whether your problem is registration or reconstruction for you. The value on offer is that once you have decided, the network is a few lines of code away and there is a trained checkpoint to start from.

The library also collects supporting pieces. The loss function list has classification loss via cross entropy, registration losses as FrobeniusNormLoss and RMSEFeaturesLoss, distance losses including Chamfer Distance and Earth Mover's Distance, and a correspondence loss derived from a specific paper on correspondence matrices. A Chamfer Distance implementation that is purely PyTorch based was incorporated in May 2022.

The audience is academic and applied research: people reproducing a paper, comparing architectures on the same data loader, or building on top of one of these networks.

## The layout is models, losses, data_utils and pretrained, and that is the whole contract

The documentation is unusually blunt about how to use the library, and it starts with a warning: clone this repository into your project, and do not add your own code inside the learning3d folder. That single instruction tells you the intended integration model. You vendor the code, not the package.

The four rules that follow define the contract. All networks are defined in the models module. All loss functions are defined in the losses module. Data loaders are pre-defined in data_utils/dataloaders.py. And the pretrained models are provided in the learning3d/pretrained folder.

At the repository root the directory listing matches that description, and adds a few things the documentation does not spell out: an ops directory, a utils directory, a requirements.txt, and an images folder. The ops directory is worth noticing in combination with the requirements file, which includes ninja and carries a commented pycuda entry. That combination suggests the repository contains custom operations that may need a CUDA toolchain to build.

The examples directory is the practical documentation. There are twenty-one example scripts, and the pattern is consistent: one test script per network, such as test_pointnet.py, test_dcp.py, test_deepgmr.py, test_flownet.py, test_iae.py, test_masknet.py, test_masknet2.py, test_pcn.py, test_pcrnet.py, test_pnlk.py, test_pointconv.py, test_prnet.py, test_rpmnet.py and test_curvenet.py, plus a set of training scripts that mirror the same names with a train_ prefix.

Having both test and train scripts for each network is the detail that makes this usable as a research base. You are not only given a forward pass, you are given the training entry point too.

## Constructing a network is one import and one call with keyword arguments

The API style is uniform across the families. You import the network from learning3d.models, construct it with keyword arguments that map to documented variables, and then call it. For point embedding networks the documentation shows the constructors together, and the variable table explains what each argument controls.

```python
> from learning3d.models import PointNet, DGCNN, PPFNet\
> pn = PointNet(emb_dims=1024, input_shape='bnc', use_bn=False)\
> dgcnn = DGCNN(emb_dims=1024, input_shape='bnc')\
> ppf = PPFNet(features=['ppf', 'dxyz', 'xyz'], emb_dims=96, radius='0.3', num_neighbours=64)
```

The variables are the ones that matter when you move between networks. emb_dims is the size of the feature vector for each point, with 1024 and 512 given as the choices. input_shape selects the shape of the input point cloud and takes either bnc or bcn. features is the list of per-point features used by PPFNet. radius is the cluster radius for computing local features, given as 0.3, and num_neighbours caps how many points are considered per cluster, given as 64. The output shape is BxCxN, high dimensional embeddings for each point.

Classification and segmentation wrap an embedding network, so the same feature_model argument accepts either PointNet or DGCNN.

```python
> from learning3d.models import Classifier, PointNet, Segmentation\
> classifier = Classifier(feature_model=PointNet(), num_classes=40)\
> seg = Segmentation(feature_model=PointNet(), num_classes=40)
```

num_classes is 10 or 40, matching the category counts of the datasets in play, and the outputs differ by task: Bx40 for classification and BxNx40 for segmentation, where the second dimension is per point.

Registration networks take more arguments because they have more moving parts, and the differences are informative. PointNetLK exposes delta, xtol and two zero-mean flags along with a pooling choice. DCP takes a pointer_ type and a head type. RPM-Net and DeepGMR take a feature_model, with RPM-Net using PPFNet in the example. These are not cosmetic differences, they are the places where a registration pipeline diverges between methods.

## Pretrained weights cover most of the shelf, but not uniformly

Fourteen pretrained models are listed, and the gaps are informative. PointNet, PCN, PointNetLK, PCRNet, DCP, PRNet, FlowNet3D, DeepGMR, MaskNet, MaskNet2, CurveNet and an Implicit Autoencoder are all covered directly. Two entries are qualified. RPM-Net has three separate checkpoints, clean-trained.pth, noisy-trained.pth and partial-pretrained.pth, which reflects the fact that registration robustness depends on how well the source and target point clouds correspond. PointConv is not hosted in the repository at all; the documentation points to an external link for that checkpoint.

So if you pick a network from this list, check which case you are in. A registration experiment where the point clouds overlap only partially needs the partial-pretrained weights, and a full overlap needs the clean ones. Treating those as interchangeable would change your results without changing your code.

The dataset situation is much thinner. One dataset is listed, ModelNet40, and it matches the num_classes of 40 used throughout the documentation examples.

The project is also usable with your own data, and that functionality was added in October 2020. The data loaders live in data_utils/dataloaders.py, and the loader module is where you would point at your own point clouds rather than ModelNet40.

## Installing from PyPI or from a clone, with a version branch for the package path

There are two documented setup paths, and they are not equivalent.

The short one is a single command from the package index.

```bash
pip install learning3d
```

The other clones the repository and installs it from source, and it pins a branch.

```bash
git clone https://github.com/vinits5/learning3d.git
cd learning3d
git checkout pypi_v0.1.0
python3 -m pip install .
```

That git checkout to pypi_v0.1.0 is a meaningful detail. The PyPI branch is a separate line in the repository, so the packaged version and the master branch are not the same tree. The project has been available on PyPI since April 2024, and the master branch has continued to receive new networks since then, including IAE in July 2026 and CurveNet in February 2025. If you want the newest architectures, the packaged install may not contain them.

The runtime requirements are stated explicitly: CUDA 10.0 or higher, PyTorch 1.3 or higher, and Python 3.8. The supported operating systems listed are Ubuntu 16.04, Ubuntu 18.04, Ubuntu 20.04.6, Linux Mint and macOS Sequoia 15.3.1.

The requirements file pins much more tightly than the prose does, with torch 2.0.1, torchvision 0.15.2, h5py 3.8.0, ninja 1.11.1, open3d 0.17.0, tensorboardX 2.6, tqdm 4.65.0, scikit-learn 1.2.2, scipy 1.10.1, numpy 1.24.3 and transforms3d 0.4.1. Note the mismatch between the prose, which says Python 3.8, and the pinned numpy and scipy versions, which are from a much later era of the ecosystem. The two statements were not kept in step, so trust the pins over the prose when you build an environment.

## Where Learning3D is the wrong tool

The first wrong-tool case is a production training pipeline. There is no config file, no experiment tracker, no checkpoint manager and no distributed launcher in the documentation. The artifacts are networks, losses, loaders and weights. That is a research starting point, and a team that needs a reproducible training pipeline with data versioning and automatic evaluation will be writing that layer themselves.

The second case is a project that needs a task Learning3D does not cover. Segmentation has only PointNet and DGCNN while classification has six networks, reconstruction has one network and flow has one. If your problem is semantic segmentation of large outdoor scans at scale, the shelf is thin, and the pretrained weights are all tied to ModelNet40-style object data.

The third case is an environment you cannot pin. The requirements file names torch 2.0.1, and the commented pycuda line at the end suggests that custom CUDA operations are part of the intended setup. On a machine with a newer GPU stack, or without a CUDA toolchain, the ops directory is where an installation is likely to break.

On maintenance, the last push was on 2026-07-03 and the repository has no GitHub releases, so there is no version history to diff and no changelog to read. The news list in the README is the only record of what changed, and it is maintained by hand. The license is MIT, which is permissive and lets you vendor the code into a commercial project without obligation, which is consistent with the documented instruction to clone the repository into your own project rather than depend on the package.

## Conclusion

Learning3D suits a researcher who wants to reproduce or extend a published point cloud architecture quickly, since the networks arrive with pretrained checkpoints, a shared loss library and ready-made data loaders. It does not suit a production team that needs a maintained API, because the last push was on 2026-07-03, the repository has no GitHub releases, and the requirements file still pins torch 2.0.1 with a commented pycuda line that suggests custom CUDA kernels are an expected part of setup. Before adopting, run one of the examples under the examples/ directory on a CUDA 10.0 or higher machine with PyTorch 1.3 or higher, and clone the repository into your own project rather than installing it as a library, as the documentation instructs.

## FAQ

### How do I install Learning3D?

You can run pip install learning3d from the PyPI server, or clone the repository, check out the pypi_v0.1.0 branch and run python3 -m pip install . from the source tree. The documented runtime requirements are CUDA 10.0 or higher, PyTorch 1.3 or higher and Python 3.8.

### Which point cloud algorithms does Learning3D include?

Classification lists PointNet, DGCNN, PPFNet, PointConv, CurveNet and IAE. Segmentation covers PointNet and DGCNN, reconstruction covers the Point Completion Network, registration lists PointNetLK, PCRNet, DCP, PRNet, RPM-Net and DeepGMR, flow estimation has FlowNet3D, and inlier estimation has MaskNet and MaskNet++.

### Where are the pretrained models in Learning3D?

Fourteen pretrained models are listed and they are provided in the learning3d/pretrained folder. RPM-Net has separate clean-trained, noisy-trained and partial-pretrained checkpoints, and the PointConv checkpoint is downloaded from an external link.

### How do I use my own point cloud data with Learning3D?

The documentation states that data loaders are pre-defined in data_utils/dataloaders.py, and the project added support for using your own data in October 2020. The only dataset shipped by default is ModelNet40.

### What license is Learning3D released under?

Learning3D is licensed under the MIT License, with the LICENSE file at the root of the repository. The documentation also instructs you to clone the repository into your own project rather than adding code inside the learning3d folder.

## Sources

- [Issues](https://github.com/vinits5/learning3d/issues)
- [License: MIT](https://github.com/vinits5/learning3d/blob/master/LICENSE)
- [README](https://github.com/vinits5/learning3d/blob/master/README.md)
- [vinits5/learning3d on GitHub](https://github.com/vinits5/learning3d)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/vinits5-learning3d