1）PaddlePaddle版本：2.2
2）CPU：Intel(R) Core(TM) i9-10900K
3）GPU：两个 RTX3090 ，CUDA版本：11.65
4）系统环境：Ubuntu， python3.6

• 问题描述：最近在学习paddle，测试运行了paddle社区的一个TSN视频分类模型，进行并行训练，在对数据集进行处理时，使用了如下代码：

import paddle.distributed as dist
    dist.init_parallel_env()
    model = paddle.DataParallel(model)

    train_sampler = paddle.io.DistributedBatchSampler(
        train_dataset,
        batch_size=batch_size,
        shuffle=True,
        drop_last=drop_last
    )
    
    # 单gpu下：len(train_sampler) = 100  （python train.py）
    # 双gpu下：len(train_sampler) = 50   (python -m paddle.distributed.launch --selected_gpus='0,1' train.py)
    
    train_loader = paddle.io.DataLoader(
        train_dataset,
        # batch_size=batch_size,
        # shuffle=True,
        batch_sampler=train_sampler,
        places=paddle.set_device('gpu'),
        num_workers=num_workers,
        return_list=return_list
    )

发现使用python train.py运行代码时，len(train_sampler) = 100；而使用python -m paddle.distributed.launch --selected_gpus='0,1' train.py运行代码时，len(train_sampler) = 50。两个长度大小为什么会不一样呢？

接着，设置batch_size=4，使用循环进行训练：

model.train()  # 将模型设置为训练模式
    lr = paddle.optimizer.lr.PiecewiseDecay(
        boundaries=boundaries, values=values)
    optimizer = paddle.optimizer.Adam(
        learning_rate=lr,
        # momentum=momentum,
        parameters=model.parameters(),
        weight_decay=paddle.regularizer.L2Decay(weight_decay)
    )
    for epoch in range(0, epochs):
        record_list = build_record(framework)
        tic = time.time()
        for i, data in enumerate(train_loader):
            record_list['reader_time'].update(time.time() - tic)
            imgs = data[0]
            labels = data[1]
    
            print(labels)
            # [[0],
            #  [1],
            #  [1],
            #  [0]]
    
            cls_score = model(imgs) 
            outputs = head.loss(cls_score, labels, False) 
            avg_loss = outputs['loss']
            avg_loss.backward()
            optimizer.step()
            optimizer.clear_grad()
            record_list['lr'].update(
                optimizer._global_learning_rate(), batch_size)
            for name, value in outputs.items():
                record_list[name].update(value, batch_size)
            record_list['batch_time'].update(time.time() - tic)
            tic = time.time()
            if i % log_interval == 0:
                ips = "ips: {:.5f} instance/sec.".format(
                    batch_size / record_list["batch_time"].val)
                log_batch(record_list, i, epoch + 1, epochs, "train", ips)
        lr.step()
        ips = "ips: {:.5f} instance/sec.".format(
            batch_size * record_list["batch_time"].count /
            record_list["batch_time"].sum
        )
        log_epoch(record_list, epoch + 1, "train", ips)

使用单gpu时，发现上述代码中的内循环运行了100次，而使用双gpu时，内循环只运行了50次，打印的log数量减半。这是为什么呢？双卡时感觉只有一半数据参与了训练，但两张卡都有相同的显存占用。如果我的操作有问题，那么如何实现并行训练呢？

期待帮忙解答，谢谢！