Deep Learning Project Template

Plantilla de proyecto Pytorch

Una estructura simple y bien diseñada es esencial para cualquier proyecto de aprendizaje profundo, por lo que después de una gran práctica y contribuir en proyectos de Pytorch, aquí hay una plantilla de proyecto Pytorch que combina simplicidad, mejor práctica para la estructura de carpetas y un buen diseño de OOP . La idea principal es que hay muchas cosas que haces cada vez que comienzas tu proyecto Pytorch, por lo que envolver todas estas cosas compartidas te ayudará a cambiar la idea central cada vez que comiences un nuevo proyecto de Pytorch.

Entonces, aquí hay una plantilla simple de Pytorch que lo ayuda a ingresar a su proyecto principal más rápido y solo concéntrese en su núcleo (arquitectura de modelos, flujo de entrenamiento, etc.)

Para disminuir las cosas repetidas, recomendamos usar una biblioteca de alto nivel. Puede escribir su propia biblioteca de alto nivel o puede usar algunas bibliotecas de terceros como Ignite, Fastai, MMCV ... etc. Esto puede ayudarlo a escribir bucles de entrenamiento compactos pero con todas las funciones en algunas líneas de código. Aquí usamos Ignite para entrenar a Mnist como ejemplo.

Requisitos

• YACS (otro sistema de configuración)
• Pytorch (una plataforma de aprendizaje profundo de código abierto)
• Ignite (Biblioteca de alto nivel para ayudar con la capacitación de redes neuronales en Pytorch)

Tabla de contenido

• En una palabra
• En detalle
• Trabajo futuro
• Que contribuye
• Expresiones de gratitud

En una palabra

En pocas palabras, aquí es cómo usar esta plantilla, así que , por ejemplo, suponga que desea implementar resnet-18 para entrenar a Mnist, por lo que debe hacer lo siguiente:

• En la carpeta modeling cree un archivo de Python llamado lo que quiera, aquí lo llamamos example_model.py . En el archivo de modeling/__init__.py , puede crear una función llamada build_model para llamar a su modelo

 from . example_model import ResNet18

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

• En la carpeta engine , cree una función de entrenador de modelo y una función de inferencia. En la función del entrenador, debe escribir la lógica del proceso de capacitación, puede usar una biblioteca de terceros para disminuir las cosas 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

• En la carpeta tools , crea train.py . En este archivo, debe obtener las instancias del "modelo" de los siguientes objetos "," DataLoader "," Optimizer "y 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 )

• Pase todos estos objetos a la función do_train e inicie su entrenamiento

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

Encontrará un archivo de plantilla y un ejemplo simple en la carpeta modelo y entrenador que le muestra cómo probar su primer modelo simplemente.

En detalle

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

Trabajo futuro

Que contribuye

Cualquier tipo de mejora o contribución es bienvenida.

Expresiones de gratitud