Pretrained SOTA Deep Learning models, callbacks and more for research and production with PyTorch Lightning and PyTorch
System / PyTorch ver. | 1.6 (min. req.) | 1.6 (latest) |
---|---|---|
Linux py3.6 / py3.7 / py3.8 | ||
OSX py3.6 / py3.7 | ||
Windows py3.6 / py3.7 |
Simple installation from PyPI
pip install pytorch-lightning-bolts
Install bleeding-edge (no guarantees)
pip install git+https://github.com/PytorchLightning/pytorch-lightning-bolts.git@master --upgrade
In case you wan to have full experience you can install all optional packages at once
pip install pytorch-lightning-bolts["extra"]
Bolts is a Deep learning research and production toolbox of:
- SOTA pretrained models.
- Model components.
- Callbacks.
- Losses.
- Datasets.
The main goal of Bolts is to enable rapid model idea iteration.
from pl_bolts.models.self_supervised import SimCLR
from pl_bolts.models.self_supervised.simclr.transforms import SimCLRTrainDataTransform, SimCLREvalDataTransform
import pytorch_lightning as pl
# data
train_data = DataLoader(MyDataset(transforms=SimCLRTrainDataTransform(input_height=32)))
val_data = DataLoader(MyDataset(transforms=SimCLREvalDataTransform(input_height=32)))
# model
weight_path = 'https://pl-bolts-weights.s3.us-east-2.amazonaws.com/simclr/simclr-cifar10-v1-exp12_87_52/epoch%3D960.ckpt'
simclr = SimCLR.load_from_checkpoint(weight_path, strict=False)
simclr.freeze()
# finetune
from pl_bolts.models import ImageGPT
from pl_bolts.models.self_supervised import SimCLR
class VideoGPT(ImageGPT):
def training_step(self, batch, batch_idx):
x, y = batch
x = _shape_input(x)
logits = self.gpt(x)
simclr_features = self.simclr(x)
# -----------------
# do something new with GPT logits + simclr_features
# -----------------
loss = self.criterion(logits.view(-1, logits.size(-1)), x.view(-1).long())
logs = {"loss": loss}
return {"loss": loss, "log": logs}
- Corporate production teams
- Professional researchers
- Ph.D. students
- Linear + Logistic regression heroes
Great! We have LinearRegression and LogisticRegression implementations with numpy and sklearn bridges for datasets! But our implementations work on multiple GPUs, TPUs and scale dramatically...
Check out our Linear Regression on TPU demo
from pl_bolts.models.regression import LinearRegression
from pl_bolts.datamodules import SklearnDataModule
from sklearn.datasets import load_boston
import pytorch_lightning as pl
# sklearn dataset
X, y = load_boston(return_X_y=True)
loaders = SklearnDataModule(X, y)
model = LinearRegression(input_dim=13)
# try with gpus=4!
# trainer = pl.Trainer(gpus=4)
trainer = pl.Trainer()
trainer.fit(model, loaders.train_dataloader(), loaders.val_dataloader())
trainer.test(test_dataloaders=loaders.test_dataloader())
No!
Bolts is unique because models are implemented using PyTorch Lightning and structured so that they can be easily subclassed and iterated on.
For example, you can override the elbo loss of a VAE, or the generator_step of a GAN to quickly try out a new idea. The best part is that all the models are benchmarked so you won't waste time trying to "reproduce" or find the bugs with your implementation.
Bolts is supported by the PyTorch Lightning team and the PyTorch Lightning community!