When the program was killed, there was no other information:
The error info is like below:

截屏2021-09-10 下午7.33.261920×909 219 KB

There is no out of memory. I really don’t know how to fix these. Please give me some help.
This is the code of each epoch.
def train_one_epoch_dg(model, optimizer, data_loaders, device, epoch, batch_size,
                       print_freq=50, warmup=False):
    length_list = [len(data_loader) for data_loader in data_loaders]
    max_length = max(length_list)
    cycle_data_loaders = list()

    for data_loader in data_loaders:
        if len(data_loader) < max_length:
            cycle_data_loaders.append(cycle(data_loader))
        else:
            cycle_data_loaders.append(data_loader)

    model.train()
    # metric_logger = utils.MetricLogger(delimiter="  ")
    # metric_logger.add_meter('lr', utils.SmoothedValue(window_size=1, fmt='{value:.6f}'))

    lr_scheduler = None
    if epoch == 0 and warmup is True:  # 当训练第一轮（epoch=0）时，启用warmup训练方式，可理解为热身训练
        warmup_factor = 1.0 / 1000
        warmup_iters = min(1000, max_length - 1)

        lr_scheduler = utils.warmup_lr_scheduler(optimizer, warmup_iters, warmup_factor)

    mloss = torch.zeros(1).to(device)  # mean losses
    enable_amp = True if "cuda" in device.type else False

    for i in tqdm(range(0, max_length)):
        images_list = list()
        targets_list = list()

        for j in range(len(data_loaders)):
            [images, targets] = next(iter(cycle_data_loaders[j]))
            images = list(image.to(device) for image in images)
            targets = [{k: v.to(device) for k, v in t.items()} for t in targets]

            images_list.extend(images)
            targets_list.extend(targets)

        with torch.cuda.amp.autocast(enabled=enable_amp):

            loss_dict = model(images_list, targets_list)

            losses = sum(loss for loss in loss_dict.values())

            # reduce losses over all GPUs for logging purpose
            loss_dict_reduced = utils.reduce_dict(loss_dict)
            losses_reduced = sum(loss for loss in loss_dict_reduced.values())

            loss_value = losses_reduced.item()
            # 记录训练损失
            mloss = (mloss * i + loss_value) / (i + 1)  # update mean losses

            if not math.isfinite(loss_value):  # 当计算的损失为无穷大时停止训练
                print("Loss is {}, stopping training".format(loss_value))
                print(loss_dict_reduced)
                sys.exit(1)

        optimizer.zero_grad()
        losses.backward()
        optimizer.step()

        if lr_scheduler is not None:  # 第一轮使用warmup训练方式
            lr_scheduler.step()

        now_lr = optimizer.param_groups[0]["lr"]

    return mloss, now_lr