Hydra Lightning Template for Structured Configs

Overview

Hydra Lightning Template for Structured Configs

Template for creating projects with pytorch-lightning and hydra.

How to use this template?

Create your own project on GitHub with this template by clicking the Use this template button.

You now have to only add your own dataloader, dataset, model, optimizer and loss and you should be ready to go. To see if you have all modules installed and everything works fine, you should run the unit tests!

How to add my own module?

For this tutorial it is expected that you already know pytorch (and best also some pytorch-lightning). If you don't know hydra that should be fine, but definitely check out their docs.

If you encounter any problems have a look at the my_simple_model branch of this repo, where I played through this complete tutorial. So you can find all files there.

Lets explore how to use hydra and this template by showcasing how one would add a simple own CNN to this repo. For the tests I used MNIST as dataset so we will just continue using that. But if you know how to write a pytorch-lightning Dataloader and a torch Dataset it should be just as easy to replace them after this small tutorial.

To add our own model we have to do the following steps:

  1. in the folder src/models we create a new file containing our torch model (a torch.nn.Module).
  2. Add the model in the hydra config library by adding it to the src/lib/model.py file.
  3. Register the model in the hydra global-config-register by following the pattern in src/lib/config.py and creating a new entry there.
  4. (Optional) Create a yaml file for the model. This makes sense if the model is used with a lot of different settings. So we can give those settings individual names, which makes them easier to call.
  5. Add an experiment using that model

1. Creating the simplest model:

Create the file src/models/my_simple_model.py with the following content:

import torch.nn as nn
import torch.nn.functional as F


class MySimpleModel(nn.Module):
    def __init__(self, input_channels=1, num_classes=10):
        super(MySimpleModel, self).__init__()

        # When the image enters the net at conv1 it has a size of 28x28x1, because there is a single color channel
        self.conv1 = nn.Conv2d(input_channels, 16, kernel_size=3, stride=1, padding=1, bias=True)
        # Since we are using padding the size of the image does not change after the conv layer
        self.max_pool = nn.MaxPool2d(kernel_size=2, stride=2)
        # due to the maxpooling shape and stride our image is now 14x14
        self.conv2 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=1, bias=True)
        # still 14x14
        # We will again use maxpool so now it is 7x7
        self.fully_connected = nn.Linear(16 * 7 * 7, num_classes, bias=True)

    def forward(self, x):
        x = self.conv1(x)
        x = self.max_pool(x)
        x = self.conv2(x)
        x = self.max_pool(x)
        x = x.flatten(start_dim=1)  # To use a fully connected layer in the end we need to have a 1D array
        x = self.fully_connected(x)
        return F.softmax(x)  #  we apply a softmax here to return probabilities between 0 and 1

2. Add the model to the lib:

Change the file src/lib/model.py to add our model there. Just add the following lines:

@dataclass
class MySimpleModelLib:
    _target_: str = "src.models.my_simple_model.MySimpleModel"
    input_channels: int = 1
    num_classes: int = 10

A few pittfalls to avoid are:

  • Do not forget to decorate your class with @dataclass !
  • do not forget to specify the type !
  • Have a look at other lib files to see how to implement None as default and use the Any type.
  • do not forget any inputs to the actual model (like forget the parameter input_channels) because you will never be able to override the input channels from outside the source code.

3. Register the model in hydra:

For hydra to know about your model, you have to register it. We do this in the file src/lib/config.py. All we have to do here is adding 2 lines.

  1. We have to import the library model. So at the imports we add:
from src.lib.model import MySimpleModelLib
  1. Register the model by using the hydra ConfigStore. Best keep the code clean, so find the section where the models are defined and add:
cs.store(name="my_simple_model_base", node=MySimpleModelLib, group=model_group)

I like to append the _base her to later distinguish between the yaml-config and the structured-config. If you want to know more about this you will probably have to read the hydra documentation.

4. Add a yaml config file:

This step is not necessary. We could already use our model in hydra now, which would at this point go under the name my_simple_model_base. But for the sake of completion lets create a yaml config as well.

For this we will have to create this file: conf/model/my_simple_model.yaml

The content of this file should be

defaults:
  - my_simple_model_base  # this is the name of the registered model that we would like to extend
  - _self_  # adding this BELOW!! the registered name means, that everything in this yaml file will override the defaults

