本文整理汇总了Python中torch.backends.cudnn.benchmark方法的典型用法代码示例。如果您正苦于以下问题：Python cudnn.benchmark方法的具体用法？Python cudnn.benchmark怎么用？Python cudnn.benchmark使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在模块torch.backends.cudnn的用法示例。

在下文中一共展示了cudnn.benchmark方法的28个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于我们的系统推荐出更棒的Python代码示例。

示例1: main_inference

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def main_inference():

print("Loading config...")

opt = TestOptions().parse()

print("Loading dataset...")

dset = TVQADataset(opt, mode=opt.mode)

print("Loading model...")

model = STAGE(opt)

model.to(opt.device)

cudnn.benchmark = True

strict_mode = not opt.no_strict

model_path = os.path.join("results", opt.model_dir, "best_valid.pth")

model.load_state_dict(torch.load(model_path), strict=strict_mode)

model.eval()

model.inference_mode = True

torch.set_grad_enabled(False)

print("Evaluation Starts:\n")

predictions = inference(opt, dset, model)

print("predictions {}".format(predictions.keys()))

pred_path = model_path.replace("best_valid.pth",

"{}_inference_predictions.json".format(opt.mode))

save_json(predictions, pred_path)

开发者ID:jayleicn，项目名称:TVQAplus，代码行数:23，

示例2: test_voc

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def test_voc():

# load net

num_classes = len(VOC_CLASSES) + 1 # +1 background

net = build_ssd('test', 300, num_classes) # initialize SSD

net.load_state_dict(torch.load(args.trained_model))

net.eval()

print('Finished loading model!')

# load data

testset = VOCDetection(args.voc_root, [('2007', 'test')], None, VOCAnnotationTransform())

if args.cuda:

net = net.cuda()

cudnn.benchmark = True

# evaluation

test_net(args.save_folder, net, args.cuda, testset,

BaseTransform(net.size, (104, 117, 123)),

thresh=args.visual_threshold)

开发者ID:soo89，项目名称:CSD-SSD，代码行数:18，

示例3: extract_features

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def extract_features(model, data_loader, print_freq=1, metric=None):

cudnn.benchmark = False

model.eval()

batch_time = AverageMeter()

data_time = AverageMeter()

features = OrderedDict()

labels = OrderedDict()

fcs = OrderedDict()

print("Begin to extract features...")

for i, (imgs, fnames, pids, _, _) in enumerate(data_loader):

_fcs, pool5s = extract_cnn_feature(model, imgs)

for fname, fc, pool5, pid in zip(fnames, _fcs, pool5s, pids):

features[fname] = pool5

fcs[fname] = fc

labels[fname] = pid

cudnn.benchmark = True

return features, labels, fcs # 2048 pool5 feature, labels, 1024 fc layers

开发者ID:gddingcs，项目名称:Dispersion-based-Clustering，代码行数:22，

示例4: run

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def run(self):

self.build_model()

self.resume_and_evaluate()

cudnn.benchmark = True

for self.epoch in range(self.start_epoch, self.nb_epochs):

self.train_1epoch()

prec1, val_loss = self.validate_1epoch()

is_best = prec1 > self.best_prec1

#lr_scheduler

self.scheduler.step(val_loss)

# save model

if is_best:

self.best_prec1 = prec1

with open('record/spatial/spatial_video_preds.pickle','wb') as f:

pickle.dump(self.dic_video_level_preds,f)

f.close()

save_checkpoint({

'epoch': self.epoch,

'state_dict': self.model.state_dict(),

'best_prec1': self.best_prec1,

'optimizer' : self.optimizer.state_dict()

},is_best,'record/spatial/checkpoint.pth.tar','record/spatial/model_best.pth.tar')

开发者ID:CMU-CREATE-Lab，项目名称:deep-smoke-machine，代码行数:26，

示例5: set_gpu

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def set_gpu(args, model):

