深度学习训练模型时保存Log输出信息为文件

使用logging包实现边在命令行输出结果，边保存结果为Log文件

首先自定义一个Logger类，调用Logging包实现功能，实例化一个对象logger，直接调用logger.info，例如

            logger.info("  ===cost time:{:.4f}s".format(end - start))

完整的示例如下，包含logging记录信息以及tensorboard的summary监督指标（https://www.cnblogs.com/ywheunji/p/10712620.html）。参照示例，直接添加logger.info信息即可录入文件。

class Logger(object):
    def __init__(self, log_file_name, log_level, logger_name):
        # firstly, create a logger
        self.__logger = logging.getLogger(logger_name)
        self.__logger.setLevel(log_level)
        # secondly, create a handler
        file_handler = logging.FileHandler(log_file_name)
        console_handler = logging.StreamHandler()
        # thirdly, define the output form of handler
        formatter = logging.Formatter(
            "[%(asctime)s]-[%(filename)s line:%(lineno)d]:%(message)s "
        )
        file_handler.setFormatter(formatter)
        console_handler.setFormatter(formatter)
        # finally, add the Hander to logger
        self.__logger.addHandler(file_handler)
        self.__logger.addHandler(console_handler)

    def get_log(self):
        return self.__logger
        
class Trainer(object):
    def __init__(self, weight_path, resume, gpu_id, accumulate, fp_16):
        init_seeds(0)
        self.train_dataloader = DataLoader(
            self.train_dataset,
            batch_size=cfg.TRAIN["BATCH_SIZE"],
            num_workers=cfg.TRAIN["NUMBER_WORKERS"],
            shuffle=True,
            pin_memory=True,
        )

        self.yolov4 = Build_Model(weight_path=weight_path, resume=resume).to(
            self.device
        )

    def train(self):
        global writer
        logger.info(
            "Training start,img size is: {:d},batchsize is: {:d},work number is {:d}".format(
                cfg.TRAIN["TRAIN_IMG_SIZE"],
                cfg.TRAIN["BATCH_SIZE"],
                cfg.TRAIN["NUMBER_WORKERS"],
            )
        )
        logger.info(self.yolov4)
        logger.info(
            "Train datasets number is : {}".format(len(self.train_dataset))
        )

        if self.fp_16:
            self.yolov4, self.optimizer = amp.initialize(
                self.yolov4, self.optimizer, opt_level="O1", verbosity=0
            )
        logger.info("        =======  start  training   ======     ")
        for epoch in range(self.start_epoch, self.epochs):
            start = time.time()
            self.yolov4.train()

            mloss = torch.zeros(4)
            logger.info("===Epoch:[{}/{}]===".format(epoch, self.epochs))
            for i, (imgs, label_sbbox,
            ) in enumerate(self.train_dataloader):

                loss, loss_ciou, loss_conf, loss_cls = self.criterion(p, p_d, label_sbbox)

                loss.backward()
                # Print batch results
                if i % 10 == 0:
                    logger.info(
                        "  === Epoch:[{:3}/{}],step:[{:3}/{}],img_size:[{:3}],total_loss:{:.4f}|loss_ciou:{:.4f}|loss_conf:{:.4f}|loss_cls:{:.4f}|lr:{:.4f}".format(
                            epoch,
                            self.epochs,
                            i,
                            len(self.train_dataloader) - 1,
                            self.train_dataset.img_size,
                            mloss[3],
                            mloss[0],
                            mloss[1],
                            mloss[2],
                            self.optimizer.param_groups[0]["lr"],
                        )
                    )
                    writer.add_scalar(
                        "loss_ciou",
                        mloss[0],
                        len(self.train_dataloader)
                        * epoch
                        + i,
                    )
                    writer.add_scalar(
                        "train_loss",
                        mloss[3],
                        len(self.train_dataloader)
                        * epoch
                        + i,
                    )


            # eval
            logger.info(
                "===== Validate =====".format(epoch, self.epochs)
            )
            logger.info("val img size is {}".format(cfg.VAL["TEST_IMG_SIZE"]))
            with torch.no_grad():
                APs, inference_time = Evaluator(
                    self.yolov4, showatt=False
                ).APs_voc()
                for i in APs:
                    logger.info("{} --> mAP : {}".format(i, APs[i]))
                    mAP += APs[i]
                mAP = mAP / self.train_dataset.num_classes
                logger.info("mAP : {}".format(mAP))
                logger.info(
                    "inference time: {:.2f} ms".format(inference_time)
                )
                writer.add_scalar("mAP", mAP, epoch)
                self.__save_model_weights(epoch, mAP)
                logger.info("save weights done")
            logger.info("  ===test mAP:{:.3f}".format(mAP))

if __name__ == "__main__":
    global logger, writer
    writer = SummaryWriter(logdir=opt.log_path + "/event")
    logger = Logger(
        log_file_name=opt.log_path + "/log.txt",
        log_level=logging.DEBUG,
        logger_name="YOLOv4",
    ).get_log()

    Trainer(
        weight_path=opt.weight_path,
        resume=opt.resume,
        gpu_id=opt.gpu_id,
        accumulate=opt.accumulate,
        fp_16=opt.fp_16,
    ).train()