Pytorch基礎訓練庫Pytorch-Base-Trainer(支持模型剪枝 分布式訓練)

目錄

Pytorch基礎訓練庫Pytorch-Base-Trainer(PBT)(支持分布式訓練)

1.Introduction

2.Install

3.訓練框架

(1)訓練引擎(Engine)

(2)回呼函式(Callback)

4.使用方法

5.Example: 構建自己的分類Pipeline

6.可視化

7.其他

1.Introduction

開源不易,麻煩給個【Star】

尊重原創，轉載請注明出處：https://panjinquan.blog.csdn.net/article/details/122662902

GitHub - PanJinquan/Pytorch-Base-Trainer: Pytorch分布式訓練框架Pytorch分布式訓練框架. Contribute to PanJinquan/Pytorch-Base-Trainer development by creating an account on GitHub.https://github.com/PanJinquan/Pytorch-Base-Trainer考慮到深度學習訓練程序都有一套約定成俗的流程，鄙人借鑒Keras開發了一套基礎訓練庫： Pytorch-Base-Trainer(PBT)； 這是一個基于Pytorch開發的基礎訓練庫，支持以下特征：

• 支持多卡訓練訓練(DP模式)和分布式多卡訓練(DDP模式)，參考build_model_parallel
• 支持argparse命令列指定引數，也支持config.yaml組態檔
• 支持最優模型保存ModelCheckpoint
• 支持自定義回呼函式Callback
• 支持NNI模型剪枝(L1/L2-Pruner,FPGM-Pruner Slim-Pruner)nni_pruning
• 非常輕便,安裝簡單

誠然，諸多大公司已經開源基礎庫，如MMClassification,MMDetection等庫； 但礙于這些開源庫安裝麻煩,依賴庫多,版本差異大等問題；鄙人還是開發了一套屬于自己的， 比較lowbi的基礎訓練庫Pytorch-Base-Trainer(PBT), 基于PBT可以快速搭建自己的訓練工程； 目前，基于PBT完成了通用分類別庫(PBTClassification),通用檢測庫(PBTDetection),通用語意分割庫( PBTSegmentation)以及,通用姿態檢測庫(PBTPose)

基于PBT框架訓練的模型,已經形成了一套完整的Android端上部署流程,支持CPU和GPU

人體姿態估計2DPose	人臉+人體檢測	人像摳圖
CPU/GPU:70/50ms	CPU/GPU:30/20ms	CPU/GPU:150/30ms

PS：受商業保護,目前,僅開源Pytorch-Base-Trainer(PBT),基于PBT的分類,檢測和分割以及姿態估計訓練庫,暫不開源，

2.Install

• 原始碼安裝

git clone https://github.com/PanJinquan/Pytorch-Base-Trainer
cd Pytorch-Base-Trainer
bash setup.sh #pip install dist/basetrainer-*.*.*.tar.gz

• pip安裝

pip install basetrainer

• 使用NNI 模型剪枝工具，需要安裝NNI

# Linux or macOS
python3 -m pip install --upgrade nni
# Windows
python -m pip install --upgrade nni

3.訓練框架

PBT基礎訓練庫定義了一個基類(Base),所有訓練引擎(Engine)以及回呼函式(Callback)都會繼承基類，

(1)訓練引擎(Engine)

Engine類實作了訓練/測驗的迭代方法(如on_batch_begin,on_batch_end),其迭代程序參考如下,用戶可以根據自己的需要自定義迭代程序：

self.on_train_begin()
for epoch in range(num_epochs):
    self.set_model()  # 設定模型
    # 開始訓練
    self.on_epoch_begin()  # 開始每個epoch呼叫
    for inputs in self.train_dataset:
        self.on_batch_begin()  # 每次迭代開始時回呼
        self.run_step()  # 每次迭代回傳outputs, losses
        self.on_train_summary()  # 每次迭代，訓練結束時回呼
        self.on_batch_end()  # 每次迭代結束時回呼
    # 開始測驗
    self.on_test_begin()
    for inputs in self.test_dataset:
        self.run_step()  # 每次迭代回傳outputs, losses
        self.on_test_summary()  # 每次迭代，測驗結束時回呼
    self.on_test_end()  # 結束測驗
    # 結束當前epoch
    self.on_epoch_end()
self.on_train_end()

