def __init__(self, args, train_loader, test_loader, writer=None): self.args = args self.model = args.model self.train_loader = train_loader self.test_loader = test_loader self.device = args.device self.recon_kernel_size = self.args.recon_kernel_size self.eps = 0.00316 if self.args.resume: self.global_step = self.args.global_step else: self.global_step = 1 # args.global_step self.log_dir = os.path.join('exp', self.args.dir_save) self.model_dir = os.path.join(self.log_dir, 'model', self.args.model) self.print_freq = self.args.print_freq self.visualize_freq = self.args.visualize_freq self.writer = writer self.prediction = self.args.prediction if not os.path.exists(self.model_dir): os.makedirs(self.model_dir) print('Making the Network') if args.model == 'KPRCAN': self.diffuseNet = model.kprcan.KPRCAN(self.args).to(self.device) self.specularNet = model.kprcan.KPRCAN(self.args).to(self.device) elif args.model == 'KPRCN': self.diffuseNet = model.kprcn.KPRCN(self.args).to(self.device) self.specularNet = model.kprcn.KPRCN(self.args).to(self.device) else: self.diffuseNet = Net(self.args).to(self.device) self.specularNet = Net(self.args).to(self.device)
def __init__(self): self.actions = 4 self.state_space = 37 self.memory = deque(maxlen = 100000) self.randomness = 1 self.least_randomness = 0.01 self.randomness_decay = 0.995 self.gamma = 0.95 self.network = Net() self.qtarget_net = Net() self.optimizer = optim.Adam(self.network.parameters(), lr=3e-4) self.loss_func = nn.MSELoss() self.tau = 1e-3
def test(): # setting model model = Net() # 实例化一个网络 model.cuda() # 送入GPU,利用GPU计算 model = nn.DataParallel(model) model.load_state_dict(torch.load(model_file)) # 加载训练好的模型参数 model.eval() # 设定为评估模式,即计算过程中不要dropout # get data files = random.sample(os.listdir(dataset_dir), N) # 随机获取N个测试图像 imgs = [] # img imgs_data = [] # img data for file in files: img = Image.open(dataset_dir + file) # 打开图像 img_data = getdata.dataTransform(img) # 转换成torch tensor数据 imgs.append(img) # 图像list imgs_data.append(img_data) # tensor list imgs_data = torch.stack(imgs_data) # tensor list合成一个4D tensor # calculation out = model(imgs_data) # 对每个图像进行网络计算 out = F.softmax(out, dim=1) # 输出概率化 out = out.data.cpu().numpy() # 转成numpy数据 # pring results 显示结果 for idx in range(N): plt.figure() if out[idx, 0] > out[idx, 1]: plt.suptitle('cat:{:.1%},dog:{:.1%}'.format(out[idx, 0], out[idx, 1])) else: plt.suptitle('dog:{:.1%},cat:{:.1%}'.format(out[idx, 1], out[idx, 0])) plt.imshow(imgs[idx]) plt.show()
def test(): model = Net() #네트워크실제화 model.cuda() # GPU로 계산 model.load_state_dict(torch.load(model_file)) # 학습된 모델 로딩 model.eval() # eval모델 datafile = DVCD('test', dataset_dir) # dataset 실례화 print('Dataset loaded! length of train set is {0}'.format(len(datafile))) index = np.random.randint(0, datafile.data_size, 1)[0] # random수로 image를 임의 선택함 img = datafile.__getitem__(index) # image 하다 받다 img = img.unsqueeze(0) img = Variable(img).cuda() # Data를 PyTorch의 Variable노드에서 놓고 ,또는 GPU에서 들어가고 시작점을 담임힘. out = model(img) out = F.softmax(out, dim=1) # SoftMax으로 2个개 output값을 [0.0, 1.0]을 시키다,합이1이다. print(out) # output는 개/고양이의 확률 if out[0, 0] > out[0, 1]: # 개<고양이 print('the image is a cat') else: # 개>고양이 print('the image is a dog') img = Image.open(datafile.list_img[index]) # text image open plt.figure('image') # matplotlib로 image show plt.imshow(img) plt.show()
def test(): model = Net() # 实例化一个网络 model.cuda() # 送入GPU,利用GPU计算 model.load_state_dict(torch.load(model_file)) # 加载训练好的模型参数 model.eval() # 设定为评估模式,即计算过程中不要dropout datafile = DVCD('test', dataset_dir) # 实例化一个数据集 print('Dataset loaded! length of train set is {0}'.format(len(datafile))) index = np.random.randint(0, datafile.data_size, 1)[0] # 获取一个随机数,即随机从数据集中获取一个测试图片 img = datafile.__getitem__(index) # 获取一个图像 img = img.unsqueeze( 0) # 因为网络的输入是一个4维Tensor,3维数据,1维样本大小,所以直接获取的图像数据需要增加1个维度 img = Variable(img).cuda() # 将数据放置在PyTorch的Variable节点中,并送入GPU中作为网络计算起点 out = model(img) # 网路前向计算,输出图片属于猫或狗的概率,第一列维猫的概率,第二列为狗的概率 print(out) # 输出该图像属于猫或狗的概率 if out[0, 0] > out[0, 1]: # 猫的概率大于狗 print('the image is a cat') else: # 猫的概率小于狗 print('the image is a dog') img = Image.open(datafile.list_img[index]) # 打开测试的图片 plt.figure('image') # 利用matplotlib库显示图片 plt.imshow(img) plt.show()
def main(): cfg = get_cfg() cfg.merge_from_file( '../output/one_cls_faster_rcnn_R_50_FPN_deconv/config.yaml') cfg.MODEL.WEIGHTS = '../output/one_cls_faster_rcnn_R_50_FPN_deconv/model_0044999.pth' cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.8 img_set_part1 = get_img_dicts( '/tcdata/test_dataset_3w/test_dataset_part1/image') img_set_part2 = get_img_dicts( '/tcdata/test_dataset_3w/test_dataset_part2/image') dataset = img_set_part1 + img_set_part2 if DEBUG: dataset = dataset[:400] metric_net = Net(num_classes=29841, feat_dim=512, cos_layer=True, dropout=0., image_net='resnet50', pretrained=False) checkpoint = torch.load('../output/arcface_R_50/best_14.pt') metric_net.load_state_dict(checkpoint['model_state_dict']) inst_ds = infer_img(cfg, metric_net, dataset, bbox_scale='S') with open('../output/inference/pred_img.json', 'w') as f: json.dump(inst_ds, f)
def __init__(self): self.model_path = './model' self.net = Net(is_training=False) self.size = 96
def train(): datafile = DATA('train', dataset_dir) dataloader = DataLoader(datafile, batch_size=batch_size, shuffle=True, num_workers=workers, drop_last=True) print('-------------train-----------------') print('Length of train set is {0}'.format(len(datafile))) model = Net() model = model.cuda() model = nn.DataParallel(model) model.train() optimizer = torch.optim.Adam(model.parameters(), lr=lr) criterion = torch.nn.CrossEntropyLoss() cnt = 0 count = 0 for epoch in range(nepoch): for img, label in dataloader: img, label = Variable(img).cuda(), Variable(label).cuda() out = model(img) loss = criterion(out, label.squeeze()) loss.backward() optimizer.step() optimizer.zero_grad() cnt += 1 print('Epoch:{0},Frame:{1}, train_loss {2}'.format( epoch, cnt * batch_size, loss / batch_size)) torch.save(model.state_dict(), '{0}/{1}model.pth'.format(model_cp, count)) val(count) count += 1
def eval(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") np.random.seed(seed=46) model = Net() path = 'model.pth.tar' checkpoint = torch.load(path, map_location=torch.device('cpu')) model.load_state_dict(checkpoint) model = model.to(device) model.eval() ious = [] for _ in tqdm(range(1000)): img, label = make_data() img = torch.from_numpy(np.asarray(img, dtype=np.float32)) img = torch.unsqueeze(img, 0) img = torch.unsqueeze(img, 0) img = img.to(device) pred = model.predict(img) ious.append(score_iou(label, pred)) ious = np.asarray(ious, dtype="float") ious = ious[~np.isnan(ious)] # remove true negatives print((ious > 0.7).mean())
def load_gen(): """ Chec the save path for the oldest generation then load all available nets """ save_path = os.path.join(os.getcwd(),"SSwingEnv") if not os.path.exists(save_path): os.makedirs(save_path) try: oldest_gen = max([int(x.split(" ")[1].strip(".pkljg")) for x in os.listdir(save_path)]) except ValueError: oldest_gen = 0 oldest_str = "Generation "+str(oldest_gen)+".pkl" gen_path = os.path.join(save_path, oldest_str) if not os.path.exists(save_path): os.makedirs(save_path) if oldest_gen != 0: nets = [] file = open(gen_path, "rb") while True: try: nets.append(pickle.load(file)) except EOFError: break file.close() nets = np.array(nets) try: nets = np.random.choice(nets, settings.number_nets, False) except: print("Insufficient saved nets. Taking Random Sample") nets = np.random.choice(nets, settings.number_nets, True) else: nets = np.array([Net() for _ in range(settings.number_nets)]) return nets, oldest_gen, save_path
def main(): train_data_reader = DataReader(FLAGS, dtype='train') test_data_reader = DataReader(FLAGS, dtype='test') with tf.Graph().as_default(): net = Net(FLAGS) config = tf.ConfigProto(allow_soft_placement=True) config.gpu_options.allow_growth = True sess = tf.Session(config=config) init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess.run(init_op) saver = tf.train.Saver() if FLAGS.mode == 'train': do_train.run(FLAGS, sess, net, saver, train_data_reader, test_data_reader) else: ckpt = tf.train.get_checkpoint_state(FLAGS.log_path) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) print("Model restored...") if FLAGS.mode == 'test': do_validate.run(sess, net, test_data_reader) else: do_train.run(FLAGS, sess, net, saver, train_data_reader, test_data_reader)
def run(self): # initialization model = Net() model.to(self.device) # loop to get and do the tasks while True: task = self.input_queue.get() # pick a task from the queue if isinstance( task, Predictor._StopToken ): # `_StopToken` is a signal to stop this worker break # decode task, it can be anything you defined. task_id, x = task with torch.no_grad(): # do the task x = x.to(self.device) output = model(x) # put the result into the queue output = output.cpu( ) # copy to cpu before send to another process self.output_queue.put((task_id, output))
def get_pred_vid(): cfg = get_cfg() cfg.merge_from_file( '../output/one_cls_faster_rcnn_R_50_FPN_deconv/config.yaml') cfg.MODEL.WEIGHTS = '../output/one_cls_faster_rcnn_R_50_FPN_deconv/model_0044999.pth' cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.8 vid_set_part1 = get_vid_dicts( '/tcdata/test_dataset_3w/test_dataset_part1/video') vid_set_part2 = get_vid_dicts( '/tcdata/test_dataset_3w/test_dataset_part2/video') dataset = vid_set_part1 + vid_set_part2 if DEBUG: dataset = dataset[:400] metric_net = Net(num_classes=29841, feat_dim=512, cos_layer=True, dropout=0., image_net='resnet50', pretrained=False) checkpoint = torch.load('../output/arcface_R_50/best_14.pt') metric_net.load_state_dict(checkpoint['model_state_dict']) inst_ds = infer_vid(cfg, metric_net, dataset, bbox_scale='S', frames=[40, 120, 200, 280, 360]) return inst_ds
def main(args, experiment_id, trial_id): use_cuda = not args['no_cuda'] and torch.cuda.is_available() torch.set_num_threads(4) torch.manual_seed(args['seed']) device = torch.device("cuda" if use_cuda else "cpu") batch_size = args['batch_size'] hidden_size = args['hidden_size'] train_loader, test_loader = data_loader(batch_size) model = Net(hidden_size=hidden_size).to(device) optimizer = optim.SGD(model.parameters(), lr=args['lr'], momentum=args['momentum']) for epoch in range(1, args['epochs'] + 1): train(args, model, device, train_loader, optimizer, epoch) test_acc = test(args, model, device, test_loader) # report intermediate result nni.report_intermediate_result(test_acc) logger.debug('test accuracy %g', test_acc) logger.debug('Pipe send intermediate result done.') torch.save( model.state_dict(), f'{os.path.join(os.getcwd())}/model_outputs/{experiment_id}-{trial_id}-model.pth' ) test_acc = test(args, model, device, test_loader) # report final result nni.report_final_result(test_acc) logger.debug('Final result is %g', test_acc) output_logger.info(f'{experiment_id}|{trial_id}|{params}|{test_acc:0.6f}') logger.debug('Send final result done.')
def __init__(self, parent=None): """ Constructor @param parent reference to the parent widget @type QWidget """ super(MainWindow, self).__init__(parent) self.setupUi(self) self.setWindowIcon(QIcon('image.ico')) #self.show() self.net = Net() bw1 = self.net.loadWeight('w1-save.csv') bw2 = self.net.loadWeight('w2-save.csv') lw1 = list(bw1) lw2 = list(bw2) weight1 = np.array(lw1) weight2 = np.array(lw2) self.weight1 = weight1.reshape(64, 365) self.weight2 = weight2.reshape(365, 49) self.horizontalSlider.setMinimum(0) self.horizontalSlider.setMaximum(100) self.horizontalSlider.setSingleStep(1) self.horizontalSlider.valueChanged.connect(self.valuechange) self.progressBarPercent.setValue(0) self.progressBarAcc.setValue(0) self.trainning = False self.work = True self.finsh_signal.connect(self.callFinish) self.progress_signal.connect(self.callProgress)
def train(): transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5, ), (0.5, ))]) trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=100, shuffle=True, num_workers=2) testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2) classes = tuple(np.linspace(0, 9, 10, dtype=np.uint8)) net = Net() criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.0005, momentum=0.99, nesterov=True) EPOCHS = 10 for epoch in range(EPOCHS): running_loss = 0.0 for i, (inputs, labels) in enumerate(trainloader, 0): # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() # print statistics running_loss += loss.item() if i % 100 == 99: print('[{:d}, {:5d}] loss: {:.3f}'.format( epoch + 1, i + 1, running_loss / 100)) running_loss = 0.0 print('Finished Training') correct = 0 total = 0 with torch.no_grad(): for (images, labels) in testloader: outputs = net(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy: {:.2f} %%'.format(100 * float(correct / total))) torch.save(net.state_dict(), 'model.pth')
def init_model_and_optimizer(use_attention_improvement=False): model = Net(use_attention_improvement) if args.cuda: model.cuda() optimizer = optim.Adam(model.parameters(), lr=args.lr) return model, optimizer
def main(): args = parser() transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) trainset = Mydataset(root="./train_data", transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True, num_workers=2) testset = Mydataset(root="./test_data", transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=True, num_workers=2) model = Net() summary(model, (3, 64, 64)) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=args.lr) x_epoch_data = [] y_train_loss_data = [] y_test_loss_data = [] y_test_accuracy_data = [] for epoch in range(1, args.epochs + 1): train_loss_per_epoch = train(args, model, trainloader, criterion, optimizer, epoch) test_loss_per_epoch, test_accuracy_per_epoch = test( args, model, testloader, criterion) x_epoch_data.append(epoch) y_train_loss_data.append(train_loss_per_epoch) y_test_loss_data.append(test_loss_per_epoch) y_test_accuracy_data.append(test_accuracy_per_epoch) plt.plot(x_epoch_data, y_train_loss_data, label="train_loss") plt.xlabel("epoch") plt.ylabel("loss") plt.legend(loc="upper right") plt.show() plt.plot(x_epoch_data, y_test_loss_data, label="test_loss") plt.xlabel("epoch") plt.ylabel("loss") plt.legend(loc="upper right") plt.show() plt.plot(x_epoch_data, y_test_accuracy_data, label="test_accuracy") plt.xlabel("epoch") plt.ylabel("accuracy") plt.legend(loc="lower right") plt.show() if (args.save_model): torch.save(model.state_dict(), "perfume_cnn.pt")
def main(): # Training Setting args = parser.parse_args() use_cuda = not args.no_cuda and torch.cuda.is_available() device = torch.device('cuda' if use_cuda else 'cpu') kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {} # Visualize the value of loss function in the train process visual = Visualization() if args.visualization else None # Define dataset train_dataset = CustomDataset('./train.txt') eval_dataset = CustomDataset('./eval.txt') # Define dataloader train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=args.batch_size, shuffle=True, **kwargs) eval_loader = torch.utils.data.DataLoader(dataset=eval_dataset, batch_size=args.eval_batch_size, shuffle=False, **kwargs) # Define nerual network model model = Net().to(device) # Set Optimizier to calculate gradients optimizer = optim.Adadelta(model.parameters(), lr=args.lr) # Scheduler of decreasing learning rate each epoch scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma) # Train neural network for epoch in range(1, args.epochs + 1): train(args, model, device, train_loader, optimizer, epoch) eval_loss = evaluate(args, model, device, eval_loader) scheduler.step() print("R2: ", calculate_R(args, model, device, eval_loader)) # Update image if args.visualization: visual.data_update(epoch, eval_loss) visual.render() # Save model if args.save_model: torch.save(model.state_dict(), "model_record.pt") # Keep showing picture after training model if args.visualization: visual.terminate()
def __init__(self, trained_weights: str, device: str): self.net = Net() self.weights = trained_weights self.device = torch.device('cuda:0' if device == 'cuda' else 'cpu') #self.preprocess = transforms.Compose([ #transforms.Resize((300, 300)), #transforms.ToTensor(), #transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),]) self._initialize()
def main(args): workspace_limits = np.asarray([[-0.724, -0.276], [-0.224, 0.224], [-0.0001, 0.4]]) mode = args.mode config_file = args.config_file cfg = args.cfg obj_data = args.obj_data weights = args.weights robot = Robot(workspace_limits, args.config_file, fixed_obj_coord=True) # Load model ## yolo yolo = YOLO() yolo_net = yolo.load_net(cfg.encode(), weights.encode(), 0) meta = yolo.load_meta(obj_data.encode()) ## cnn cnn_net = Net() device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") cnn_net.to(device) save_path = "vision/classification/model/model.pt" cnn_net.load_state_dict(torch.load(save_path)) cnt = 0 for i in range(12): rgb_img, depth_img = robot.get_camera_data() rgb_img = cv2.cvtColor(rgb_img, cv2.COLOR_RGB2BGR) vis_img = rgb_img.copy() if cnt >= 10: r = yolo.detect(yolo_net, meta, rgb_img) for i in r: x, y, w, h = i[2][0], i[2][1], i[2][2], i[2][3] xmin, ymin, xmax, ymax = yolo.convertBack( float(x), float(y), float(w), float(h)) pt1 = (xmin, ymin) pt2 = (xmax, ymax) cv2.rectangle(vis_img, pt1, pt2, (0, 255, 0), 2) cv2.putText( vis_img, i[0].decode() + " [" + str(round(i[1] * 100, 2)) + "]", (pt1[0], pt1[1] + 20), cv2.FONT_HERSHEY_SIMPLEX, 1, [0, 255, 0], 4) cv2.imshow("img", vis_img) # Classification for i, r0 in enumerate(r): bbox_info = get_bbox(r0) bbox_img, label = get_bbox_img(rgb_img, bbox_info) torch_bbox_img = torch.from_numpy(bbox_img).float().to( device).permute(2, 0, 1).unsqueeze(0) output = cnn_net(torch_bbox_img) _, predicted = torch.max(output, 1) # show result print("category label = {}".format(label_to_text(predicted))) cv2.imshow("bbox img", bbox_img) cv2.waitKey(0) cnt += 1
def main(): # prepare dataset train_adversarial = 1 use_cuda = True epochs = 2000 lr = 0.0005 train_set, test_set = get_datasets(balance_train=True) num_features = train_set[0][0].shape[0] batch_size = 400 test_batch_size = 50 torch.manual_seed(7347) device = 'cuda' if torch.cuda.is_available() else 'cpu' print('using device {0}'.format(device)) train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True) test_loader = torch.utils.data.DataLoader(test_set, batch_size=test_batch_size, shuffle=True) model = Net(activation=nn.LeakyReLU(), num_features=num_features, embed_size=80).to(device) PATH = None # model.load_state_dict(torch.load(PATH, map_location=device), strict=False) reconstruction_optimizer = optim.AdamW(model.autoenc_params(), lr=lr) discriminative_optimizer = optim.AdamW(model.disc_params(), lr=lr * 0.1) encoder_optimizer = optim.AdamW(model.enc_params(), lr=lr * 0.1) if train_adversarial: compute_loss = compute_loss_adversarial_enc optimizer = {'rec': reconstruction_optimizer, 'dis': discriminative_optimizer, 'enc': encoder_optimizer} tmp = [reconstruction_optimizer, discriminative_optimizer, encoder_optimizer] schedulers = [StepLR(x, step_size=70, gamma=0.9) for x in tmp] else: compute_loss = compute_loss_autoenc optimizer = {'rec': reconstruction_optimizer} schedulers = [StepLR(reconstruction_optimizer, step_size=50, gamma=0.9)] for epoch in range(1, epochs + 1): if epoch % 50 == 0: test(model, compute_loss, device, test_loader) train(model, compute_loss, device, train_loader, optimizer, epoch) for scheduler in schedulers: scheduler.step() if epoch % 100 == 0 and epoch: torch.save(model.state_dict(), "mnist_cnn{0}.pt".format(epoch)) print('learning rate: {0}'.format(scheduler.get_lr()))
def __init__(self, args, train_loader, test_loader, writer=None): self.args = args self.model = args.model self.train_loader = train_loader self.test_loader = test_loader self.device = args.device self.recon_kernel_size = self.args.recon_kernel_size self.eps = 0.00316 self.global_step = 0 self.model_dir = os.path.join('model', self.args.model) self.print_freq = self.args.print_freq self.writer = writer if not os.path.exists(self.model_dir): os.makedirs(self.model_dir) print('Making the Network') self.diffuseNet = Net(self.args).to(self.device) self.specularNet = Net(self.args).to(self.device)
def define_model(): # Define the Network Architecture print("Defining the Network Architecture...\n") # create a complete CNN model = Net() # move tensors to GPU if CUDA is available if train_on_gpu: model.cuda() return model
def __init__(self): self.lr = 0.001 # learning rate self.epsilon = 1 # probability with which the agent makes a random action choice instead of following its policy. Encourages exploration self.gamma = 0.95 # discount self.net = Net().to(DEVICE) self.optim = optim.RMSprop(self.net.parameters(), lr=self.lr) self.replaybuffer = list() self.maxbuf = 10000 # max size for replay buffer self.env = gym.make('LunarLander-v2') self.actions = [0,1,2,3]
def __init__(self): self.net = Net(is_training=True) self.model_path = cfg.MODEL_PATH self.size = cfg.TARGET_SIZE self.bias = cfg.BIAS self.classes = cfg.CLASSES
def main(): embed_size = 80 use_embed = True use_cuda = True epochs = 2000 lr = 0.0001 train_set, test_set = get_datasets(label_columns=['posOutcome']) # process with feature extractor # create new test and train sets num_features = train_set[0][0].shape[0] batch_size = 100 test_batch_size = 50 torch.manual_seed(7347) device = 'cuda' if torch.cuda.is_available() else 'cpu' print('using device {0}'.format(device)) train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True) test_loader = torch.utils.data.DataLoader(test_set, batch_size=test_batch_size, shuffle=True) extractor = Net(activation=nn.LeakyReLU(), num_features=num_features, embed_size=embed_size).to(device) extractor_path = 'extractor.pt' extractor.load_state_dict(torch.load(extractor_path, map_location=device), strict=False) model = ClassifierNet( num_features=embed_size if use_embed else num_features, activation=nn.LeakyReLU()).to(device) classifier_optimizer = optim.AdamW(model.parameters(), lr=lr) compute_loss = compute_classifier_loss optimizer = {'opt': classifier_optimizer} schedulers = [StepLR(classifier_optimizer, step_size=50, gamma=0.9)] callback = compute_classifier_loss if use_embed: callback = functools.partial(loss_callback, extractor=extractor) for epoch in range(1, epochs + 1): if epoch % 50 == 0 or epoch == 1: test(model, callback, device, test_loader) train(model, callback, device, train_loader, optimizer, epoch) for scheduler in schedulers: scheduler.step() if epoch % 100 == 0 and epoch: torch.save(model.state_dict(), "classifier{0}.pt".format(epoch)) print('learning rate: {0}'.format(scheduler.get_lr()))
def __init__(self, num_states, num_actions, Double, Dueling, PER): self.num_actions = num_actions # 행동 가짓수(2)를 구함 self.Double = Double self.Dueling = Dueling self.PER = PER # transition을 기억하기 위한 메모리 객체 생성 self.memory = ReplayMemory(CAPACITY) # 신경망 구성 n_in, n_mid, n_out = num_states, 32, num_actions self.main_q_network = Net(n_in, n_mid, n_out, Dueling) # Net 클래스를 사용 self.target_q_network = Net(n_in, n_mid, n_out, Dueling) # Net 클래스를 사용 print(self.main_q_network) # 신경망의 구조를 출력 # 최적화 기법을 선택 self.optimizer = optim.Adam(self.main_q_network.parameters(), lr=0.0001) # PER - TD 오차를 기억하기 위한 메모리 객체 생성 if self.PER == True: self.td_error_memory = TDerrorMemory(CAPACITY)
def main(): model = Net() # Part I - Train model to localize spaceship on images containing spaceship print("Start localization training") device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model.to(device) optimizer = optim.Adam(model.parameters(), eps=1e-07) cudnn.benchmark = True criterion = cal_diou epochs = 40 steps_per_epoch = 3125 batch_size = 64 for epoch in range(0, epochs): adjust_learning_rate(optimizer, epoch) train(model, optimizer, epoch, device, steps_per_epoch, batch_size, criterion) # Part II - Apply transfer learning to train pre-trained model to detect whether spaceship exists print("Start classification training") model.mode = 'classification' criterion = nn.BCELoss() for param in model.convnet.parameters(): param.requires_grad = False for param in model.localizer.parameters(): param.requires_grad = False batch_size = 64 steps_per_epoch = 500 epochs = 2 optimizer = optim.Adam(model.parameters(), eps=1e-07) for epoch in range(epochs): train(model, optimizer, epoch, device, steps_per_epoch, batch_size, criterion, classification=True) # Save model path = F'model.pth.tar' torch.save(model.state_dict(), path)
def main(): net = Net([784,100,50,10]) print("neurons: {}".format(net.neurons)) B, W, acc, count = net.update(noise=0) x = np.array([i for i in range(count)]) y = np.array([acc[i] for i in range(count)]) plt.plot(x,y) plt.xlabel("epoch") plt.ylim(50.0, 100.0) plt.ylabel("accuracy[%]") plt.title("neurons: {}".format(net.neurons)) plt.show()