assert torch.cuda.is_available(), "CPU-only experiments currently unsupported"

if args.gpu is not None:

torch.cuda.set_device(args.gpu)

model = model.cuda(args.gpu)

elif args.multigpu is None:

device = torch.device("cpu")

else:

# DataParallel will divide and allocate batch_size to all available GPUs

print(f"=> Parallelizing on {args.multigpu} gpus")

torch.cuda.set_device(args.multigpu[0])

args.gpu = args.multigpu[0]

model = torch.nn.DataParallel(model, device_ids=args.multigpu).cuda(

args.multigpu[0]

)

cudnn.benchmark = True

return model

开发者ID:allenai，项目名称:hidden-networks，代码行数:22，

示例6: main

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def main():

cudnn.benchmark = False

test_video=Test_video(short_side=[224,256])

model = slowfastnet.resnet50(class_num=Config.CLASS_NUM)

assert Config.LOAD_MODEL_PATH is not None

print("load model from:", Config.LOAD_MODEL_PATH)

pretrained_dict = torch.load(Config.LOAD_MODEL_PATH, map_location='cpu')

try:

model_dict = model.module.state_dict()

except AttributeError:

model_dict = model.state_dict()

pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}

model_dict.update(pretrained_dict)

model.load_state_dict(model_dict)

model = model.cuda(params['gpu'][0])

validation(model, test_video)

开发者ID:MagicChuyi，项目名称:SlowFast-Network-pytorch，代码行数:18，

示例7: __init__

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def __init__(self, output_dir):

if cfg.TRAIN.FLAG:

self.model_dir = os.path.join(output_dir, 'Model')

self.image_dir = os.path.join(output_dir, 'Image')

self.log_dir = os.path.join(output_dir, 'Log')

mkdir_p(self.model_dir)

mkdir_p(self.image_dir)

mkdir_p(self.log_dir)

self.summary_writer = FileWriter(self.log_dir)

self.max_epoch = cfg.TRAIN.MAX_EPOCH

self.snapshot_interval = cfg.TRAIN.SNAPSHOT_INTERVAL

s_gpus = cfg.GPU_ID.split(',')

self.gpus = [int(ix) for ix in s_gpus]

self.num_gpus = len(self.gpus)

self.batch_size = cfg.TRAIN.BATCH_SIZE * self.num_gpus

torch.cuda.set_device(self.gpus[0])

cudnn.benchmark = True

# ############# For training stageI GAN #############

开发者ID:hanzhanggit，项目名称:StackGAN-Pytorch，代码行数:23，

示例8: __init__

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def __init__(self, params, dist_model=False):

model_params = params['module']

self.model = models.modules.__dict__[params['module']['arch']](model_params)

utils.init_weights(self.model, init_type='xavier')

self.model.cuda()

if dist_model:

self.model = utils.DistModule(self.model)

self.world_size = dist.get_world_size()

else:

self.model = models.modules.FixModule(self.model)

self.world_size = 1

if params['optim'] == 'SGD':

self.optim = torch.optim.SGD(

self.model.parameters(), lr=params['lr'],

momentum=0.9, weight_decay=0.0001)

elif params['optim'] == 'Adam':

self.optim = torch.optim.Adam(

self.model.parameters(), lr=params['lr'],

betas=(params['beta1'], 0.999))

else:

raise Exception("No such optimizer: {}".format(params['optim']))

cudnn.benchmark = True

开发者ID:XiaohangZhan，项目名称:conditional-motion-propagation，代码行数:26，

示例9: train

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def train(self):

# cudnn.benchmark = True

# self.__val()

if self.configer.get('network', 'resume') is not None:

if self.configer.get('network', 'resume_val'):

self.__val(data_loader=self.data_loader.get_valloader(dataset='val'))

return

elif self.configer.get('network', 'resume_train'):

self.__val(data_loader=self.data_loader.get_valloader(dataset='train'))

return

# return