EngineTrainer類繼承Engine類,用戶需要繼承該類,并實作相關介面:

另外，EngineTrainer類還是實作了兩個重要的類方法(build_dataloader和build_model_parallel),用于構建分布式訓練

(2)回呼函式(Callback)

每個回呼函式都需要繼承(Callback),用戶在回呼函式中,可實作對迭代方法輸入/輸出的處理,例如:

4.使用方法

basetrainer使用方法可以參考example.py,構建自己的訓練器,可通過如下步驟實作：

• step1: 新建一個類ClassificationTrainer，繼承trainer.EngineTrainer
• step2: 實作介面

def build_train_loader(self, cfg, **kwargs):
    """定義訓練資料"""
    raise NotImplementedError("build_train_loader not implemented!")


def build_test_loader(self, cfg, **kwargs):
    """定義測驗資料"""
    raise NotImplementedError("build_test_loader not implemented!")


def build_model(self, cfg, **kwargs):
    """定于訓練模型"""
    raise NotImplementedError("build_model not implemented!")


def build_optimizer(self, cfg, **kwargs):
    """定義優化器"""
    raise NotImplementedError("build_optimizer not implemented!")


def build_criterion(self, cfg, **kwargs):
    """定義損失函式"""
    raise NotImplementedError("build_criterion not implemented!")


def build_callbacks(self, cfg, **kwargs):
    """定義回呼函式"""
    raise NotImplementedError("build_callbacks not implemented!")
step3: 在初始化中呼叫build
def __init__(self, cfg):
    super(ClassificationTrainer, self).__init__(cfg)
    ...
    self.build(cfg)
    ...
step4: 實體化ClassificationTrainer,并使用launch啟動分布式訓練
def main(cfg):
    t = ClassificationTrainer(cfg)
    return t.run()


if __name__ == "__main__":
    parser = get_parser()
    args = parser.parse_args()
    cfg = setup_config.parser_config(args)
    launch(main,
           num_gpus_per_machine=len(cfg.gpu_id),
           dist_url="tcp://127.0.0.1:28661",
           num_machines=1,
           machine_rank=0,
           distributed=cfg.distributed,
           args=(cfg,))

5.Example: 構建自己的分類Pipeline

• basetrainer使用方法可以參考example.py

python example.py

• 目標支持的backbone有：resnet[18,34,50,101], ,mobilenet_v2等，詳見backbone等 ，其他backbone可以自定義添加
• 訓練引數可以通過兩種方法指定: (1) 通過argparse命令列指定 (2)通過config.yaml組態檔，當存在同名引數時，以組態檔為默認值

一個簡單分類例子如下：

# -*-coding: utf-8 -*-
"""
    @Author : panjq
    @E-mail : pan_jinquan@163.com
    @Date   : 2021-07-28 22:09:32
"""
import os
import sys

sys.path.append(os.getcwd())
import argparse
import basetrainer
from torchvision import transforms
from torchvision.datasets import ImageFolder
from basetrainer.engine import trainer
from basetrainer.engine.launch import launch
from basetrainer.criterion.criterion import get_criterion
from basetrainer.metric import accuracy_recorder
from basetrainer.callbacks import log_history, model_checkpoint, losses_recorder, multi_losses_recorder
from basetrainer.scheduler import build_scheduler
from basetrainer.optimizer.build_optimizer import get_optimizer
from basetrainer.utils import log, file_utils, setup_config, torch_tools
from basetrainer.models import build_models

print(basetrainer.__version__)


