kindle 0.3.0

PyTorch no-code model builder.

Kindle - PyTorch no-code model builder

Documentation

Kindle is an easy model build package for PyTorch. Building a deep learning model became so simple that almost all model can be made by copy and paste from other existing model codes. So why code? when we can simply build a model with yaml markup file.

Kindle builds a model with no code but yaml file which its method is inspired from YOLOv5.

Contents

• Installation
  • Install with pip
  • Install from source
  • For contributors
• AutoML with Kindle
• Usage
• Supported modules
• Custom module support
  • Custom module with yaml
  • Custom module from source

Installation

Install with pip

PyTorch is required prior to install. Please visit PyTorch installation guide to install.

You can install kindle by pip.

$ pip install kindle

Install from source

Please visit Install from source wiki page

For contributors

Please visit For contributors wiki page

Usage

Build a model

1. Make model yaml file

• Example model https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html

input_size: [32, 32]
input_channel: 3

depth_multiple: 1.0
width_multiple: 1.0

backbone:
    [
        [-1, 1, Conv, [6, 5, 1, 0], {activation: LeakyReLU}],
        [-1, 1, MaxPool, [2]],
        [-1, 1, nn.Conv2d, [16, 5, 1, 2], {bias: False}],
        [-1, 1, nn.BatchNorm2d, []],
        [-1, 1, nn.ReLU, []],
        [-1, 1, MaxPool, [2]],
        [-1, 1, Flatten, []],
        [-1, 1, Linear, [120, ReLU]],
        [-1, 1, Linear, [84, ReLU]],
    ]

head:
  [
      [-1, 1, Linear, [10]]
  ]

2. Build the model with kindle

from kindle import Model

model = Model("model.yaml"), verbose=True)

idx |       from |   n |   params |          module |                           arguments | in_channel | out_channel |        in shape |       out shape |
----------------------------------------------------------------------------------------------------------------------------------------------------------
  0 |         -1 |   1 |      616 |            Conv | [6, 5, 1, 0], activation: LeakyReLU |          3 |           8 |     [3, 32, 32] |     [8, 32, 32] |
  1 |         -1 |   1 |        0 |         MaxPool |                                 [2] |          8 |           8 |       [8 32 32] |     [8, 16, 16] |
  2 |         -1 |   1 |    3,200 |       nn.Conv2d |          [16, 5, 1, 2], bias: False |          8 |          16 |       [8 16 16] |    [16, 16, 16] |
  3 |         -1 |   1 |       32 |  nn.BatchNorm2d |                                  [] |         16 |          16 |      [16 16 16] |    [16, 16, 16] |
  4 |         -1 |   1 |        0 |         nn.ReLU |                                  [] |         16 |          16 |      [16 16 16] |    [16, 16, 16] |
  5 |         -1 |   1 |        0 |         MaxPool |                                 [2] |         16 |          16 |      [16 16 16] |      [16, 8, 8] |
  6 |         -1 |   1 |        0 |         Flatten |                                  [] |         -1 |        1024 |        [16 8 8] |          [1024] |
  7 |         -1 |   1 |  123,000 |          Linear |                       [120, 'ReLU'] |       1024 |         120 |          [1024] |           [120] |
  8 |         -1 |   1 |   10,164 |          Linear |                        [84, 'ReLU'] |        120 |          84 |           [120] |            [84] |
  9 |         -1 |   1 |      850 |          Linear |                                [10] |         84 |          10 |            [84] |            [10] |
Model Summary: 20 layers, 137,862 parameters, 137,862 gradients

AutoML with Kindle

• Kindle offers the easiest way to build your own deep learning architecture. Beyond building a model, AutoML became easier with Kindle and Optuna or other optimization frameworks.
• For further information, please refer to https://limjk.ai/kindle/usages/#automl-with-optuna

Supported modules

• Detailed documents can be found https://limjk.ai/kindle/modules/

Module	Components	Arguments
Conv	Conv -> BatchNorm -> Activation	[out_channels, kernel_size, stride, padding, groups, activation]
DWConv	DWConv -> BatchNorm -> Activation	[out_channels, kernel_size, stride, padding, activation]
Bottleneck	Expansion ConvBNAct -> ConvBNAct	[out_channels, shortcut, groups, expansion, activation]
AvgPool	Average pooling	[kernel_size, stride, padding]
MaxPool	Max pooling	[kernel_size, stride, padding]
GlobalAvgPool	Global Average Pooling	[]
Flatten	Flatten	[]
Concat	Concatenation	[dimension]
Linear	Linear	[out_channels, activation]
Add	Add	[]
UpSample	UpSample	[]
Identity	Identity	[]
YamlModule	Custom module from yaml file	['yaml/file/path', arg0, arg1, ...]
nn.{module_name}	PyTorch torch.nn.* module	Please refer to https://pytorch.org/docs/stable/nn.html
Pretrained	timm.create_model	[model_name, features_only, pretrained]
PreTrainedFeatureMap	Bypass feature layer map from Pretrained	[feature_idx]

• nn.{module_name} is currently experimental. This might change in the future release. Use with caution.
• For the supported model of Pretrained module, please refer to https://rwightman.github.io/pytorch-image-models/results

Custom module support

Custom module with yaml

• You can make your own custom module with yaml file. Please refer to https://limjk.ai/kindle/tutorial/#2-design-custom-module-with-yaml for further detail.

Custom module from source code

• You can also make your own custom module from the source code. Please refer to https://limjk.ai/kindle/tutorial/#3-design-custom-module-from-source for further detail.

Pretrained model support

• Pre-trained model from timm can be loaded in kindle yaml config file. Please refer to https://limjk.ai/kindle/tutorial/#4-utilize-pretrained-model for further detail.

Planned features

• Custom module support
• Custom module with yaml support
• Use pre-trained model
• Graphical model file generator
• More modules!