if self.configer.get('network', 'resume') is not None and self.configer.get('network', 'resume_val'):

self.__val(data_loader=self.data_loader.get_valloader(dataset='val'))

return

while self.configer.get('iters') < self.configer.get('solver', 'max_iters'):

self.__train()

# use swa to average the model

if 'swa' in self.configer.get('lr', 'lr_policy'):

self.optimizer.swap_swa_sgd()

self.optimizer.bn_update(self.train_loader, self.seg_net)

self.__val(data_loader=self.data_loader.get_valloader(dataset='val'))

开发者ID:openseg-group，项目名称:openseg.pytorch，代码行数:27，

示例10: main

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def main():

testset = DeployDataset(

image_root=cfg.img_root,

transform=BaseTransform(size=cfg.input_size, mean=cfg.means, std=cfg.stds)

)

test_loader = data.DataLoader(testset, batch_size=1, shuffle=False, num_workers=cfg.num_workers)

# Model

model = TextNet(is_training=False, backbone=cfg.net)

model_path = os.path.join(cfg.save_dir, cfg.exp_name, \

'textsnake_{}_{}.pth'.format(model.backbone_name, cfg.checkepoch))

model.load_model(model_path)

# copy to cuda

model = model.to(cfg.device)

if cfg.cuda:

cudnn.benchmark = True

detector = TextDetector(model, tr_thresh=cfg.tr_thresh, tcl_thresh=cfg.tcl_thresh)

print('Start testing TextSnake.')

output_dir = os.path.join(cfg.output_dir, cfg.exp_name)

inference(detector, test_loader, output_dir)

开发者ID:princewang1994，项目名称:TextSnake.pytorch，代码行数:25，

示例11: initialize

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def initialize(self, fixed=None):

# Parse options

self.args = self.parse(fixed)

# Setting default torch Tensor type

if self.args.cuda and torch.cuda.is_available():

torch.set_default_tensor_type('torch.cuda.FloatTensor')

cudnn.benchmark = True

else:

torch.set_default_tensor_type('torch.FloatTensor')

# Create weights saving directory

if not os.path.exists(self.args.save_dir):

os.mkdir(self.args.save_dir)

# Create weights saving directory of target model

model_save_path = os.path.join(self.args.save_dir, self.args.exp_name)

if not os.path.exists(model_save_path):

os.mkdir(model_save_path)

return self.args

开发者ID:princewang1994，项目名称:TextSnake.pytorch，代码行数:25，

示例12: tes_net

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def tes_net():

# enable cudnn

cudnn.benchmark = True

# get the DataLoader

data_loaders = get_loader(dataset_config, config, mode="test")

#get the solver

if args.model == 'cycleGAN':

solver = Solver_cycleGAN(data_loaders, config, dataset_config)

elif args.model =='makeupGAN':

solver = Solver_makeupGAN(data_loaders, config, dataset_config)

else:

print("model that not support")

exit()

solver.test()

开发者ID:wtjiang98，项目名称:BeautyGAN_pytorch，代码行数:18，

示例13: main

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def main(config):

svhn_loader, mnist_loader = get_loader(config)

solver = Solver(config, svhn_loader, mnist_loader)

cudnn.benchmark = True

# create directories if not exist

if not os.path.exists(config.model_path):

os.makedirs(config.model_path)

if not os.path.exists(config.sample_path):

os.makedirs(config.sample_path)

if config.mode == 'train':

solver.train()

elif config.mode == 'sample':

solver.sample()

开发者ID:yunjey，项目名称:mnist-svhn-transfer，代码行数:18，

示例14: __init__

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def __init__(self, output_dir, data_loader, n_words, ixtoword, dataset):

if cfg.TRAIN.FLAG:

self.model_dir = os.path.join(output_dir, 'Model')

self.image_dir = os.path.join(output_dir, 'Image')

mkdir_p(self.model_dir)

mkdir_p(self.image_dir)