class ClassificationTrainer(trainer.EngineTrainer):
    """ Training Pipeline """

    def __init__(self, cfg):
        super(ClassificationTrainer, self).__init__(cfg)
        torch_tools.set_env_random_seed()
        cfg.model_root = os.path.join(cfg.work_dir, "model")
        cfg.log_root = os.path.join(cfg.work_dir, "log")
        if self.is_main_process:
            file_utils.create_dir(cfg.work_dir)
            file_utils.create_dir(cfg.model_root)
            file_utils.create_dir(cfg.log_root)
            file_utils.copy_file_to_dir(cfg.config_file, cfg.work_dir)
            setup_config.save_config(cfg, os.path.join(cfg.work_dir, "setup_config.yaml"))
        self.logger = log.set_logger(level="debug",
                                     logfile=os.path.join(cfg.log_root, "train.log"),
                                     is_main_process=self.is_main_process)
        # build project
        self.build(cfg)
        self.logger.info("=" * 60)
        self.logger.info("work_dir          :{}".format(cfg.work_dir))
        self.logger.info("config_file       :{}".format(cfg.config_file))
        self.logger.info("gpu_id            :{}".format(cfg.gpu_id))
        self.logger.info("main device       :{}".format(self.device))
        self.logger.info("num_samples(train):{}".format(self.num_samples))
        self.logger.info("num_classes       :{}".format(cfg.num_classes))
        self.logger.info("mean_num          :{}".format(self.num_samples / cfg.num_classes))
        self.logger.info("=" * 60)

    def build_optimizer(self, cfg, **kwargs):
        """build_optimizer"""
        self.logger.info("build_optimizer")
        self.logger.info("optim_type:{},init_lr:{},weight_decay:{}".format(cfg.optim_type, cfg.lr, cfg.weight_decay))
        optimizer = get_optimizer(self.model,
                                  optim_type=cfg.optim_type,
                                  lr=cfg.lr,
                                  momentum=cfg.momentum,
                                  weight_decay=cfg.weight_decay)
        return optimizer

    def build_criterion(self, cfg, **kwargs):
        """build_criterion"""
        self.logger.info("build_criterion,loss_type:{},num_classes:{}".format(cfg.loss_type, cfg.num_classes))
        criterion = get_criterion(cfg.loss_type, cfg.num_classes, device=self.device)
        return criterion

    def build_train_loader(self, cfg, **kwargs):
        """build_train_loader"""
        self.logger.info("build_train_loader,input_size:{}".format(cfg.input_size))
        transform = transforms.Compose([
            transforms.Resize([int(128 * cfg.input_size[1] / 112), int(128 * cfg.input_size[0] / 112)]),
            transforms.RandomHorizontalFlip(),
            transforms.RandomCrop([cfg.input_size[1], cfg.input_size[0]]),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
        ])
        dataset = ImageFolder(root=cfg.train_data, transform=transform)
        cfg.num_classes = len(dataset.classes)
        cfg.classes = dataset.classes
        loader = self.build_dataloader(dataset, cfg.batch_size, cfg.num_workers, phase="train",
                                       shuffle=True, pin_memory=False, drop_last=True, distributed=cfg.distributed)
        return loader

    def build_test_loader(self, cfg, **kwargs):
        """build_test_loader"""
        self.logger.info("build_test_loader,input_size:{}".format(cfg.input_size))
        transform = transforms.Compose([
            transforms.Resize([int(128 * cfg.input_size[1] / 112), int(128 * cfg.input_size[0] / 112)]),
            transforms.CenterCrop([cfg.input_size[1], cfg.input_size[0]]),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
        ])
        dataset = ImageFolder(root=cfg.train_data, transform=transform)
        loader = self.build_dataloader(dataset, cfg.batch_size, cfg.num_workers, phase="test",
                                       shuffle=False, pin_memory=False, drop_last=False, distributed=False)
        return loader

    def build_model(self, cfg, **kwargs):
        """build_model"""
        self.logger.info("build_model,net_type:{}".format(cfg.net_type))
        model = build_models.get_models(net_type=cfg.net_type, input_size=cfg.input_size,
                                        num_classes=cfg.num_classes, pretrained=True)
        if cfg.finetune:
            self.logger.info("finetune:{}".format(cfg.finetune))
            state_dict = torch_tools.load_state_dict(cfg.finetune)
            model.load_state_dict(state_dict)
        if cfg.use_prune:
            from basetrainer.pruning import nni_pruning
            sparsity = 0.2
            self.logger.info("use_prune:{},sparsity:{}".format(cfg.use_prune, sparsity))
            model = nni_pruning.model_pruning(model,
                                              input_size=[1, 3, cfg.input_size[1], cfg.input_size[0]],
                                              sparsity=sparsity,
                                              reuse=False,
                                              output_prune=os.path.join(cfg.work_dir, "prune"))
        model = self.build_model_parallel(model, cfg.gpu_id, distributed=cfg.distributed)
        return model

    def build_callbacks(self, cfg, **kwargs):
        """定義回呼函式"""
        self.logger.info("build_callbacks")
        # 準確率記錄回呼函式
        acc_record = accuracy_recorder.AccuracyRecorder(target_names=cfg.classes,
                                                        indicator="Accuracy")
        # loss記錄回呼函式
        loss_record = losses_recorder.LossesRecorder(indicator="loss")
        # Tensorboard Log等歷史記錄回呼函式
        history = log_history.LogHistory(log_dir=cfg.log_root,
                                         log_freq=cfg.log_freq,
                                         logger=self.logger,
                                         indicators=["loss", "Accuracy"],
                                         is_main_process=self.is_main_process)
        # 模型保存回呼函式
        checkpointer = model_checkpoint.ModelCheckpoint(model=self.model,
                                                        optimizer=self.optimizer,
                                                        moder_dir=cfg.model_root,
                                                        epochs=cfg.num_epochs,
                                                        start_save=-1,
                                                        indicator="Accuracy",
                                                        logger=self.logger)
        # 學習率調整策略回呼函式
        lr_scheduler = build_scheduler.get_scheduler(cfg.scheduler,
                                                     optimizer=self.optimizer,
                                                     lr_init=cfg.lr,
                                                     num_epochs=cfg.num_epochs,
                                                     num_steps=self.num_steps,
                                                     milestones=cfg.milestones,
                                                     num_warn_up=cfg.num_warn_up)
        callbacks = [acc_record,
                     loss_record,
                     lr_scheduler,
                     history,
                     checkpointer]
        return callbacks

    def run(self, logs: dict = {}):
        self.logger.info("start train")
        super().run(logs)


