def __init__(self): self.model = get_net() state_dict = torch.load( r'..\static\model\model.pkl', map_location=device) self.model.load_state_dict(state_dict) self.model.eval()
def calc_pos(val_path="../data/cub/CUB200/images/val/", log_path="./loc.txt"): model = net.get_net(classes_num=200, channel_size=2048) model.load_state_dict( torch.load("./weights/cub/resnet50_cub_best_acc.pth"), strict=True) transform = transforms.Compose([ transforms.Resize(size=(224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) model.eval() dir_list = os.listdir(val_path) log_list = [] for dir_ in dir_list: imgae_list = os.listdir(val_path + "/" + dir_) for image in imgae_list: image_path = val_path + "/" + dir_ + "/" + image p1, p2 = model.get_boundbox_image(image_path, transform) log_list.append([image, p1, p2]) print("{} finished".format(image_path)) with open(log_path, "w", encoding="utf-8") as file: for item in log_list: image, p1, p2 = item content = "{},{},{},{},{}".format(image, p1[0], p1[1], p2[0], p2[1]) + "\n" file.write(content)
def build_qnet(self): net_func = get_net(self._net_name) hidden_units = self._layer_size + [self._action_size] self._q = net_func(self._state, hidden_units=hidden_units, name='Online') self._q_next = net_func(self._state_next, hidden_units=hidden_units, name='Target')
def get_dogs_bounding_box(): model=net.get_net(classes_num=120,channel_size=2048) model.load_state_dict(torch.load("./weights/dogs/resnet50_dogs_best_acc.pth"),strict=True) transform=transforms.Compose([transforms.Resize(size=(224,224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225])]) model.eval() img_name_list=os.listdir("./utils/ori/dogs/") for img_name in img_name_list: old_img_path="./utils/ori/dogs/"+img_name new_image_path="./utils/bnd/dogs/"+img_name model.get_boundbox_image(old_img_path,transform,new_image_path)
def vis_cub(): model=net.get_net(classes_num=200,channel_size=2048) model.load_state_dict(torch.load("./weights/cub/resnet50_cub_best_acc.pth"),strict=True) transform=transforms.Compose([transforms.Resize(size=(224,224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225])]) model.eval() img_name_list=os.listdir("./utils/ori/cub/") for img_name in img_name_list: old_img_path="./utils/ori/cub/"+img_name attention_img_path="./utils/new/cub/"+img_name model.get_attention_map(old_img_path,transform,attention_img_path) print("{} finished".format(old_img_path))
def count_cub(): model=net.get_net(classes_num=200,channel_size=2048) model.load_state_dict(torch.load("./weights/cub/resnet50_cub_best_acc.pth"),strict=True) transform=transforms.Compose([transforms.Resize(size=(224,224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225])]) model.eval() img_name_list=os.listdir("./utils/ori/cub/") feature_vec=[] for img_name in img_name_list: old_img_path="./utils/ori/cub/"+img_name vec=model.get_count_result(old_img_path,transform) feature_vec.append(vec) feature_vec=np.concatenate(feature_vec,axis=0) print(feature_vec.shape) draw_hist(feature_vec)
def predict_all(self, datas): my_model = get_net() my_model.load_state_dict( torch.load(os.path.join(MODEL_PATH, TORCH_MODEL_NAME))) my_model.to(device) for param in my_model.parameters(): param.requires_grad = False my_model.eval() labels = [] step = 0 for data in datas: # print('predict step : ', step) step += 1 x_data = self.data.predict_data(**data) img = cv2.imread(os.path.join(DATA_PATH, x_data[0])) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img = torchvision.transforms.ToTensor()(img) pred = my_model([img.to(device)])[0] for (k, v) in pred.items(): pred[k] = v.cpu().numpy() # print('labels len is ',len(pred['labels'])) for j in range(len(pred['labels'])): labels.append([ x_data[0], pred['scores'][j], pred['boxes'][j], pred['labels'][j] - 1 ]) # 这里pred['labels'][j]-1 用于与标签对应 0-没有佩戴,1-有佩戴 ''' 关于返回的说明: 返回labels为一个list集合,其中每一项样例为['img/000278.jpg', 0.99910635, [117.190445, 108.4803, 163.91493, 222.29749], 1],包括: x_data[0]:图片的相对路径 pred['scores'][j]:预测框的置信度 pred['boxes'][j]:预测框的坐标 [x_min, y_min, x_max, y_max] pred['labels'][j]:预测框所属类别 评估指标为map。 ''' return labels
def main(): start_time = time() last_step = get_last_ckpt_step() assert last_step >= 0 my_log(f'Checkpoint found: {last_step}\n') print_args() net_init, net_apply, net_init_cache, net_apply_fast = get_net() params = load_ckpt(last_step) in_shape = (args.batch_size, args.L, args.L, 1) _, cache_init = net_init_cache(params, jnp.zeros(in_shape), (-1, -1)) # sample_raw_fun = get_sample_fun(net_apply, None) sample_raw_fun = get_sample_fun(net_apply_fast, cache_init) # sample_k_fun = get_sample_k_fun(net_apply, None) sample_k_fun = get_sample_k_fun(net_apply_fast, net_init_cache) log_q_fun = get_log_q_fun(net_apply) @jit def update(spins_old, log_q_old, energy_old, step, accept_count, energy_mean, energy_var_sum, rng): rng, rng_k, rng_sample, rng_accept = jrand.split(rng, 4) k = get_k(rng_k) spins = sample_k_fun(k, params, spins_old, rng_sample) log_q = log_q_fun(params, spins) energy = energy_fun(spins) log_uniform = jnp.log(jrand.uniform(rng_accept, (args.batch_size, ))) accept = log_uniform < (log_q_old - log_q + args.beta * (energy_old - energy)) spins = jnp.where(jnp.expand_dims(accept, axis=(1, 2, 3)), spins, spins_old) log_q = jnp.where(accept, log_q, log_q_old) energy = jnp.where(accept, energy, energy_old) mag = spins.mean(axis=(1, 2, 3)) step += 1 accept_count += accept.sum() energy_per_spin = energy / args.L**2 energy_mean, energy_var_sum = welford_update(energy_per_spin.mean(), step, energy_mean, energy_var_sum) return (spins, log_q, energy, mag, accept, k, step, accept_count, energy_mean, energy_var_sum, rng) rng, rng_init = jrand.split(jrand.PRNGKey(args.seed)) # Sample initial configurations from the network spins = sample_raw_fun(args.batch_size, params, rng_init) log_q = log_q_fun(params, spins) energy = energy_fun(spins) step = 0 accept_count = 0 energy_mean = 0 energy_var_sum = 0 data_filename = args.log_filename.replace('.log', '.hdf5') writer_proto = [ # Uncomment to save all the sampled spins # ('spins', bool, (args.batch_size, args.L, args.L)), ('log_q', np.float32, (args.batch_size, )), ('energy', np.int32, (args.batch_size, )), ('mag', np.float32, (args.batch_size, )), ('accept', bool, (args.batch_size, )), ('k', np.int32, None), ] ensure_dir(data_filename) with ChunkedDataWriter(data_filename, writer_proto, args.save_step) as writer: my_log('Sampling...') while step < args.max_step: (spins, log_q, energy, mag, accept, k, step, accept_count, energy_mean, energy_var_sum, rng) = update(spins, log_q, energy, step, accept_count, energy_mean, energy_var_sum, rng) # Uncomment to save all the sampled spins # writer.write(spins[:, :, :, 0] > 0, log_q, energy, mag, accept, k) writer.write(log_q, energy, mag, accept, k) if args.print_step and step % args.print_step == 0: accept_rate = accept_count / (step * args.batch_size) energy_std = jnp.sqrt(energy_var_sum / step) my_log(', '.join([ f'step = {step}', f'P = {accept_rate:.8g}', f'E = {energy_mean:.8g}', f'E_std = {energy_std:.8g}', f'time = {time() - start_time:.3f}', ]))
def main(): start_time = time() last_step = get_last_ckpt_step() assert last_step >= 0 my_log(f'Checkpoint found: {last_step}\n') print_args() net_init, net_apply, net_init_cache, net_apply_fast = get_net() params = load_ckpt(last_step) in_shape = (args.batch_size, args.L, args.L, 1) _, cache_init = net_init_cache(params, jnp.zeros(in_shape), (-1, -1)) # sample_fun = get_sample_fun(net_apply, None) sample_fun = get_sample_fun(net_apply_fast, cache_init) log_q_fun = get_log_q_fun(net_apply) def sample_energy_fun(rng): spins = sample_fun(args.batch_size, params, rng) log_q = log_q_fun(params, spins) energy = energy_fun(spins) return spins, log_q, energy @jit def update(spins_old, log_q_old, energy_old, step, energy_mean, energy_var_sum, rng): rng, rng_sample = jrand.split(rng) spins, log_q, energy = sample_energy_fun(rng_sample) mag = spins.mean(axis=(1, 2, 3)) step += 1 energy_per_spin = energy / args.L**2 energy_mean, energy_var_sum = welford_update(energy_per_spin.mean(), step, energy_mean, energy_var_sum) return (spins, log_q, energy, mag, step, energy_mean, energy_var_sum, rng) rng, rng_init = jrand.split(jrand.PRNGKey(args.seed)) spins, log_q, energy = sample_energy_fun(rng_init) step = 0 energy_mean = 0 energy_var_sum = 0 data_filename = args.log_filename.replace('.log', '.hdf5') writer_proto = [ # Uncomment to save all the sampled spins # ('spins', bool, (args.L, args.L)), ('log_q', np.float32, None), ('energy', np.int32, None), ('mag', np.float32, None), ] ensure_dir(data_filename) with ChunkedDataWriter(data_filename, writer_proto, args.save_step * args.batch_size) as writer: my_log('Sampling...') while step < args.max_step: (spins, log_q, energy, mag, step, energy_mean, energy_var_sum, rng) = update(spins, log_q, energy, step, energy_mean, energy_var_sum, rng) # Uncomment to save all the sampled spins # writer.write_batch(spins[:, :, :, 0] > 0, log_q, energy, mag) writer.write_batch(log_q, energy, mag) if args.print_step and step % args.print_step == 0: energy_std = jnp.sqrt(energy_var_sum / step) my_log(', '.join([ f'step = {step}', f'E = {energy_mean:.8g}', f'E_std = {energy_std:.8g}', f'time = {time() - start_time:.3f}', ]))
train_batch_size = args.BATCH valid_batch_size = 1 train_data_loader = torch.utils.data.DataLoader(train_dataset, batch_size=train_batch_size, shuffle=True, num_workers=0, collate_fn=collate_fn) valid_data_loader = torch.utils.data.DataLoader(valid_dataset, batch_size=valid_batch_size, shuffle=False, num_workers=0, collate_fn=collate_fn) ''' 实现自己的网络机构 ''' my_model = get_net() # 判断gpu是否可用 if torch.cuda.is_available(): device = 'cuda' print('pytorch use cuda') else: device = 'cpu' print('pytorch use cpu') device = torch.device(device) my_model.to(device) TORCH_MODEL_NAME = "model.pkl" lr = 1e-4 params = [p for p in my_model.parameters() if p.requires_grad] optimizer = torch.optim.SGD(params, lr=lr, momentum=0.9, weight_decay=0.001)
parser.add_argument('--model_choice', default=MODEL_CHOICE, type=int, help='MODEL_CHOICE') parser.add_argument('--which_epoch',default='last', type=str, help='0,1,2,3...or last') parser.add_argument('--batch_size', default=BATCH_SIZE, type=int, help='batchsize') parser.add_argument('--num_workers', default=1, type=int, help='num_workers') opt = parser.parse_args() MODEL_NAME = MODEL_DICT[opt.model_choice] DATASET_NAME = DATASET_DICT[opt.data_choice] data_dir = os.path.join(DATA_ROOT, DATASET_NAME) model_dir = os.path.join(MODEL_ROOT, DATASET_NAME, MODEL_NAME) result_dir = os.path.join(RESULT_ROOT, DATASET_NAME, MODEL_NAME) if not os.path.isdir(result_dir): os.makedirs(result_dir) create_net = get_net(opt.model_choice) ###################################################################### # Load Data # --------- data_transforms = transforms.Compose([ transforms.Resize((288,144), interpolation=3), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) image_datasets = {x: datasets.ImageFolder( os.path.join(data_dir,x) ,data_transforms) for x in ['gallery','query']} dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=opt.batch_size, shuffle=False, num_workers=opt.num_workers) for x in ['gallery','query']} class_names = image_datasets['query'].classes
def train(): ''' 进行训练 ''' #定义记录部分 log = Metrics.Logger(config.csv_path, config.tb_path) #定义模型 if config.start_epoch == 1: model = net.get_net(classes_num=config.classes_num, channel_size=config.channel_size, cnn_weights_path=config.cnn_weights_path, drop_rate=config.drop_rate) else: model = net.get_net(classes_num=config.classes_num, channel_size=config.channel_size, drop_rate=config.drop_rate) print("model load succeed") if config.use_cuda: model = model.cuda() #将model转到cuda上 if config.use_parallel: model = nn.DataParallel(model, device_ids=config.device_ids) cudnn.benchmark = True if config.start_epoch != 1: all_weights_path = config.save_weights_path.format(config.start_epoch - 1) model.load_state_dict(torch.load(all_weights_path)) print("{} load succeed".format(all_weights_path)) #加载数据集 train_folder = config.train_img_path validate_folder = config.validate_img_path train_loader = ImageReader.get_loader("train", train_folder) validate_loader = ImageReader.get_loader("validate", validate_folder) #定义优化器和学习率调度器 optimizer = SGD(params=model.parameters(), lr=config.start_lr, momentum=0.9, weight_decay=config.weight_decay) scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=config.stones, gamma=0.1) #定义评估函数 accuracy = Metrics.AccuracyList(num=1) l_train = Metrics.LossList(1) l_val = Metrics.LossList(1) #定义最好的准确率 best_acc = 0 for i in range(config.start_epoch, config.start_epoch + config.num_epoch): #分配学习率 scheduler.step(epoch=i) lr = scheduler.get_lr()[0] print("{} epoch start , lr is {}".format(i, lr)) #开始训练这一轮 model.train() accuracy.set_zeros() l_train.set_zeros() train_step = 0 for (x1, x2), y in train_loader: x1 = Variable(x1) x2 = Variable(x2) y = Variable(y) if config.use_cuda: x1 = x1.cuda() x2 = x2.cuda() y = y.cuda(async=True) optimizer.zero_grad() #清空梯度值 y_ = model(x1, x2) #求y #求这一步的损失值和准确率 step_loss, loss_list = model.get_loss(y_, y) step_acc = accuracy(y_, y) l_train.log(loss_list) #更新梯度值 step_loss.backward() optimizer.step() train_step += 1 #训练步数+1 #输出这一步的记录 print("{} epoch,{} step,step loss is {:.6f},step acc is {:.4f}". format(i, train_step, loss_list[0], max(step_acc))) del (step_loss, x1, x2, y, y_) #求这一轮训练情况 train_acc_list = accuracy.get_acc_list() train_loss_list = l_train.get_loss_list() #保存模型 weights_name = config.save_weights_path.format(i) torch.save(model.state_dict(), weights_name) del_weights_name = config.save_weights_path.format(i - 1) if os.path.exists(del_weights_name): os.remove(del_weights_name) print("{} save,{} delete".format(weights_name, del_weights_name)) #开始验证步骤 model.eval() accuracy.set_zeros() #将accuracy中total_sample和total_correct清0 l_val.set_zeros() for (x1, x2), y in validate_loader: x1 = Variable(x1, requires_grad=False) x2 = Variable(x2, requires_grad=False) y = Variable(y, requires_grad=False) if config.use_cuda: x1 = x1.cuda() x2 = x2.cuda() y = y.cuda(async=True) y_ = model(x1, x2) _, loss_list = model.get_valloss(y_, y) accuracy(y_, y) l_val.log(loss_list) del (x1, x2, y, y_, _) val_acc_list = accuracy.get_acc_list() val_loss_list = l_val.get_loss_list() print("validate end,log start") #保存最佳的模型 if best_acc < max(val_acc_list): weights_name = config.save_weights_path.format("best_acc") torch.save(model.state_dict(), weights_name) best_acc = max(val_acc_list) #求model的正则化项 l2_reg = 0.0 for param in model.parameters(): l2_reg += torch.norm(param).data[0] #开始记录 log.log(i, train_acc_list, train_loss_list, val_acc_list, val_loss_list, l2_reg, lr) print("log end ...") print( "{} epoch end, train loss is {},train acc is {},val loss is {},val acc is {},weight l2 norm is {}" .format(i, train_loss_list[0], max(train_acc_list), val_loss_list[0], max(val_acc_list), l2_reg)) del (model) print("{} train end,best_acc is {}...".format(config.dataset, best_acc))
def main(): start_time = time() init_out_dir() last_step = get_last_ckpt_step() if last_step >= 0: my_log(f'\nCheckpoint found: {last_step}\n') else: clear_log() print_args() net_init, net_apply, net_init_cache, net_apply_fast = get_net() rng, rng_net = jrand.split(jrand.PRNGKey(args.seed)) in_shape = (args.batch_size, args.L, args.L, 1) out_shape, params_init = net_init(rng_net, in_shape) _, cache_init = net_init_cache(params_init, jnp.zeros(in_shape), (-1, -1)) # sample_fun = get_sample_fun(net_apply, None) sample_fun = get_sample_fun(net_apply_fast, cache_init) log_q_fun = get_log_q_fun(net_apply) need_beta_anneal = args.beta_anneal_step > 0 opt_init, opt_update, get_params = optimizers.adam(args.lr) @jit def update(step, opt_state, rng): params = get_params(opt_state) rng, rng_sample = jrand.split(rng) spins = sample_fun(args.batch_size, params, rng_sample) log_q = log_q_fun(params, spins) / args.L**2 energy = energy_fun(spins) / args.L**2 def neg_log_Z_fun(params, spins): log_q = log_q_fun(params, spins) / args.L**2 energy = energy_fun(spins) / args.L**2 beta = args.beta if need_beta_anneal: beta *= jnp.minimum(step / args.beta_anneal_step, 1) neg_log_Z = log_q + beta * energy return neg_log_Z loss_fun = partial(expect, log_q_fun, neg_log_Z_fun, mean_grad_expected_is_zero=True) grads = grad(loss_fun)(params, spins, spins) opt_state = opt_update(step, grads, opt_state) return spins, log_q, energy, opt_state, rng if last_step >= 0: params_init = load_ckpt(last_step) opt_state = opt_init(params_init) my_log('Training...') for step in range(last_step + 1, args.max_step + 1): spins, log_q, energy, opt_state, rng = update(step, opt_state, rng) if args.print_step and step % args.print_step == 0: # Use the final beta, not the annealed beta free_energy = log_q / args.beta + energy my_log(', '.join([ f'step = {step}', f'F = {free_energy.mean():.8g}', f'F_std = {free_energy.std():.8g}', f'S = {-log_q.mean():.8g}', f'E = {energy.mean():.8g}', f'time = {time() - start_time:.3f}', ])) if args.save_step and step % args.save_step == 0: params = get_params(opt_state) save_ckpt(params, step)
def train(): ''' 进行训练 ''' #定义记录部分 csv_path = config.csv_path tb_path = config.tb_path writer = SummaryWriter(log_dir=tb_path) #定义模型 if config.start_epoch == 1: model = net.get_net(classes_num=config.classes_num, channel_size=config.channel_size, cnn_weights_path=config.cnn_weights_path, drop_rate=config.drop_rate) else: model = net.get_net(classes_num=config.classes_num, channel_size=config.channel_size, drop_rate=config.drop_rate) print("model load succeed") if config.use_cuda: model = model.cuda() #将model转到cuda上 if config.use_parallel: model = nn.DataParallel(model, device_ids=config.device_ids) cudnn.benchmark = True if config.start_epoch != 1: all_weights_path = config.save_weights_path.format(config.start_epoch - 1) model.load_state_dict(torch.load(all_weights_path)) print("{} load succeed".format(all_weights_path)) #加载数据集 train_folder = config.train_img_path validate_folder = config.validate_img_path train_loader = ImageReader.getLoader(config.dataset, "train", train_folder) validate_loader = ImageReader.getLoader(config.dataset, "validate", validate_folder) #定义优化器和学习率调度器 optimizer = SGD(params=model.parameters(), lr=config.start_lr, momentum=0.9, weight_decay=config.weight_decay) scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=config.stones, gamma=0.1) #定义评估函数 criterion = nn.CrossEntropyLoss() accuracy = Metrics.Accuracy() #定义最好的准确率 best_acc = 0 for i in range(config.start_epoch, config.start_epoch + config.num_epoch): #分配学习率 scheduler.step(epoch=i) lr = scheduler.get_lr()[0] print("{} epoch start , lr is {}".format(i, lr)) #开始训练这一轮 model.train() accuracy.__init__() train_loss = 0 train_step = 0 for x, y in train_loader: x = Variable(x) y = Variable(y) if config.use_cuda: x = x.cuda() y = y.cuda(async=True) optimizer.zero_grad() #清空梯度值 y_ = model(x) #求y #求这一步的损失值和准确率 step_loss = criterion(y_, y) step_acc = accuracy(y_, y) train_loss += step_loss.data[0] #更新梯度值 step_loss.backward() optimizer.step() train_step += 1 #训练步数+1 #输出这一步的记录 print("{} epoch,{} step,step loss is {:.6f},step acc is {:.4f}". format(i, train_step, step_loss.data[0], step_acc)) del (step_loss, x, y, y_) #求这一轮训练情况 train_acc = accuracy.total_correct / (accuracy.total_sample + 1e-5) train_loss = train_loss / (train_step + 1e-5) #保存模型 weights_name = config.save_weights_path.format(i) torch.save(model.state_dict(), weights_name) del_weights_name = config.save_weights_path.format(i - 3) if os.path.exists(del_weights_name): os.remove(del_weights_name) print("{} save,{} delete".format(weights_name, del_weights_name)) #开始验证步骤 model.eval() accuracy.__init__() #将accuracy中total_sample和total_correct清0 val_loss = 0 val_step = 0 for x, y in validate_loader: x = Variable(x, requires_grad=False) y = Variable(y, requires_grad=False) if config.use_cuda: x = x.cuda() y = y.cuda(async=True) y_ = model(x) step_loss = criterion(y_, y) step_acc = accuracy(y_, y) val_loss += step_loss.data[0] val_step += 1 del (x, y, y_, step_loss) val_acc = accuracy.total_correct / (accuracy.total_sample + 1e-5) val_loss = val_loss / (val_step + 1e-5) print("validate end,log start") #保存最佳的模型 if best_acc < val_acc: weights_name = config.save_weights_path.format("best_acc") torch.save(model.state_dict(), weights_name) best_acc = val_acc #求model的正则化项 l2_reg = 0.0 for param in model.parameters(): l2_reg += torch.norm(param).data[0] #开始记录 with open(csv_path, "a", encoding="utf-8") as file: t = get_ctime() content = "{},{:.6f},{:.4f},{:.6f},{:.4f},{:.6f},{}".format( i, train_loss, train_acc, val_loss, val_acc, l2_reg, t) + "\n" file.write(content) writer.add_scalar("Train/acc", train_acc, i) writer.add_scalar("Train/loss", train_loss, i) writer.add_scalar("Val/acc", val_acc, i) writer.add_scalar("Val/loss", val_loss, i) writer.add_scalar("lr", lr, i) writer.add_scalar("l2_reg", l2_reg, i) print("log end ...") print( "{} epoch end, train loss is {:.6f},train acc is {:.4f},val loss is \ {:.6f},val acc is {:.4f},weight l2 norm is {:.6f}".format( i, train_loss, train_acc, val_loss, val_acc, l2_reg)) del (model) print("{} train end,best_acc is {}...".format(config.dataset, best_acc))
import net,config,os import ImageReader import torch from torchvision import transforms import numpy as np model=net.get_net(classes_num=200,channel_size=2048) model.load_state_dict( torch.load("./weights/cub/resnet50_cub_best_acc.pth"),strict=True) transform=transforms.Compose([transforms.Resize([224,224]), transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406),std=(0.229, 0.224, 0.225))]) model.eval() #model.get_max_pos_count("./utils/ori/101.jpg",transform) #model.get_middle_attention_map("./utils/ori/18.jpg",transform,"./utils/new/res18_middle.jpg") img_list=os.listdir("./utils/ori/") for img in img_list: classes_num=int(img.split(".")[0]) #model.get_attention_map("./utils/ori/"+img,transform,classes_num, # "./utils/new/"+img) model.get_res("./utils/ori/"+img,transform,classes_num, "./utils/new/"+img)
# context ctx = utils.try_gpu() # ctx = mx.cpu() # neural style network pretrained_net = models.vgg19(pretrained=False) # Utlize class VGG + layers(11, 13, 16, 19. The number of conv layer) + # filters(num_kernels, e.g. [64, 128, 256, 512, 512]) to define a net. pretrained_net.load_params( filename="/home/ly/mxnet/models/vgg19-f7134366.params", ctx=ctx) # Utlize get_model_file(name, root) to download the trained model. # If you set pretrained=True, Every time you run the code, it will redownload the trained model. # So, in here set pretrained=False, load trained parameters directly! # content_layers + style_layers is: [25,0,5,10,19,28]. max(content_layers + style_layers) is 28. net = net.get_net(pretrained_net, args.content_layers, args.style_layers) # Use trained model to define our neural-style network. It contains 29 layer, e.g. conv + relu + bn.... # Every layer of neural-style network has owned parameters, so don't initialize. net.collect_params().reset_ctx(ctx) # parameters in ctx. This operate must do, ensure the parameters of network is in appointed ctx. # Otherwise, it maight have a error. # There not define trainer(the first argument is net.collect_params()), so we don't # train this net. We only train the content image. # Therefore, Neural Style's efficient is very high! Time is so short. # style image and content image. # There, we only load a pair of images. one is style image, the other is content image. content_img = image.imread(os.path.join(args.image_root, "tubingen.jpg")) style_img = image.imread(os.path.join(args.image_root, "the_scream.jpg")) # image.imread(): load a image, return NDArray. data format is BGR, w.t. HWC. # imshow