# you can only specify values here that are also in the registered model (src/lib/model/MySimpleModelLib)
num_classes: 10
input_channels: 1

If you want, you can of course drop the comments.

Why did we create this config file? Lets say you would like to also have t he same model, but with 3 input channels when you do predictions on colored images. All you would have to do is either change the value input_channels: 3 of the file conf/model/my_simple_model.yaml. But if you want to give it a distiguishable name (which makes sense for more complex usecases) then you can just create another file conf/model/my_simple_model_rgb.yaml for example, which has the content

defaults:
  - my_simple_model_base
  - _self_

num_classes: 10
input_channels: 3  # <- this is the only thing that changed

Now you could from a command line very easily switch between the 2 configs without remembering any specific numbers.

5. Add an experiment using that model:

There are 2 ways to use your model now in a training run.

  1. From the command line: All you have to do is keep everything with the defaults and just exchanging the model from the command line using hydras command line interface:
python main.py model=my_simple_model

or

python main.py model=my_simple_model_rgb

or if you did not create the yaml-file:

python main.py model=my_simple_model_base

From the command line we could also specify different inputs to our model:

python main.py model=my_simple_model_base model.input_channels=3
  1. We can create an experiment using this model. This definitely is preferable when the setups get more complex. For this, we have to create a new yaml file in the experiment folder. So lets create the file conf/experiment/my_simple_model_experiment.yaml with the following content:
# @package _global_

defaults:
  - override /lightning_module: default
  - override /datamodule: mnist
  - override /datamodule/dataset: mnist
  - override /loss: nll_loss
  - override /datamodule/train_transforms: no_transforms
  - override /datamodule/valid_transforms: no_transforms
  - override /model: my_simple_model  # <- this is the line where we add our own model to the experiment
  - override /optimizer: sgd
  - override /loss: nll_loss
  - override /strategy: null
  - override /logger/tensorboard: tensorboard
  - override /callbacks/checkpoint: model_checkpoint
  - override /callbacks/early_stopping: early_stopping
  - override /callbacks/lr_monitor: lr_monitor

  - override /hydra/launcher: local
  - _self_

output_dir_base_path: ./outputs
random_seed: 7
print_config: true
log_level: "info"

trainer:
  fast_dev_run: false
  num_sanity_val_steps: 3
  max_epochs: 3
  gpus: 0
  limit_train_batches: 3
  limit_val_batches: 3

datamodule:
  num_workers: 0
  batch_size: 4

Most settings here are the same as in the defaults, which are specified in conf/config.yaml but for this tutorial I think explicit is easier to understand the implicit.

To use the experiment we run our model with

python main.py +experiment=my_simple_model_experiment

Again we can also change all set values from the command line

python main.py +experiment=my_simple_model_experiment datamodule.num_workers=20

It should be easy now to follow the same steps to include your own datamodule, dataset, transforms, optimizers or whatever else you might need.

Owner
Model-driven Machine Learning
Model-driven Machine Learning
Zsseg.baseline - Zero-Shot Semantic Segmentation

This repo is for our paper A Simple Baseline for Zero-shot Semantic Segmentation

98 Dec 20, 2022
Tensorflow 2 implementations of the C-SimCLR and C-BYOL self-supervised visual representation methods from "Compressive Visual Representations" (NeurIPS 2021)

Compressive Visual Representations This repository contains the source code for our paper, Compressive Visual Representations. We developed informatio

Google Research 30 Nov 23, 2022
Advbox is a toolbox to generate adversarial examples that fool neural networks in PaddlePaddle、PyTorch、Caffe2、MxNet、Keras、TensorFlow and Advbox can benchmark the robustness of machine learning models.

Advbox is a toolbox to generate adversarial examples that fool neural networks in PaddlePaddle、PyTorch、Caffe2、MxNet、Keras、TensorFlow and Advbox can benchmark the robustness of machine learning models

AdvBox 1.3k Dec 25, 2022
Using Streamlit to host a multi-page tool with model specs and classification metrics, while also accepting user input values for prediction.

Predicitng_viability Using Streamlit to host a multi-page tool with model specs and classification metrics, while also accepting user input values for

Gopalika Sharma 1 Nov 08, 2021
CUda Matrix Multiply library.

