def define_model(is_resnet, is_densenet, is_senet): if is_resnet: original_model = resnet.resnet50(pretrained = True) Encoder = modules.E_resnet(original_model) model = net.model(Encoder, num_features=2048, block_channel = [256, 512, 1024, 2048]) if is_densenet: original_model = densenet.densenet161(pretrained=True) Encoder = modules.E_densenet(original_model) model = net.model(Encoder, num_features=2208, block_channel = [192, 384, 1056, 2208]) if is_senet: original_model = senet.senet154(pretrained='imagenet') Encoder = modules.E_senet(original_model) model = net.model(Encoder, num_features=2048, block_channel = [256, 512, 1024, 2048]) return model
def define_model(target): model = None if target is 'resnet': original_model = resnet.resnet50(pretrained=True) encoder = modules.E_resnet(original_model) model = net.model(encoder, num_features=2048, block_channel=[256, 512, 1024, 2048]) elif target is 'densenet': original_model = densenet.densenet161(pretrained=True) encoder = modules.E_densenet(original_model) model = net.model(encoder, num_features=2208, block_channel=[192, 384, 1056, 2208]) elif target is 'senet': original_model = senet.senet154(pretrained='imagenet') encoder = modules.E_senet(original_model) model = net.model(encoder, num_features=2048, block_channel=[256, 512, 1024, 2048]) return model
def __init__(self, model): with tf.get_default_graph().as_default(): self.x = tf.placeholder( tf.float32, shape=[None, tr.crop_size, tr.crop_size, 3], name='input_images') self.y = net.model(self.x, is_training=False, tag=tr.tag, num_class=tr.num_class) self.saver = tf.train.Saver() self.sess = tf.Session() self.ckpt = tf.train.latest_checkpoint(model) self.saver.restore(self.sess, self.ckpt) print('Restore from {}'.format(self.ckpt))
def __init__(self, envs, gamma, learning_rate, episode, render, temperature, max_episode_length=1000): self.envs = envs self.num_agent = len(self.envs) self.observation_dim = self.envs[0].observation_space.shape[0] self.action_dim = self.envs[0].action_space.n self.gamma = gamma self.learning_rate = learning_rate self.episode = episode self.render = render self.temperature = temperature self.eps = np.finfo(np.float32).eps.item() self.policies = [model(self.observation_dim, self.action_dim) for _ in range(self.num_agent)] self.optimizers = [torch.optim.Adam(self.policies[i].parameters(), lr=self.learning_rate) for i in range(self.num_agent)] self.total_returns = [] self.weight_reward = None self.max_episode_length = max_episode_length
def test_ing(): try: os.makedirs(output_path) except OSError as e: if e.errno != 17: raise with tf.get_default_graph().as_default(): x = tf.placeholder(tf.float32, shape=[None, None, None, 3], name='input_images') y_ = tf.placeholder(tf.float32, shape=[None, None, None, 3], name='label_images') global_step = tf.get_variable('global_step', [], initializer=tf.constant_initializer(0), trainable=False) y = net.model(x, False) mse = tf.reduce_mean(tf.square(y - y_)) psnr = tf.reduce_mean(tf.image.psnr(y, y_, max_val=1.0)) ssim = tf.reduce_mean(tf.image.ssim(y, y_, max_val=1.0)) # variable_averages = tf.train.ExponentialMovingAverage(0.997, global_step) # saver = tf.train.Saver(variable_averages.variables_to_restore()) saver = tf.train.Saver() with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess: ckpt = tf.train.latest_checkpoint(tr.checkpoint_path) # ckpt_state = tf.train.get_checkpoint_state(checkpoint_path) # if ckpt_state is None: # model_path = checkpoint_path # else: # model_path = os.path.join(checkpoint_path, os.path.basename(ckpt_state.model_checkpoint_path)) if ckpt: saver.restore(sess, ckpt) print('Restore from {}'.format(ckpt)) start = time.time() for i in range(100): im, label = data_process.get_test_batch() out, p, s, m = sess.run([y, psnr, ssim, mse], feed_dict={x: im, y_: label}) print(p, s, m) print(time.time() - start) print('end')
def main(): Encoder = modules.E_resnet(resnet.resnet50(pretrained=True)) N = net.model(Encoder, num_features=2048, block_channel=[256, 512, 1024, 2048]) N = torch.nn.DataParallel(N).cuda() N.load_state_dict(torch.load('./models/N')) N_adv = copy.deepcopy(N) N_adv.load_state_dict(torch.load('./models/N_adv')) cudnn.benchmark = True test_loader = loaddata.getTestingData(8) #test for N_adv(x*) test_N_adv(test_loader, N, N_adv, epsilon=0.05, iteration=10) test_N_adv(test_loader, N, N_adv, epsilon=0.1, iteration=10) test_N_adv(test_loader, N, N_adv, epsilon=0.15, iteration=10) test_N_adv(test_loader, N, N_adv, epsilon=0.2, iteration=10)
from utils import * from options.testopt import _get_test_opt import nyudv2_dataloader from resnet import resnet18 import modules import net args = _get_test_opt TestImgLoader = nyudv2_dataloader.getTestingData_NYUDV2( args.batch_size, args.testlist_path, args.root_path) Encoder = modules.E_resnet(resnet18) if args.backbone in ['resnet50']: model = net.model(Encoder, num_features=2048, block_channel=[256, 512, 1024, 2048], refinenet=args.refinenet) elif args.backbone in ['resnet18', 'resnet34']: model = net.model(Encoder, num_features=512, block_channel=[64, 128, 256, 512], refinenet=args.refinenet) model = nn.DataParallel(model).cuda() if args.loadckpt is not None and args.loadckpt.endswith('.pth.tar'): print("loading the specific model in checkpoint_dir: {}".format( args.loadckpt)) state_dict = torch.load(args.loadckpt) model.load_state_dict(state_dict) elif os.path.isdir(args.loadckpt):
import torch #from /home/chase/pytorch-OpCounter/thop/profile.py import profile from profileForBN import profile import numpy as np import tensorflow as tf from net import model def get_flops(model, numExitPoints): input = torch.randn(1, 3, 32, 32) macs, _ = profile(model, inputs=(input, ), verbose=False) # from the THOP git: # "The FLOPs is approximated by multiplying by two." macs = sorted([2 * int(mac) for mac in macs[0:numExitPoints]], key=int) return macs print('FLOPs in BranchyNet:', get_flops(model(), 4))
def test_one(name): try: os.makedirs(output_path) except OSError as e: if e.errno != 17: raise with tf.get_default_graph().as_default(): x = tf.placeholder(tf.float32, shape=[None, None, None, 3], name='input_images') y_ = tf.placeholder(tf.float32, shape=[None, None, None, 3], name='label_images') global_step = tf.get_variable('global_step', [], initializer=tf.constant_initializer(0), trainable=False) y = net.model(x, False) mse = tf.reduce_mean(tf.square(y - y_)) psnr = tf.image.psnr(y, y_, max_val=1.0) ssim = tf.image.ssim(y, y_, max_val=1.0) # variable_averages = tf.train.ExponentialMovingAverage(0.997, global_step) # saver = tf.train.Saver(variable_averages.variables_to_restore()) saver = tf.train.Saver() with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess: ckpt = tf.train.latest_checkpoint(tr.checkpoint_path) # ckpt_state = tf.train.get_checkpoint_state(checkpoint_path) # if ckpt_state is None: # model_path = checkpoint_path # else: # model_path = os.path.join(checkpoint_path, os.path.basename(ckpt_state.model_checkpoint_path)) if ckpt: saver.restore(sess, ckpt) print('Restore from {}'.format(ckpt)) # name = '54.png' im = cv2.imread('./dataset/test/input/' + name)[:, :, ::-1] # print(im) im_net = im / 255 label = cv2.imread('./dataset/test/label/' + name)[:, :, ::-1] label_net = label / 255 # print(im) out, p, s, m = sess.run([y, psnr, ssim, mse], feed_dict={x: [im_net], y_: [label_net]}) # print(label.dtype) # print(out) out_im = out[0] * 255 # print(out_im)0 # out_im = out_im.astype(np.uint8)[:, :, ::-1] out_im = out_im.astype(np.uint8) print(out_im) # cv2.imshow('in', im[:, :, ::-1]) # cv2.imshow('label', label[:, :, ::-1]) # cv2.imshow('out', out_im) # cv2.waitKey(0) sm.imshow(im) sm.imshow(label) sm.imshow(out_im) print(im[0, 0]) print(out_im[0, 0]) p1 = cp.fun(im, out_im, m=255.0, BGR=True) s1 = compare_ssim(im_net, out[0], multichannel=True, full=False) print('tensorflow:', p, s) print('ski:', p1, s1) if save_result: cv2.imwrite('result.png', out_im)
def main(args): dist.init_process_group(backend="nccl") torch.cuda.set_device(args.local_rank) ds = dataset(args.data_file, args.class_file, config) sampler = torch.utils.data.distributed.DistributedSampler(ds, shuffle=True) dl = DataLoader(ds, batch_size=args.batch_size, num_workers=args.num_workers, collate_fn=collate_fn, pin_memory=True, drop_last=False, sampler=sampler) batch_save_path = f"{args.model_dir}/batch_4.pth" epoch_save_path = f"{args.model_dir}/epoch_4.pth" net = model(config, ds.num_classes) if os.path.isfile(batch_save_path): log("载入模型中...", args.log_detail_path, args) try: net.load_state_dict(torch.load(batch_save_path)) log("模型载入完成!", args.log_detail_path, args) except Exception as e: log(f"{e}\n载入模型失败: {batch_save_path}", args.log_detail_path, args) else: log(f"没找到模型: {batch_save_path}", args.log_detail_path, args) config["cuda"] = config["cuda"] and torch.cuda.is_available() if config["cuda"]: # net = torch.nn.DataParallel(net.cuda()) net = torch.nn.parallel.DistributedDataParallel( net.cuda(), device_ids=[args.local_rank]) log("cuda", args.log_detail_path, args) criterion = loss_func(config) optimizer = optim.Adam(net.parameters(), lr=args.lr, weight_decay=args.weight_decay) scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=1, verbose=True, factor=args.lr_decay, threshold=1e-3) schedule_loss = [] net.train() for epoch in range(1, args.epochs + 1): log(f"{'='*30}\n[{epoch}|{args.epochs}]", args.log_detail_path, args) for num_batch, batch_data in enumerate(dl, 1): t = time.time() loss, box_loss, landmark_loss, cls_loss = train_batch( net, batch_data, criterion, optimizer, config["cuda"], args) t = time.time() - t loss, box_loss, landmark_loss, cls_loss = [ reduce_tensor(i).item() for i in [loss, box_loss, landmark_loss, cls_loss] ] msg = f" [{epoch}|{args.epochs}] num_batch:{num_batch}" \ + f" loss:{loss:.4f} box_loss:{box_loss:.4f} landmark_loss:{landmark_loss:.4f} cls_loss:{cls_loss:.4f} time:{t*1000:.1f}ms" log(msg, args.log_detail_path, args) if num_batch % args.num_show == 0: log(msg, args.log_path, args) if args.local_rank == 0: if num_batch % args.num_save == 0: save_model(net, batch_save_path) schedule_loss += [loss] if num_batch % args.num_adjuest_lr == 0: scheduler.step(np.mean(schedule_loss)) schedule_loss = [] if args.local_rank == 0: save_model(net, epoch_save_path)
loss_list = [] val_loss_list = [] mae_list = [] lr_list = [] for epoch in range(num_epochs): epoch += 1 print('running epoch: {} / {}'.format(epoch, num_epochs)) #訓練模式 model.train() total_loss = 0 with tqdm(total=train_epoch_size) as pbar: for inputs, target in trainloader: inputs, target = inputs.to(device), target.to(device) output = model(torch.unsqueeze(inputs, dim=0)) loss = criterion(torch.squeeze(output), target) running_loss = loss.item() total_loss += running_loss*inputs.shape[0] optimizer.zero_grad() # clear gradients for this training step loss.backward() # back propagation, compute gradients optimizer.step() #更新進度條 pbar.set_description('train') pbar.set_postfix( **{ 'running_loss': running_loss, }) pbar.update(1) loss = total_loss/len(trainloader.dataset)
import tensorflow as tf
def main(): os.environ['CUDA_VISIBLE_DEVICES'] = '0' if not tf.gfile.Exists(checkpoint_path): tf.gfile.MakeDirs(checkpoint_path) else: if not whether_resort: tf.gfile.DeleteRecursively(checkpoint_path) tf.gfile.MakeDirs(checkpoint_path) x = tf.placeholder(tf.float32, shape=[None, crop_size, crop_size, 3], name='input_images') y_ = tf.placeholder(tf.float32, shape=[None, num_class], name='input_labels') y = net.model(x, is_training=True, tag=tag, num_class=num_class, regular=regularization_rate) print(y.shape) print(y_.shape) correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y)) acc_sum_train = tf.summary.scalar('accuracy_train', accuracy) acc_sum_val = tf.summary.scalar('accuracy_val', accuracy) cross_sum = tf.summary.scalar('cross_entropy', cross_entropy) global_step = tf.get_variable('global_step', [], initializer=tf.constant_initializer(0), trainable=False) learning_rate = tf.train.exponential_decay(lr, global_step, decay_steps=decay_steps, decay_rate=lr_decay, staircase=True) lr_sum = tf.summary.scalar('learning_rate', learning_rate) train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize( cross_entropy, global_step) update_ops = tf.group(*tf.get_collection(tf.GraphKeys.UPDATE_OPS)) with tf.control_dependencies([train_step, update_ops]): train_op = tf.no_op(name='train') # summary_train_op = tf.summary.merge([acc_sum_train, cross_sum, lr_sum]) summary_val_op = tf.summary.merge([acc_sum_val]) summary_writer = tf.summary.FileWriter(checkpoint_path, tf.get_default_graph()) # saver = tf.train.Saver(tf.global_variables()) saver = tf.train.Saver(max_to_keep=1) init = tf.global_variables_initializer() if pre_train_path is not None: variable_restore_op = slim.assign_from_checkpoint_fn( pre_train_path, slim.get_trainable_variables(), ignore_missing_vars=True) config = tf.ConfigProto() config.gpu_options.per_process_gpu_memory_fraction = 0.9 # GPU setting config.gpu_options.allow_growth = True with tf.Session(config=config) as sess: if whether_resort: print('continue training from previous checkpoint', checkpoint_path) ckpt = tf.train.latest_checkpoint(checkpoint_path) try: current_step = int(ckpt.split('-')[1]) + 1 except: current_step = 0 print(current_step) saver.restore(sess, ckpt) else: sess.run(init) current_step = 0 if pre_train_path is not None: variable_restore_op(sess) data_gene = data_genertor.get_batch(num_workers=number_readers, crop_size=crop_size, batch_size=batch_size, class_num=num_class) start = time.time() train_time = [] for step in range(current_step, max_step + 1): data = next(data_gene) train_star = time.time() _, loss, acc = sess.run([train_op, cross_entropy, accuracy], feed_dict={ x: data[0], y_: data[1] }) train_time.append(time.time() - train_star) if np.isnan(loss): print('loss diverged, stop training') break if step % log_step == 0: avg_time_per_step = (time.time() - start) / log_step avg_traintime_per_step = sum(train_time) / log_step avg_examples_per_second = (log_step * batch_size) / (time.time() - start) train_time = [] start = time.time() print( 'step {:06d}, loss {:.4f}, acc {:.4f}, all:{:.2f}sec/step, train:{:.2f}sec/ste, {:.2f} examples/second' .format(step, loss, acc, avg_time_per_step, avg_traintime_per_step, avg_examples_per_second)) summary_str = sess.run(summary_train_op, feed_dict={ x: data[0], y_: data[1] }) summary_writer.add_summary(summary_str, global_step=step) if step % save_step == 0: saver.save(sess, checkpoint_path + 'model.ckpt', global_step=step) if step % val_step == 0: val_data = data_genertor.get_val_batch(crop_size=crop_size, batch_size=batch_size, class_num=num_class) summary_str, val_acc = sess.run([summary_val_op, accuracy], feed_dict={ x: val_data[0], y_: val_data[1] }) print('after {} step, val_acc is {}'.format(step, val_acc)) summary_writer.add_summary(summary_str, global_step=step)
break ious = jaccard_iou(box[order_index[0:1]], box[order_index]).reshape(-1) k = ious <= iou_threshold order_index = order_index[k] return keep_index def idx2cls(class_txt): with open(class_txt, "r") as f: lines = f.readlines() return [i.strip() for i in lines] priors = None with torch.no_grad(): net = model(config, num_classes, mode="eval").eval() if os.path.isfile(model_path): net.load_state_dict(torch.load(model_path)) else: print(f"没有这个文件:{model_path}") if cuda: net = net.cuda() class_names = idx2cls(class_txt) img_paths = glob(f"{img_dir}/*.jpg") print(len(img_paths)) for img_path in img_paths: img = cv2.imread(img_path) img_cv = cv2.resize(img, dsize=(config["image_size"], config["image_size"])) imshow("i", img, 1)
def validation(): with tf.get_default_graph().as_default(): x = tf.placeholder(tf.float32, shape=[None, tr.crop_size, tr.crop_size, 3], name='input_images') y = net.model(x, is_training=False, tag=tr.tag, num_class=tr.num_class) saver = tf.train.Saver() with tf.Session(config=tf.ConfigProto( allow_soft_placement=True)) as sess: ckpt = tf.train.latest_checkpoint(tr.checkpoint_path) if ckpt: saver.restore(sess, ckpt) print('Restore from {}'.format(ckpt)) images_file = data_genertor.get_images(validate_path) # with open(validate_Jsonpath, 'r') as load_f: # val_dict = json.load(load_f) num = len(images_file) correct_num = 0 #top1 correct_num_top5 = 0 #top5 correct_num_class = 0 # 物种分类 correct_num_assign_class = 0 #指定物种下分类病 start = time.time() for i in range(len(images_file)): # for i in range(1): img = cv2.imread(images_file[i]) if img is None: num -= 1 img = img[:, :, ::-1] # print(img.shape) img_list = [] for _ in range(crop_num): img_list.append( data_genertor.random_crop_resize( img, rate=0.95, crop_size=tr.crop_size)) label = data_genertor.find_id(images_file[i], val_dict, tr.num_class) ys = sess.run([y], feed_dict={x: img_list}) y_ = np.mean(ys, axis=0)[0] flag = [False, False, False, False] label_class = np.argmax(label) y_class = np.argmax(y_) label_info = switchClass(label_class) y_info = switchClass(y_class) y_assign_class = np.argmax( y_[label_info[1]:label_info[2]]) + label_info[1] # print(y_class) # print(y_assign_class) # print(label_class) # print(label_info) if label_class == y_class: # top1分类是否正确 correct_num += 1 flag = [True] * 4 # print(i, 'top1_right') else: y_top5_class = he.nlargest(3, range(len(y_)), y_.__getitem__) if y_class in y_top5_class: # top5 分类是否正确 correct_num_top5 += 1 flag[1] = True if label_info[0] == y_info[0]: # 物种分类是否正确 correct_num_class += 1 flag[2] = True if label_class == y_assign_class: # 指定物种,分类是否正确 correct_num_assign_class += 1 flag[3] = True # print(i, 'top1_wrong, top5_right') print(i, flag) correct_num_top5 = correct_num_top5 + correct_num correct_num_class = correct_num_class + correct_num correct_num_assign_class = correct_num_assign_class + correct_num print( 'total files {}, top1_acc {}, top5_acc {}, class_acc {}, assign_class_acc {}, fps {}' .format(len(images_file), correct_num / num, correct_num_top5 / num, correct_num_class / num, correct_num_assign_class / num, num / (time.time() - start)))
test_x = np.array(test_df) test_x = x_scaler.transform(test_x) test_x = torch.Tensor(test_x) # to tensor model.eval() date_list = [] output_list = [] start = datetime.datetime(2020, 1, 9) end = datetime.datetime(2020, 1, 24) interval = (end - start).days for i in tqdm(range(interval)): with torch.no_grad(): date = start + datetime.timedelta(days=(i + 1)) date = date.strftime('%Y-%m-%d') date_list.append(date) predict = model(torch.unsqueeze(test_x, dim=0)) predict = predict[0][0] test_x = new_x(predict, test_x, n, x_scaler) predict = np.array(predict) output_list.append(predict) test_df = pd.read_csv( r'D:\dataset\lilium_price\test_x\for2021test\for2021test.csv', index_col=None, header=None) # 取去年的最後n天作為今天的初始特徵 test_x = np.array(test_df) test_x = x_scaler.transform(test_x) test_x = torch.Tensor(test_x) # to tensor start = datetime.datetime(2021, 1, 27) end = datetime.datetime(2021, 2, 12) interval = (end - start).days