#torch.cuda.set_device(cfg.GPU_ID)

#cudnn.benchmark = True

self.batch_size = cfg.TRAIN.BATCH_SIZE

self.max_epoch = cfg.TRAIN.MAX_EPOCH

self.snapshot_interval = cfg.TRAIN.SNAPSHOT_INTERVAL

self.n_words = n_words

self.ixtoword = ixtoword

self.data_loader = data_loader

self.dataset = dataset

self.num_batches = len(self.data_loader)

开发者ID:MinfengZhu，项目名称:DM-GAN，代码行数:21，

示例15: get_model

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def get_model(conf, num_class=10, data_parallel=True):

name = conf['type']

if name == 'wresnet40_2':

model = WideResNet(40, 2, dropout_rate=0.0, num_classes=num_class)

elif name == 'wresnet28_2':

model = WideResNet(28, 2, dropout_rate=0.0, num_classes=num_class)

elif name == 'wresnet28_10':

model = WideResNet(28, 10, dropout_rate=0.0, num_classes=num_class)

else:

raise NameError('no model named, %s' % name)

if data_parallel:

model = model.cuda()

model = DataParallel(model)

else:

import horovod.torch as hvd

device = torch.device('cuda', hvd.local_rank())

model = model.to(device)

cudnn.benchmark = True

return model

开发者ID:ildoonet，项目名称:unsupervised-data-augmentation，代码行数:24，

示例16: initial_setup

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def initial_setup(self, args):

############

logging.info(f"run pid: {os.getpid()} parent: {os.getppid()}")

logging.info("#########")

logging.info(args.__dict__)

logging.info(f"Rank: {args.rank} World_size: {args.world_size}, Run {args.run_name}")

args.cuda = torch.cuda.is_available()

logging.info(f"Pytorch version: {torch.__version__}")

logging.info("Using CUDA: {} CUDA AVAIL: {} #DEVICES: {} VERSION: {}".format(

args.cuda, torch.cuda.is_available(), torch.cuda.device_count(),

torch.version.cuda))

if not args.cuda:

self.device = 'cpu'

else:

self.device = 'cuda'

cudnn.benchmark = True

cudnn.enabled = True

random.seed(args.seed) # The seed needs to be constant between processes.

torch.manual_seed(args.seed)

torch.cuda.manual_seed_all(args.seed)

开发者ID:facebookresearch，项目名称:fastMRI，代码行数:24，

示例17: main

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def main():

print "==> Loading data and model..."

tranfrom_test = transforms.Compose([

transforms.ToTensor(),

transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),

])

test_set = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=tranfrom_test)

testloader = torch.utils.data.DataLoader(test_set, batch_size=1, shuffle=True, num_workers=2)

class_names = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']

assert os.path.isdir('checkpoint'), 'Error: no checkpoint directory found!'

checkpoint = torch.load('./checkpoint/%s.t7'%args.model)

net = checkpoint['net']

net.cuda()

cudnn.benchmark = True

print "==> Starting attck..."

results = attack_all(net, testloader, pixels=args.pixels, targeted=args.targeted, maxiter=args.maxiter, popsize=args.popsize, verbose=args.verbose)

print "Final success rate: %.4f"%results

开发者ID:DebangLi，项目名称:one-pixel-attack-pytorch，代码行数:23，

示例18: __init__

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def __init__(self, output_dir):

if cfg.TRAIN.FLAG:

self.model_dir = os.path.join(output_dir, 'Model')

self.image_dir = os.path.join(output_dir, 'Image')

self.log_dir = os.path.join(output_dir, 'Log')

mkdir_p(self.model_dir)

mkdir_p(self.image_dir)

mkdir_p(self.log_dir)

self.summary_writer = FileWriter(self.log_dir)

self.max_epoch = cfg.TRAIN.MAX_EPOCH

self.snapshot_interval = cfg.TRAIN.SNAPSHOT_INTERVAL