def main(cfg):
    t = ClassificationTrainer(cfg)
    return t.run()


def get_parser():
    parser = argparse.ArgumentParser(description="Training Pipeline")
    parser.add_argument("-c", "--config_file", help="configs file", default="configs/config.yaml", type=str)
    # parser.add_argument("-c", "--config_file", help="configs file", default=None, type=str)
    parser.add_argument("--train_data", help="train data", default="./data/dataset/train", type=str)
    parser.add_argument("--test_data", help="test data", default="./data/dataset/val", type=str)
    parser.add_argument("--work_dir", help="work_dir", default="output", type=str)
    parser.add_argument("--input_size", help="input size", nargs="+", default=[224, 224], type=int)
    parser.add_argument("--batch_size", help="batch_size", default=32, type=int)
    parser.add_argument("--gpu_id", help="specify your GPU ids", nargs="+", default=[0], type=int)
    parser.add_argument("--num_workers", help="num_workers", default=0, type=int)
    parser.add_argument("--num_epochs", help="total epoch number", default=50, type=int)
    parser.add_argument("--scheduler", help=" learning scheduler: multi-step,cosine", default="multi-step", type=str)
    parser.add_argument("--milestones", help="epoch stages to decay learning rate", nargs="+",
                        default=[10, 20, 40], type=int)
    parser.add_argument("--num_warn_up", help="num_warn_up", default=3, type=int)
    parser.add_argument("--net_type", help="net_type", default="mobilenet_v2", type=str)
    parser.add_argument("--finetune", help="finetune model file", default=None, type=str)
    parser.add_argument("--loss_type", help="loss_type", default="CELoss", type=str)
    parser.add_argument("--optim_type", help="optim_type", default="SGD", type=str)
    parser.add_argument("--lr", help="learning rate", default=0.1, type=float)
    parser.add_argument("--weight_decay", help="weight_decay", default=0.0005, type=float)
    parser.add_argument("--momentum", help="momentum", default=0.9, type=float)
    parser.add_argument("--log_freq", help="log_freq", default=10, type=int)
    parser.add_argument('--use_prune', action='store_true', help='use prune', default=False)
    parser.add_argument('--progress', action='store_true', help='display progress bar', default=True)
    parser.add_argument('--distributed', action='store_true', help='use distributed training', default=False)
    parser.add_argument('--polyaxon', action='store_true', help='polyaxon', default=False)
    return parser


if __name__ == "__main__":
    parser = get_parser()
    cfg = setup_config.parser_config(parser.parse_args(), cfg_updata=True)
    launch(main,
           num_gpus_per_machine=len(cfg.gpu_id),
           dist_url="tcp://127.0.0.1:28661",
           num_machines=1,
           machine_rank=0,
           distributed=cfg.distributed,
           args=(cfg,))

6.可視化

目前訓練程序可視化工具是使用Tensorboard，使用方法：

tensorboard --logdir=path/to/log/

7.其他