Deep Learning Project Template

Modelo de projeto Pytorch

Uma estrutura simples e bem projetada é essencial para qualquer projeto de aprendizado profundo; portanto, depois de muita prática e contribuindo em projetos de Pytorch, aqui está um modelo de projeto Pytorch que combina simplicidade, melhor prática para a estrutura de pastas e um bom design de OOP . A idéia principal é que há muitas coisas que você faz todas as vezes quando inicia seu projeto Pytorch, então envolver todas essas coisas compartilhadas ajudarão você a alterar apenas a ideia principal toda vez que você inicia um novo projeto Pytorch.

Então, aqui está um modelo Pytorch simples que ajuda você a entrar no seu projeto principal mais rápido e apenas se concentrar no seu núcleo (arquitetura de modelo, fluxo de treinamento, etc.)

Para diminuir as coisas repetidas, recomendamos usar uma biblioteca de alto nível. Você pode escrever sua própria biblioteca de alto nível ou apenas usar bibliotecas de terceiros, como Ignite, Fastai, MMCV ... etc. Isso pode ajudá-lo a escrever loops de treinamento compactos, mas com recursos completos, em algumas linhas de código. Aqui usamos o Ignite para treinar o mnist como exemplo.

Requisitos

• YACS (mais um sistema de configuração)
• Pytorch (uma plataforma de aprendizado profundo de código aberto)
• Ignite (biblioteca de alto nível para ajudar no treinamento de redes neurais em Pytorch)

Índice

• Em poucas palavras
• Em detalhes
• Trabalho futuro
• Contribuindo
• Agradecimentos

Em poucas palavras

Em poucas palavras, aqui está como usar esse modelo, por exemplo, suponha que você queira implementar o RESNET-18 para treinar o MNIST, para que você faça o seguinte:

• Na pasta modeling crie um arquivo python chamado o que você quiser, aqui chamamos o example_model.py . No arquivo modeling/__init__.py , você pode criar uma função chamada build_model para chamar seu modelo

 from . example_model import ResNet18

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

• Na pasta engine , crie uma função e função de inferência de um modelo. Na função do treinador, você precisa escrever a lógica do processo de treinamento, você pode usar uma biblioteca de terceiros para diminuir as coisas repetidas.

 # 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

• Na pasta tools , você cria o train.py Neste arquivo, você precisa obter as instâncias dos seguintes objetos "Modelo", "Dataloader", "Optimizer" e 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 )

• Passe todos esses objetos para a função do_train e inicie seu treinamento

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

Você encontrará um arquivo de modelo e um exemplo simples na pasta modelo e treinador que mostra como experimentar o seu primeiro modelo de maneira simples.

Em detalhes

 ├──  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

Trabalho futuro

Contribuindo

Qualquer tipo de aprimoramento ou contribuição é bem -vindo.

Agradecimentos