self.max_objects = 4

s_gpus = cfg.GPU_ID.split(',')

self.gpus = [int(ix) for ix in s_gpus]

self.num_gpus = len(self.gpus)

self.batch_size = cfg.TRAIN.BATCH_SIZE

torch.cuda.set_device(self.gpus[0])

cudnn.benchmark = True

# ############# For training stageI GAN #############

开发者ID:tohinz，项目名称:multiple-objects-gan，代码行数:24，

示例19: __init__

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def __init__(self, output_dir):

if cfg.TRAIN.FLAG:

self.model_dir = os.path.join(output_dir, 'Model')

self.image_dir = os.path.join(output_dir, 'Image')

self.log_dir = os.path.join(output_dir, 'Log')

mkdir_p(self.model_dir)

mkdir_p(self.image_dir)

mkdir_p(self.log_dir)

self.summary_writer = FileWriter(self.log_dir)

self.max_epoch = cfg.TRAIN.MAX_EPOCH

self.snapshot_interval = cfg.TRAIN.SNAPSHOT_INTERVAL

self.max_objects = 3

s_gpus = cfg.GPU_ID.split(',')

self.gpus = [int(ix) for ix in s_gpus]

self.num_gpus = len(self.gpus)

self.batch_size = cfg.TRAIN.BATCH_SIZE

torch.cuda.set_device(self.gpus[0])

cudnn.benchmark = True

# ############# For training stageI GAN #############

开发者ID:tohinz，项目名称:multiple-objects-gan，代码行数:24，

示例20: __init__

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def __init__(self, output_dir, data_loader, n_words, ixtoword, resume):

if cfg.TRAIN.FLAG:

self.model_dir = os.path.join(output_dir, 'Model')

self.image_dir = os.path.join(output_dir, 'Image')

mkdir_p(self.model_dir)

mkdir_p(self.image_dir)

self.batch_size = cfg.TRAIN.BATCH_SIZE

self.max_epoch = cfg.TRAIN.MAX_EPOCH

self.snapshot_interval = cfg.TRAIN.SNAPSHOT_INTERVAL

self.resume = resume

s_gpus = cfg.GPU_ID.split(',')

self.gpus = [int(ix) for ix in s_gpus]

self.n_words = n_words

self.ixtoword = ixtoword

self.data_loader = data_loader

self.num_batches = len(self.data_loader)

torch.cuda.set_device(self.gpus[0])

cudnn.benchmark = True

开发者ID:tohinz，项目名称:multiple-objects-gan，代码行数:24，

示例21: __init__

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def __init__(self, output_dir):

if cfg.TRAIN.FLAG:

self.model_dir = os.path.join(output_dir, 'Model')

self.image_dir = os.path.join(output_dir, 'Image')

self.log_dir = os.path.join(output_dir, 'Log')

mkdir_p(self.model_dir)

mkdir_p(self.image_dir)

mkdir_p(self.log_dir)

self.summary_writer = FileWriter(self.log_dir)

self.max_epoch = cfg.TRAIN.MAX_EPOCH

self.snapshot_interval = cfg.TRAIN.SNAPSHOT_INTERVAL

s_gpus = cfg.GPU_ID.split(',')

self.gpus = [int(ix) for ix in s_gpus]

self.num_gpus = len(self.gpus)

self.batch_size = cfg.TRAIN.BATCH_SIZE

torch.cuda.set_device(self.gpus[0])

cudnn.benchmark = True

# ############# For training stageI GAN #############

开发者ID:tohinz，项目名称:multiple-objects-gan，代码行数:23，

示例22: forward

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def forward(self, weight, bias, input):

# Assert we're using cudnn

for i in ([weight, bias, input]):

if i is not None and not(cudnn.is_acceptable(i)):

raise Exception('You must be using CUDNN to use _EfficientBatchNorm')

res = input.new(*self._output_size(input, weight))

