使用npu多卡训练时遇到报错，这是我的代码：

 

import os  

import random 

import time 

import cv2 

import numpy as np 

import logging 

import argparse 

import torch_npu 

#自动映射cuda API到npu的代码 

from torch_npu.contrib import transfer_to_npu 

 

#os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" 

#os.environ["CUDA_VISIBLE_DEVICES"] = '0'  #只让设备0可见 

from torch.utils.data import DataLoader, DistributedSampler 

import torch 

import torch.backends.cudnn as cudnn 

import torch.nn as nn 

import torch.nn.functional as F 

import torch.nn.parallel 

import torch.optim 

import torch.utils.data 

import torch.multiprocessing as mp 

import torch.distributed as dist 

from tensorboardX import SummaryWriter 

 

# import sys 

# sys.path.append("..") 

# print(sys.path) 

 

# print(os.getcwd()) 

 

import sys 

sys.path.append('/home/ma-user/work/ASGNet-main') 

from model import * 

from util import dataset 

from util import transform, config 

from util.util import AverageMeter, poly_learning_rate, intersectionAndUnionGPU 

 

cv2.ocl.setUseOpenCL(False) 

cv2.setNumThreads(0) 

 

def get_parser(): 

    parser = argparse.ArgumentParser(description='PyTorch Semantic Segmentation') 

    parser.add_argument('--config', type=str, default='config/ade20k/ade20k_pspnet50.yaml', help='config file') 

    parser.add_argument("--local_rank", type=int, required=True, help='local rank for DistributedDataParallel') 

    #parser.add_argument("--local-rank", "--local_rank", type=int) 

    parser.add_argument('opts', help='see config/ade20k/ade20k_pspnet50.yaml for all options', default=None, nargs=argparse.REMAINDER) 

    args = parser.parse_args() 

    assert args.config is not None 

    cfg = config.load_cfg_from_cfg_file(args.config) 

    if args.opts is not None: 

        cfg = config.merge_cfg_from_list(cfg, args.opts) 

    cfg.LOCAL_RANK = args.local_rank 

    return cfg 

 

def get_logger(): 

    logger_name = "main-logger" 

    logger = logging.getLogger(logger_name) 

    logger.setLevel(logging.INFO) 

    handler = logging.StreamHandler() 

    fmt = "[%(asctime)s %(levelname)s %(filename)s line %(lineno)d %(process)d] %(message)s" 

    handler.setFormatter(logging.Formatter(fmt)) 

    logger.addHandler(handler) 

    return logger 

 

def worker_init_fn(worker_id): 

    random.seed(args.manual_seed + worker_id)    #在多进程数据加载时，根据传入的worker_id和手动设置的种子值来初始化随机数生成器。 

 

# def main_process(): 

#     return not args.multiprocessing_distributed or (args.multiprocessing_distributed and args.rank % args.ngpus_per_node == 0)   #如果没有使用多进程分布式训练或者在多进程分布式训练中当前进程的rank与每个节点的 GPU 数量取余为 0，则为主进程 

 

def main(): 

    args = get_parser() 

    if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ: 

        rank = int(os.environ["RANK"]) 

        world_size = int(os.environ['WORLD_SIZE']) 

        print(f"RANK and WORLD_SIZE in environ: {rank}/{world_size}") 

    else: 

        rank = -1 

        world_size = -1 

   # args.LOCAL_RANK=int(os.environ["LOCAL_RANK"])  

    torch_npu.npu.set_device(args.LOCAL_RANK)  #换个方法设置device  like npu:0 

    #torch_npu.npu.set_device("npu:{}".format(args.LOCAL_RANK))  

    torch.distributed.init_process_group(backend='hccl', world_size=world_size, rank=rank) 

     

     

    device = torch.device('npu:{}'.format(args.LOCAL_RANK)) 

    # torch.distributed.barrier() 

     

 

    assert args.classes > 1 

    assert args.zoom_factor in [1, 2, 4, 8] 

    assert (args.train_h - 1) % 8 == 0 and (args.train_w - 1) % 8 == 0 

    # os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" 

    # os.environ["CUDA_VISIBLE_DEVICES"] = ','.join(str(x) for x in args.train_gpu) 

    if args.manual_seed is not None: 

        cudnn.benchmark = False 

        cudnn.deterministic = True 

        torch_npu.npu.manual_seed(args.manual_seed) 

        np.random.seed(args.manual_seed) 

        torch.manual_seed(args.manual_seed) 

        torch_npu.npu.manual_seed_all(args.manual_seed) 

        random.seed(args.manual_seed) 

    ### multi-processing training is deprecated 

    # if args.dist_url == "env://" and args.world_size == -1: 

    #     args.world_size = int(os.environ["WORLD_SIZE"]) 

    # args.distributed = args.world_size > 1 or args.multiprocessing_distributed 

    # args.ngpus_per_node = len(args.train_gpu) 

    # if len(args.train_gpu) == 1: 

    #     args.sync_bn = False    # sync_bn is deprecated  

    #     args.distributed = False 

    #     args.multiprocessing_distributed = False 

    # if args.multiprocessing_distributed: 

    #     args.world_size = args.ngpus_per_node * args.world_size 

    #     mp.spawn(main_worker, nprocs=args.ngpus_per_node, args=(args.ngpus_per_node, args)) 

    # else: 

    #     main_worker(args.train_gpu, args.ngpus_per_node, args) 

    args.ngpus_per_node = len(args.train_gpu) 

     

    

    main_worker(args.train_gpu, args.ngpus_per_node, args,device) 

 

def main_worker(gpu, ngpus_per_node, argss,device): 

    global args 

    args = argss 

    BatchNorm = nn.BatchNorm2d 

 

    criterion = nn.CrossEntropyLoss(ignore_index=args.ignore_label) 

    model = eval(args.arch).Model(args) 

    model.npu() 

报错如下：