Deep Learning Project Template

Modèle de projet Pytorch

Une structure simple et bien conçue est essentielle pour tout projet d'apprentissage en profondeur, donc après beaucoup de pratique et de contribution dans les projets Pytorch, voici un modèle de projet Pytorch qui combine la simplicité, les meilleures pratiques pour la structure du dossier et la bonne conception OOP . L'idée principale est qu'il y a beaucoup de choses que vous faites à chaque fois que vous commencez votre projet Pytorch, donc envelopper toutes ces choses partagées vous aidera à changer juste l'idée principale à chaque fois que vous démarrez un nouveau projet Pytorch.

Donc, voici un simple modèle de pytorch qui vous aide à accéder plus rapidement à votre projet principal et à vous concentrer sur votre cœur (architecture du modèle, flux de formation, etc.)

Afin de diminuer les choses répétées, nous vous recommandons d'utiliser une bibliothèque de haut niveau. Vous pouvez écrire votre propre bibliothèque de haut niveau ou vous pouvez simplement utiliser certaines bibliothèques en tiers telles que Ignite, Fastai, MMCV… etc. Cela peut vous aider à écrire des boucles de formation compactes mais complètes en quelques lignes de code. Ici, nous utilisons Ignite pour former MNIST comme exemple.

Exigences

• YACS (encore un autre système de configuration)
• Pytorch (une plate-forme d'apprentissage en profondeur open source)
• Ignite (bibliothèque de haut niveau pour aider à la formation des réseaux de neurones à Pytorch)

Table des matières

• En un mot
• En détail
• Travail futur
• Contributif
• Remerciements

En un mot

En un mot, voici comment utiliser ce modèle, donc par exemple, supposons que vous souhaitez implémenter Resnet-18 pour former MNIST, vous devez donc faire ce qui suit:

• Dans le dossier modeling créez un fichier python nommé ce que vous voulez, nous l'avons nommé example_model.py . Dans le fichier modeling/__init__.py , vous pouvez créer une fonction nommée build_model pour appeler votre modèle

 from . example_model import ResNet18

def build_model ( cfg ):
    model = ResNet18 ( cfg . MODEL . NUM_CLASSES )
    return model

• Dans le dossier engine , créer une fonction d'entraîneur de modèle et une fonction d'inférence. Dans la fonction du formateur, vous devez écrire la logique du processus de formation, vous pouvez utiliser une bibliothèque tierce pour diminuer les choses répétées.

 # trainer
def do_train ( cfg , model , train_loader , val_loader , optimizer , scheduler , loss_fn ):
 """
 implement the logic of epoch:
 -loop on the number of iterations in the config and call the train step
 -add any summaries you want using the summary
 """
pass

# inference
def inference ( cfg , model , val_loader ):
"""
implement the logic of the train step
- run the tensorflow session
- return any metrics you need to summarize
 """
pass

• Dans le dossier tools , vous créez le train.py . Dans ce fichier, vous devez obtenir les instances des objets suivants "modèle", "DatalOader", "Optimizer" et config

 # create instance of the model you want
model = build_model ( cfg )

# create your data generator
train_loader = make_data_loader ( cfg , is_train = True )
val_loader = make_data_loader ( cfg , is_train = False )

# create your model optimizer
optimizer = make_optimizer ( cfg , model )

• Passez tous ces objets à la fonction do_train et commencez votre formation

 # here you train your model
do_train ( cfg , model , train_loader , val_loader , optimizer , None , F . cross_entropy )

Vous trouverez un fichier de modèle et un exemple simple dans le dossier du modèle et du formateur qui vous montre comment essayer votre premier modèle simplement.

En détail

 ├──  config
│    └── defaults.py  - here's the default config file.
│
│
├──  configs  
│    └── train_mnist_softmax.yml  - here's the specific config file for specific model or dataset.
│ 
│
├──  data  
│    └── datasets  - here's the datasets folder that is responsible for all data handling.
│    └── transforms  - here's the data preprocess folder that is responsible for all data augmentation.
│    └── build.py  		   - here's the file to make dataloader.
│    └── collate_batch.py   - here's the file that is responsible for merges a list of samples to form a mini-batch.
│
│
├──  engine
│   ├── trainer.py     - this file contains the train loops.
│   └── inference.py   - this file contains the inference process.
│
│
├── layers              - this folder contains any customed layers of your project.
│   └── conv_layer.py
│
│
├── modeling            - this folder contains any model of your project.
│   └── example_model.py
│
│
├── solver             - this folder contains optimizer of your project.
│   └── build.py
│   └── lr_scheduler.py
│   
│ 
├──  tools                - here's the train/test model of your project.
│    └── train_net.py  - here's an example of train model that is responsible for the whole pipeline.
│ 
│ 
└── utils
│    ├── logger.py
│    └── any_other_utils_you_need
│ 
│ 
└── tests					- this foler contains unit test of your project.
     ├── test_data_sampler.py

Travail futur

Contributif

Tout type d'amélioration ou de contribution est accueilli.

Remerciements