self._cudnn_info = torch._C._cudnn_convolution_full_forward(

input, weight, bias, res,

(self.padding, self.padding),

(self.stride, self.stride),

(self.dilation, self.dilation),

self.groups, cudnn.benchmark

)

return res

开发者ID:zhiqiangdon，项目名称:CU-Net，代码行数:18，

示例23: backward

​点赞 6

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def backward(self, weight, bias, input, grad_output):

grad_input = input.new()

grad_input.resize_as_(input)

torch._C._cudnn_convolution_backward_data(

grad_output, grad_input, weight, self._cudnn_info,

cudnn.benchmark)

grad_weight = weight.new().resize_as_(weight)

torch._C._cudnn_convolution_backward_filter(grad_output, input, grad_weight, self._cudnn_info,

cudnn.benchmark)

if bias is not None:

grad_bias = bias.new().resize_as_(bias)

torch._C._cudnn_convolution_backward_bias(grad_output, grad_bias, self._cudnn_info)

else:

grad_bias = None

return grad_weight, grad_bias, grad_input

开发者ID:zhiqiangdon，项目名称:CU-Net，代码行数:20，

示例24: main

​点赞 5

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def main(args):

cudnn.benchmark = True

cudnn.enabled = True

save_path = args.logs_dir

sys.stdout = Logger(osp.join(args.logs_dir, 'log'+ str(args.merge_percent)+ time.strftime(".%m_%d_%H:%M:%S") + '.txt'))

# get all unlabeled data for training

dataset_all = datasets.create(args.dataset, osp.join(args.data_dir, args.dataset))

new_train_data, cluster_id_labels = change_to_unlabel(dataset_all)

num_train_ids = len(np.unique(np.array(cluster_id_labels)))

nums_to_merge = int(num_train_ids * args.merge_percent)

BuMain = Bottom_up(model_name=args.arch, batch_size=args.batch_size,

num_classes=num_train_ids,

dataset=dataset_all,

u_data=new_train_data, save_path=args.logs_dir, max_frames=args.max_frames,

embeding_fea_size=args.fea)

for step in range(int(1/args.merge_percent)-1):

print('step: ',step)

BuMain.train(new_train_data, step, loss=args.loss)

BuMain.evaluate(dataset_all.query, dataset_all.gallery)

# get new train data for the next iteration

print('----------------------------------------bottom-up clustering------------------------------------------------')

cluster_id_labels, new_train_data = BuMain.get_new_train_data_v2(cluster_id_labels, nums_to_merge, step, penalty=args.size_penalty)

print('\n\n')

开发者ID:gddingcs，项目名称:Dispersion-based-Clustering，代码行数:35，

示例25: main

​点赞 5

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def main():

global args

args = parser.parse_args()

model_selection = 'resnet'

model = define_model(encoder = model_selection)

original_model2 = net_mask.drn_d_22(pretrained=True)

model2 = net_mask.AutoED(original_model2)

if torch.cuda.device_count() == 8:

model = torch.nn.DataParallel(model, device_ids=[0, 1, 2, 3, 4, 5, 6, 7]).cuda()

model2 = torch.nn.DataParallel(model2, device_ids=[0, 1, 2, 3, 4, 5, 6, 7]).cuda()

batch_size = 64

elif torch.cuda.device_count() == 4:

model = torch.nn.DataParallel(model, device_ids=[0, 1, 2, 3]).cuda()

model2 = torch.nn.DataParallel(model2, device_ids=[0, 1, 2, 3]).cuda()

batch_size = 32

else:

model = torch.nn.DataParallel(model).cuda()

model2 = torch.nn.DataParallel(model2).cuda()

batch_size = 8

model.load_state_dict(torch.load('./pretrained_model/model_' + model_selection))

cudnn.benchmark = True

optimizer = torch.optim.Adam(model2.parameters(), args.lr, weight_decay=args.weight_decay)

train_loader = loaddata.getTrainingData(batch_size)