cumm CUda Matrix Multiply library. cumm is developed during learning of CUTLASS, which use too much c++ template and make code unmaintainable. So I de

49 Dec 27, 2022
PyTorch implementation of popular datasets and models in remote sensing

PyTorch Remote Sensing (torchrs) (WIP) PyTorch implementation of popular datasets and models in remote sensing tasks (Change Detection, Image Super Re

isaac 222 Dec 28, 2022
A general framework for inferring CNNs efficiently. Reduce the inference latency of MobileNet-V3 by 1.3x on an iPhone XS Max without sacrificing accuracy.

GFNet-Pytorch (NeurIPS 2020) This repo contains the official code and pre-trained models for the glance and focus network (GFNet). Glance and Focus: a

Rainforest Wang 169 Oct 28, 2022
null

DeformingThings4D dataset Video | Paper DeformingThings4D is an synthetic dataset containing 1,972 animation sequences spanning 31 categories of human

208 Jan 03, 2023
Enhancing Column Generation by a Machine-Learning-BasedPricing Heuristic for Graph Coloring

Enhancing Column Generation by a Machine-Learning-BasedPricing Heuristic for Graph Coloring (to appear at AAAI 2022) We propose a machine-learning-bas

YunzhuangS 2 May 02, 2022
PlenOctrees: NeRF-SH Training & Conversion

PlenOctrees Official Repo: NeRF-SH training and conversion This repository contains code to train NeRF-SH and to extract the PlenOctree, constituting

Alex Yu 323 Dec 29, 2022
Code for "SRHEN: Stepwise-Refining Homography Estimation Network via Parsing Geometric Correspondences in Deep Latent Space"

SRHEN This is a better and simpler implementation for "SRHEN: Stepwise-Refining Homography Estimation Network via Parsing Geometric Correspondences in

1 Oct 28, 2022
Back to Basics: Efficient Network Compression via IMP

Back to Basics: Efficient Network Compression via IMP Authors: Max Zimmer, Christoph Spiegel, Sebastian Pokutta This repository contains the code to r

IOL Lab @ ZIB 1 Nov 19, 2021
Prototype for Baby Action Detection and Classification

Baby Action Detection Table of Contents About Install Run Predictions Demo About An attempt to harness the power of Deep Learning to come up with a so

Shreyas K 30 Dec 16, 2022
Multivariate Time Series Forecasting with efficient Transformers. Code for the paper "Long-Range Transformers for Dynamic Spatiotemporal Forecasting."

Spacetimeformer Multivariate Forecasting This repository contains the code for the paper, "Long-Range Transformers for Dynamic Spatiotemporal Forecast

QData 440 Jan 02, 2023
Face Mask Detection System built with OpenCV, TensorFlow using Computer Vision concepts

Face mask detection Face Mask Detection System built with OpenCV, TensorFlow using Computer Vision concepts in order to detect face masks in static im

Vaibhav Shukla 1 Oct 27, 2021
NeuPy is a Tensorflow based python library for prototyping and building neural networks

NeuPy v0.8.2 NeuPy is a python library for prototyping and building neural networks. NeuPy uses Tensorflow as a computational backend for deep learnin

Yurii Shevchuk 729 Jan 03, 2023
Face uncertainty quantification or estimation using PyTorch.

Face-uncertainty-pytorch This is a demo code of face uncertainty quantification or estimation using PyTorch. The uncertainty of face recognition is af

Kaen 3 Sep 16, 2022
Interactive Image Segmentation via Backpropagating Refinement Scheme

Won-Dong Jang and Chang-Su Kim, Interactive Image Segmentation via Backpropagating Refinement Scheme, CVPR 2019

Won-Dong Jang 85 Sep 15, 2022
MicroNet: Improving Image Recognition with Extremely Low FLOPs (ICCV 2021)

MicroNet: Improving Image Recognition with Extremely Low FLOPs (ICCV 2021) A pytorch implementation of MicroNet. If you use this code in your research

Yunsheng Li 293 Dec 28, 2022
You can draw the corresponding bounding box into the image and save it according to the result file (txt format) run by the tracker.

You can draw the corresponding bounding box into the image and save it according to the result file (txt format) run by the tracker.

Huiyiqianli 42 Dec 06, 2022