for epoch in range(args.start_epoch, args.epochs):

train(train_loader, model, model2, optimizer, epoch)

torch.save(model.state_dict(), '/net_mask/mask_'+model_selection)

开发者ID:JunjH，项目名称:Visualizing-CNNs-for-monocular-depth-estimation，代码行数:34，

示例26: enable_cudnn_benchmark

​点赞 5

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def enable_cudnn_benchmark():

"""Turn on the cudnn autotuner that selects efficient algorithms."""

if torch.cuda.is_available():

cudnn.benchmark = True

开发者ID:corenel，项目名称:pytorch-atda，代码行数:6，

示例27: main

​点赞 5

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def main():

# Parse the JSON arguments

config_args = parse_args()

# Create the experiment directories

_, config_args.summary_dir, config_args.checkpoint_dir = create_experiment_dirs(

config_args.experiment_dir)

model = MobileNetV2(config_args)

if config_args.cuda:

model.cuda()

cudnn.enabled = True

cudnn.benchmark = True

print("Loading Data...")

data = CIFAR10Data(config_args)

print("Data loaded successfully\n")

trainer = Train(model, data.trainloader, data.testloader, config_args)

if config_args.to_train:

try:

print("Training...")

trainer.train()

print("Training Finished\n")

except KeyboardInterrupt:

pass

if config_args.to_test:

print("Testing...")

trainer.test(data.testloader)

print("Testing Finished\n")

开发者ID:MG2033，项目名称:MobileNet-V2，代码行数:35，

示例28: __init__

​点赞 5

​

# 需要导入模块: from torch.backends import cudnn [as 别名]

# 或者: from torch.backends.cudnn import benchmark [as 别名]

def __init__(self, modalities, n_classes, n_frames, n_channels, input_sizes,

hidden_size, n_layers, dropout, hidden_size_seq, n_layers_seq,

dropout_seq, bg_w, lr, lr_decay_rate, to_idx, ckpt_path):

super(BaseModel, self).__init__()

cudnn.benchmark = True

utils.info('{} modality'.format(modalities[to_idx]))

self.embeds = []

for i, m in enumerate(modalities):

encoder_type = 'cnn' if m in CNN_MODALITIES else 'rnn'

embed = nn.DataParallel(

get_tad(n_classes, n_frames, n_channels[i], input_sizes[i],

hidden_size, n_layers, dropout, hidden_size_seq, n_layers_seq,

dropout_seq, encoder_type).cuda())

self.embeds.append(embed)

# Multiple optimizers

self.optimizers = []

self.lr_decay_rates = []

# Visual encoder: SGD

visual_params = list(self.embeds[to_idx].module.embed.parameters())

visual_optimizer = optim.SGD(

visual_params, lr=lr, momentum=0.9, weight_decay=5e-4)

self.optimizers.append(visual_optimizer)

self.lr_decay_rates.append(lr_decay_rate)

# Sequence encoder: Adam

sequence_params = list(self.embeds[to_idx].module.rnn.parameters()) + \

list(self.embeds[to_idx].module.fc.parameters())

sequence_optimizer = optim.Adam(sequence_params, lr=1e-3)

self.optimizers.append(sequence_optimizer)

self.lr_decay_rates.append(1) # No learning rate decay for Adam

# Weighted cross-entropy loss

self.criterion_cls = nn.CrossEntropyLoss(

torch.FloatTensor([bg_w] + [1] * n_classes)).cuda()

self.n_classes = n_classes

self.modalities = modalities

self.to_idx = to_idx

self.ckpt_path = ckpt_path

开发者ID:google，项目名称:graph_distillation，代码行数:42，

注：本文中的torch.backends.cudnn.benchmark方法示例整理自Github/MSDocs等源码及文档管理平台，相关代码片段筛选自各路编程大神贡献的开源项目，源码版权归原作者所有，传播和使用请参考对应项目的License；未经允许，请勿转载。