def run(): print("CUDA is available: {}".format(torch.cuda.is_available())) data_transform = transforms.Compose( [Rescale(250), CenterCrop(224), Normalize(), ToTensor()]) # loader will split datatests into batches witht size defined by batch_size train_loader = initialize_train_loader(data_transform) test_loader = initialize_test_loader(data_transform) model_id = time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime()) # instantiate the neural network net = Net() net.to(device=device) summary(net, (1, 224, 224)) # define the loss function using SmoothL1Loss criterion = nn.SmoothL1Loss() # define the params updating function using Adam optimizer = optim.Adam(net.parameters(), lr=0.001) loss_logger = [] for i in range(1, epochs + 1): model_name = 'model-{}-epoch-{}.pt'.format(model_id, i) # train all data for one epoch train(net, criterion, optimizer, i, train_loader, model_id, loss_logger) # evaludate the accuracy after each epoch evaluate(net, criterion, i, test_loader) # save model after every 5 epochs # https://discuss.pytorch.org/t/loading-a-saved-model-for-continue-training/17244/3 # https://github.com/pytorch/pytorch/issues/2830 # https://pytorch.org/tutorials/beginner/saving_loading_models.html if i % 5 == 1: torch.save( { 'epoch': i, 'model': net.state_dict(), 'optimizer': optimizer.state_dict(), 'loss_logger': loss_logger, }, model_dir + model_name) print("Finished training!") model_name = 'model-{}-final.pt'.format(model_id) torch.save( { 'epoch': epochs, 'model': net.state_dict(), 'optimizer': optimizer.state_dict(), 'loss_logger': loss_logger, }, model_dir + model_name)
def create_model(args): model = Net() if args.start_epoch: path = os.path.join(args.checkpoints_dir, f'checkpoint-{args.start_epoch}.pth') model.load_state_dict(torch.load(path)) else: model.load_pretrained(args.ddr_weights) return model.to(args.device)
def main(args): epochs = args.epochs batch_size = args.batch_size val_frac = args.val_frac lr = args.lr momentum = args.momentum total_it = args.total_it device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') print(device) dataset_train = HomographyDataset(val_frac=val_frac, mode='train') dataset_eval = HomographyDataset(val_frac=val_frac, mode='eval') dataloader_train = DataLoader(dataset_train, batch_size=batch_size, shuffle=True, num_workers=4) dataloader_eval = DataLoader(dataset_eval, batch_size=batch_size, shuffle=False, num_workers=2) net = Net() net.to(device) criterion = nn.MSELoss() optimizer = optim.SGD(net.parameters(), momentum=momentum, lr=lr) log_every = len(dataloader_train) // 2 n_it, lr_it = 0, 0 while n_it < total_it: train(dataloader_train, device, net, criterion, optimizer) n_it += len(dataloader_train) test(dataloader_eval, device, net, criterion, n_it) if lr_it >= 30000: d = optimizer.state_dict() d['param_groups'][0]['lr'] /= 10.0 optimizer.load_state_dict(d) lr_it = 0
def main(): args = get_args() print(args) # set device device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # device = 'cpu' transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) net = Net(device=device, mode=args.target, target_mode=args.target_mode) net = net.eval() net = net.to(device) load_model( net, device, fullpath='trained_models/Net_continuous_trained/checkpoint_274.pth.tar' ) imgs_dir = '/media/yotamg/bd0eccc9-4cd5-414c-b764-c5a7890f9785/Yotam/Real-Images/png' imgs_filelist = [ os.path.join(imgs_dir, img) for img in os.listdir(imgs_dir) if img.endswith('.png') ] for i, img in enumerate(imgs_filelist): # x,x_paths, y, y_paths = data x = plt.imread(img) x = np.expand_dims(x, 0) x = np.transpose(x, (0, 3, 1, 2)) x = x[:, :, 2:-2, 8:-8] x = torch.Tensor(x).to(device) with torch.no_grad(): out = net(x) out = out.detach().cpu().numpy() x = x.detach().cpu().numpy() plt.figure(1) if args.target_mode == 'discrete': out = np.argmax(out, axis=1) out = out[0] # out = np.squeeze(out,0) out = (out - np.min(out)) / (np.max(out) - np.min(out)) ax1 = plt.subplot(1, 3, 1) # x = (x + 1) / 2 ax1.imshow(np.transpose(x[0], (1, 2, 0))) ax3 = plt.subplot(1, 3, 3, sharex=ax1, sharey=ax1) ax3.imshow(out, cmap='jet') # plt.suptitle(label, fontsize="large") plt.show()
def get_model(args): ''' define model ''' model = None if args.model == 'Net': model = Net() elif args.model == 'FCNet': model = FCNet() elif args.model == 'ConvNet': model = ConvNet() else: raise ValueError('The model is not defined!!') print('---Model Information---') print('Net:', model) print('Use GPU:', args.use_cuda) return model.to(args.device)
def main(self): num_of_neurons = 151 num_of_hidden_layers = 2 learning_rate = 0.001 epochs = 10 args = dict() args['num_of_neurons'], args['num_of_hidden_layers'], args[ 'learning_rate'], args[ 'epochs'] = num_of_neurons, num_of_hidden_layers, learning_rate, epochs loss = self.objective(args) print(loss) net = Net(num_of_neurones=num_of_neurons, num_of_hidden_layers=num_of_hidden_layers, num_of_inputs=self.hw_model.inputs, num_of_outputs=self.hw_model.outputs) net = net.to(self.device) print(self.test(net))
class TrainBigramNN(tune.Trainable): def _setup(self, config): print("Loading word vectors...") word2index, word_vecs = process_word_vecs(FAST_TEXT) # Note that the word embeddings are normalized. self.wv = WV(F.normalize(word_vecs), word2index) # wv = WV(word_vecs, word2index) print("Done.") self.corpus_size = config["corpus_size"] bigram_fn_name = "diff" out_bigram_dim = 300 dist_fn_name = "cos_dist" loss_fn_name = "mrl" margin = config["margin"] self.lr = config["lr"] self.num_epochs = config["num_epochs"] self.batch_size = config["batch_size"] self.test_model = True self.test_freq = config["test_freq"] with open(PROCESSED / "train.{}.pkl".format(str(self.corpus_size)), "rb") as f: wiki_train = pickle.load(f) with open(PROCESSED / "valid.pkl", "rb") as f: wiki_valid = pickle.load(f) wiki_combined = wiki_train + wiki_valid self.corpus = Corpus("wiki", wiki_combined, self.wv, filter_stopwords=True) self.model = Net( self.wv.vecs.size(1), BigramEncoder(bigram_fn_name), out_bigram_dim ) self.model.to(device) self.dist_fn = DistanceFunction(dist_fn_name) self.loss_fn = LossFunction(loss_fn_name, margin=margin) self.device = device self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr) torch.manual_seed(config["seed"]) print("Traninig on Wikipedia corpus of size {}".format(self.corpus_size)) def _train(self): result = train( self.wv, self.corpus.ix_sents[: self.corpus_size], self.corpus.sent_lengths[: self.corpus_size], self.corpus.ix_sents[self.corpus_size :], self.corpus.sent_lengths[self.corpus_size :], self.model, self.wv.vecs, self.dist_fn, self.loss_fn, self.optimizer, self.lr, self.num_epochs, self.batch_size, self._iteration, self.test_model, self.test_freq, self.device, ) return result def _save(self, tmp_checkpoint_dir): checkpoint_path = str(Path(tmp_checkpoint_dir) / "model.pth") torch.save(self.model.state_dict(), checkpoint_path) return checkpoint_path def _restore(self, tmp_checkpoint_dir): checkpoint_path = str(Path(tmp_checkpoint_dir) / "model.pth") self.model.load_state_dict(torch.load(checkpoint_path))
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = Net(50, 50, 50) #criterion = nn.MSELoss() criterion = nn.L1Loss(reduction='mean') #criterion = nn.KLDivLoss(reduction='batchmean') #criterion = nn.HingeEmbeddingLoss(reduction='sum') #criterion = nn.CosineEmbeddingLoss() #criterion = myloss.HingeLoss() lr = 0.01 momentum = 0.9 #optimizer optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=momentum) #optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=5e-4) model.to(device) losses_tr = [] losses_ts = [] num_epoches = 100 #训练 for epoch in range(num_epoches): print(f'epoch {epoch}, training....') loss_tr = 0 acc_tr = 0 if epoch % 5 == 0: #每隔5轮 optimizer.param_groups[0]['lr'] *= 0.9 optimizer.zero_grad()
for k, v in weights.items(): k = k.split('.')[1:] k = ".".join(k) state_dict.update({k: v}) # import pdb; pdb.set_trace() refine_net.load_state_dict(state_dict) vgg = VGG16(requires_grad=False) vgg.to(device) if torch.cuda.device_count() > 1 and MULTI_GPU: print("Using {} GPUs...".format(torch.cuda.device_count())) refine_net = nn.DataParallel(refine_net) else: print("GPU ID: {}".format(device)) refine_net = refine_net.to(device) d_loss_fn = nn.BCELoss() d_loss_fn = d_loss_fn.to(device) refine_loss_fn = CustomLoss() refine_loss_fn = refine_loss_fn.to(device) from dataset_cloth import define_dataset tfrecord_path = "/content/uplara_tops_v10_refined_grapy.record" batch_size = 1 trainset, trainset_length = define_dataset(tfrecord_path, batch_size, train=True) valset, valset_length = define_dataset(tfrecord_path, batch_size, train=False) tps_weights_path = "gs://experiments_logs/gmm/TOPS/short_sleeves_high_slope_loss/weights/model_44"
print() #Additional Info when using cuda if device.type == 'cuda': print(torch.cuda.get_device_name(0)) print('Memory Usage:') print('Allocated:', round(torch.cuda.memory_allocated(0) / 1024**3, 1), 'GB') print('Cached: ', round(torch.cuda.memory_cached(0) / 1024**3, 1), 'GB') ## TODO: Once you've define the network, you can instantiate it # one example conv layer has been provided for you from models import Net net = Net() print(net) net = net.to(device) # ## Transform the dataset # # To prepare for training, create a transformed dataset of images and keypoints. # # ### TODO: Define a data transform # # In PyTorch, a convolutional neural network expects a torch image of a consistent size as input. For efficient training, and so your model's loss does not blow up during training, it is also suggested that you normalize the input images and keypoints. The necessary transforms have been defined in `data_load.py` and you **do not** need to modify these; take a look at this file (you'll see the same transforms that were defined and applied in Notebook 1). # # To define the data transform below, use a [composition](http://pytorch.org/tutorials/beginner/data_loading_tutorial.html#compose-transforms) of: # 1. Rescaling and/or cropping the data, such that you are left with a square image (the suggested size is 224x224px) # 2. Normalizing the images and keypoints; turning each RGB image into a grayscale image with a color range of [0, 1] and transforming the given keypoints into a range of [-1, 1] # 3. Turning these images and keypoints into Tensors # # These transformations have been defined in `data_load.py`, but it's up to you to call them and create a `data_transform` below. **This transform will be applied to the training data and, later, the test data**. It will change how you go about displaying these images and keypoints, but these steps are essential for efficient training.
def main(): args = get_args() print(args) # set device device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") test_dir = '/media/yotamg/bd0eccc9-4cd5-414c-b764-c5a7890f9785/Yotam/Sintel/Filtered/rgb' label_dir = '/media/yotamg/bd0eccc9-4cd5-414c-b764-c5a7890f9785/Yotam/Sintel/Filtered/GT' test_filelist = [ os.path.join(test_dir, img) for img in os.listdir(test_dir) if 'alley_1' in img ] test_labels_filelist = [ img.replace(test_dir, label_dir).replace('_1100_maskImg.png', '_GT.dpt') for img in test_filelist ] transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) test_dataset = Dataset(image_filelist=test_filelist, label_filelist=test_labels_filelist, transforms=transform, pickle_name='test.pickle', train=False) test_data_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1, shuffle=True, num_workers=8) net = Net(device=device, mode=args.target, target_mode=args.target_mode) net = net.eval() net = net.to(device) load_model( net, device, fullpath= '/home/yotamg/PycharmProjects/dfd/trained_models/Net_default/checkpoint_76.pth.tar' ) for i, data in enumerate(test_data_loader): # x,x_paths, y, y_paths = data x, x_path, y, y_path = data x = x.to(device) with torch.no_grad(): out = net(x) out = out.detach().cpu().numpy() x = x.detach().cpu().numpy() plt.figure(1) out = np.argmax(out, axis=1) out = np.squeeze(out, 0) out = (out - np.min(out)) / (np.max(out) - np.min(out)) ax1 = plt.subplot(1, 3, 2) ax1.imshow(y[0]) ax2 = plt.subplot(1, 3, 1, sharex=ax1, sharey=ax1) x = (x + 1) / 2 ax2.imshow(np.transpose(x[0], (1, 2, 0))) ax3 = plt.subplot(1, 3, 3, sharex=ax1, sharey=ax1) ax3.imshow(out) # plt.suptitle(label, fontsize="large") plt.show()
def main(): # file_structure = check_directories() # if file_structure == -1: # print('\nERROR: Directories can\'t be created, error thrown') # return -1 # else: # print('\nDirectories created successfully...\nLaunching camera module...') net = Net() device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # # dev = torch.cuda.is_available() # # Assume that we are on a CUDA machine, then this should print a CUDA device: # # print(dev) net.to(device) net.load_state_dict(torch.load('saved_models/keypoints_model_2.pt')) ## print out your net and prepare it for testing (uncomment the line below) net.eval() # net.load_state_dict(torch.load('saved_models/keypoints_model_2.pt')) # Fire camera & launch streams # pyrs.start() serv = pyrs.Service() # cam = pyrs.Device(device_id = 0, streams = [pyrs.stream.ColorStream(fps=60), # pyrs.stream.DepthStream(fps=60), # pyrs.stream.CADStream(fps=60), # pyrs.stream.DACStream(fps=60)]) cam = serv.Device( device_id=0, streams=[ pyrs.stream.ColorStream(fps=60), # pyrs.stream.DepthStream(fps=60), # pyrs.stream.CADStream(fps=60), # pyrs.stream.DACStream(fps=60) ]) # scale = cam.depth_scale # Some important variables flag_save_frames = False # file_num = 0 # cap = cv2.VideoCapture(0) # Define the codec and create VideoWriter object # fourcc = cv2.cv.CV_FOURCC(*'DIVX') # out = cv2.VideoWriter('output.avi',fourcc, 20.0, (640,480)) # out = cv2.VideoWriter('./output.avi', -1, 20.0, (640, 480)) # Define the codec and create VideoWriter object.The output is stored in 'outpy.avi' file. out = cv2.VideoWriter('output_4.avi', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 20, (640, 480)) # Start fetching Buffer print('Starting Buffer...') i = 1000 while (i): cam.wait_for_frames() image_1 = cam.color[:, :, ::-1] gray_1 = cv2.cvtColor(image_1, cv2.COLOR_RGB2GRAY) face_cascade = cv2.CascadeClassifier( 'detector_architectures/haarcascade_frontalface_default.xml') faces_1 = face_cascade.detectMultiScale(gray_1, 1.1, 5) # make a copy of the original image to plot detections on image_with_detections_1 = image_1.copy() # loop over the detected faces, mark the image where each face is found for (x, y, w, h) in faces_1: # face = gray_1 roi = gray_1[y:y + int(h), x:x + int(w)] org_shape = roi.shape roi = roi / 255.0 roi = cv2.resize(roi, (224, 224)) # image_plot = np.copy(roi) roi = roi.reshape(roi.shape[0], roi.shape[1], 1) roi = np.transpose(roi, (2, 0, 1)) roi = torch.from_numpy(roi) roi = Variable(roi) roi = roi.type(torch.cuda.FloatTensor) roi = roi.unsqueeze(0) predicted_key_pts = net(roi) predicted_key_pts = predicted_key_pts.view(68, -1) predicted_key_pts = predicted_key_pts.data predicted_key_pts = predicted_key_pts.cpu().numpy() predicted_key_pts = predicted_key_pts * 50.0 + 100 predicted_key_pts[:, 0] = predicted_key_pts[:, 0] * org_shape[ 0] / 224 + x predicted_key_pts[:, 1] = predicted_key_pts[:, 1] * org_shape[ 1] / 224 + y # cv2.rectangle(image_with_detections_1, (x, y), (x + w, y + h), (0, 0, 255), 3) for (x_point, y_point) in zip(predicted_key_pts[:, 0], predicted_key_pts[:, 1]): cv2.circle(image_with_detections_1, (x_point, y_point), 3, (0, 255, 0), -1) # current_color = cam.color[:, :, ::-1] # current_depth = cam.depth * scale # current_cad = cam.cad[:, :, ::-1] # current_dac = cam.dac * scale out.write(image_with_detections_1) cv2.imshow('Color', image_with_detections_1) # cv2.imshow('Depth', current_depth) # cv2.imshow('CAD', current_cad) # cv2.imshow('DAC', current_dac) # if flag_save_frames: # num = format(file_num, '08') # cv2.imwrite('./data/depth/' + str(num) + '.png', cam.depth) # cv2.imwrite('./data/color/' + str(num) + '.png', current_color) # cv2.imwrite('./data/dac/' + str(num) + '.png', cam.dac) # cv2.imwrite('./data/cad/' + str(num) + '.png', current_cad) # file_num += 1 i = i - 1 k = cv2.waitKey(1) if k == ord('q'): print('Q Pressed...\nEnding execution') break if k == ord('f'): if flag_save_frames: print('F Pressed...\nStopped fetching frames...') flag_save_frames = False else: print('F Pressed...\nStarted fetching frames...') flag_save_frames = True cam.stop() # pyrs.stop() out.release() serv.stop() return 0
def train(options): exp_name = options['exp_name'] batch_size = options['batch_size'] use_pca = options['use_pca'] model_type = options['model_type'] loss_fn = options['loss_fn'] optim = options['optim'] use_scheduler = options['use_scheduler'] lr = options['lr'] epochs = options['epochs'] pca_var_hold = options['pca_var_hold'] debug_mode = options['debug_mode'] if os.path.exists(exp_name): shutil.rmtree(exp_name) time.sleep(1) writer = SummaryWriter(exp_name,flush_secs=1) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") X = os.listdir('hilbert_data') X_train = X[:int(0.8*len(X))] X_test = X[int(0.8*len(X)):] # X = np.load('bined_x.npy') # y = np.load('bined_y.npy') # X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # if use_pca and 'Raw' in exp_name: # scaler = PCA(pca_var_hold) # scaler.fit(X_train) # X_train = scaler.transform(X_train) # X_test = scaler.transform(X_test) # needed_dim = X_train.shape[1] dataset_train = HIL_MOOD(X_train, model_type=model_type,data_type='train',debug_mode=debug_mode) train_loader = DataLoader(dataset=dataset_train, batch_size=batch_size, shuffle=True) dataset_val = HIL_MOOD(X_test, model_type=model_type,data_type='val') valid_loader = DataLoader(dataset=dataset_val, batch_size=batch_size, shuffle=False) model = Net() model.to(device) if optim == None: print('you need to specify an optimizer') exit() elif optim == 'adam': optimizer = torch.optim.Adam( model.parameters(), lr=lr) elif optim == 'sgd': optimizer = torch.optim.SGD( model.parameters(), lr=lr,momentum=0.9) if use_scheduler: scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min',verbose=True,threshold=0.0001,patience = 10) if loss_fn == None: print('you need to specify an optimizer') exit() else: if loss_fn == 'mse': loss_fn = torch.nn.MSELoss() elif loss_fn == 'cross_entropy': loss_fn = torch.nn.CrossEntropyLoss() mean_train_losses = [] mean_valid_losses = [] valid_acc_list = [] best = 0 #small number for acc big number for loss to save a model for epoch in range(epochs): model.train() train_losses = [] valid_losses = [] for i, (images, labels) in enumerate(train_loader): if images.shape[0] != batch_size: continue images = images.to(device) labels = labels.to(device) optimizer.zero_grad() # print(images.shape) outputs = model(images) # print(images.shape) # print(outputs.shape) # print(labels.shape) # print(i) loss =loss_fn(outputs,labels) # print('loss: ',loss.item()) writer.add_scalar('Loss/train', loss.item(), len(train_loader)*epoch+i) loss.backward() optimizer.step() train_losses.append(loss.item()) del outputs # if (i * batch_size) % (batch_size * 100) == 0: # print(f'{i * batch_size} / 50000') model.eval() correct_5_2 = 0 correct_5_1 = 0 total_loss = 0 total = 0 accsat =[0.5,0.05,0.005] accs = np.zeros(len(accsat)) # corrs = np.zeros(len(accsat)) correct_array = np.zeros(len(accsat)) with torch.no_grad(): for i, (images, labels) in enumerate(valid_loader): images = images.to(device) labels = labels.to(device) outputs = model(images) loss = loss_fn(outputs, labels) for i in range(len(accsat)): correct_array[i] += accat(outputs,labels,thresh=accsat[i]) # total_loss += loss.item() total += labels.size(0) valid_losses.append(loss.item()) mean_train_losses.append(np.mean(train_losses)) mean_valid_losses.append(np.mean(valid_losses)) # scheduler.step(np.mean(valid_losses)) for i in range(len(accsat)): accs[i] = 100*correct_array[i]/total writer.add_scalar('Acc/val_@'+str(accsat[i]), accs[i], epoch) if np.mean(valid_losses) < best: best = np.mean(valid_losses) torch.save(model.state_dict(),os.path.join(os.getcwd(),'models','meh.pth')) writer.add_scalar('Loss/val', np.mean(valid_losses), epoch) # valid_acc_list.append(accuracy) if epoch ==epochs-1: print('epoch : {}, train loss : {:.4f}, valid loss : {:.4f}, [email protected] : {:.4f}'\ .format(epoch+1, np.mean(train_losses), np.mean(valid_losses), accsat[1]))
def train_net(args): torch.manual_seed(7) np.random.seed(7) checkpoint = args.checkpoint start_epoch = 0 best_acc = 0 writer = SummaryWriter() epochs_since_improvement = 0 # Initialize / load checkpoint if checkpoint is None: # model = ImgClsModel() model = Net() model = nn.DataParallel(model) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) else: checkpoint = torch.load(checkpoint) start_epoch = checkpoint['epoch'] + 1 epochs_since_improvement = checkpoint['epochs_since_improvement'] model = checkpoint['model'] optimizer = checkpoint['optimizer'] logger = get_logger() # Move to GPU, if available model = model.to(device) # Loss function criterion = nn.BCELoss() logger.info('init dataset...') # Custom dataloaders dataset = YooChooseBinaryDataset(root='data/') #dataset = dataset.shuffle() train_dataset = dataset[:800000] val_dataset = dataset[800000:900000] test_dataset = dataset[900000:] len(train_dataset), len(val_dataset), len(test_dataset) train_loader = DataLoader(train_dataset, batch_size=batch_size) val_loader = DataLoader(val_dataset, batch_size=batch_size) test_loader = DataLoader(test_dataset, batch_size=batch_size) # Epochs for epoch in range(start_epoch, args.end_epoch): # One epoch's training train_loss = train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch, logger=logger) writer.add_scalar('model/train_loss', train_loss, epoch) # One epoch's validation train_acc = evaluate(train_loader, model) val_acc = evaluate(val_loader, model) test_acc = evaluate(test_loader, model) print( 'Epoch: {:03d}, Loss: {:.5f}, Train Auc: {:.5f}, Val Auc: {:.5f}, Test Auc: {:.5f}' .format(epoch, train_loss, train_acc, val_acc, test_acc)) writer.add_scalar('model/train_acc', train_acc, epoch) writer.add_scalar('model/val_acc', val_acc, epoch) writer.add_scalar('model/test_acc', test_acc, epoch) # Check if there was an improvement is_best = val_acc > best_acc best_acc = max(val_acc, best_acc) if not is_best: epochs_since_improvement += 1 print("\nEpochs since last improvement: %d\n" % (epochs_since_improvement, )) else: epochs_since_improvement = 0 # Save checkpoint save_checkpoint(epoch, epochs_since_improvement, model, optimizer, best_acc, is_best)
def create_model(args): model = Net() model.load_pretrained(args.weights) return model.to(args.device)
def train_net(args): torch.manual_seed(7) np.random.seed(7) checkpoint = args.checkpoint start_epcoch = 0 best_acc = 0 writer = SummaryWriter() epoch_since_improvement = 0 if checkpoint is None: model = Net() # model = nn.DataParallel(model) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) else: checkpoint = torch.load(checkpoint) start_epcoch = checkpoint['epoch'] + 1 epoch_since_improvement = checkpoint['epoch_since_improvement'] model = checkpoint['model'] optimizer = checkpoint['optimizer'] logger = get_logger() model = model.to(device) criterion = nn.BCELoss() logger.info('init dataset...') dataset = YoochooseBinaryDataset(root='data/') dataset = dataset.shuffle() train_dataset = dataset[:800000] val_dataset = dataset[800000:900000] test_dataset = dataset[900000:] train_loader = DataLoader(train_dataset, batch_size=batch_size) val_loader = DataLoader(val_dataset, batch_size=batch_size) test_loader = DataLoader(test_dataset, batch_size=batch_size) for epoch in range(start_epcoch, args.end_epoch): train_loss = train(train_loader=train_loader, model=model, criterion=criterion, optimizer=optimizer, epoch=epoch, logger=logger) writer.add_scalar('model/train_loss', train_loss, epoch) train_acc = evalute(train_loader, model) val_acc = evalute(val_loader, model) test_acc = evalute(test_loader, model) # print('epoch:{:03d},loss:{:.5f},train acc:{:.5f},val acc:{:.5f},test acc:{:.5f}'.format(epoch,train_acc,val_acc,test_acc)) print( 'Epoch: {:03d}, Loss: {:.5f}, Train Auc: {:.5f}, Val Auc: {:.5f}, Test Auc: {:.5f}' .format(epoch, train_loss, train_acc, val_acc, test_acc)) writer.add_scalar('model/train_acc', train_acc, epoch) writer.add_scalar('model/val_acc', val_acc, epoch) writer.add_scalar('model/test_acc', test_acc, epoch) is_best = val_acc > best_acc best_acc = max(val_acc, best_acc) if not is_best: epoch_since_improvement += 1 print('\n epcoch since last improvement:%d\n' % (epoch_since_improvement)) else: epoch_since_improvement = 0 save_checkpoint(epoch, epoch_since_improvement, model, optimizer, best_acc, is_best)
# forward + backward + optimize outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() # print statistics running_loss += loss.item() if i % 500 == 499: # print every 2000 mini-batches print('[Epoch: %d, Batch: %5d] Loss: %.3f' % (epoch + 1, i + 1, running_loss / 500)) running_loss = 0.0 net.eval() net.to('cpu') with torch.no_grad(): correct = 0 total = 0 for data in testloader: images, labels = data outputs = net(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() accuracy = (correct / total) * 100 print('Test Accuracy of the network on the 10000 test images: {} %'.format( accuracy)) if accuracy > 85:
shuffle=True, num_workers=0) # 创建测试集 test_dataset = MyFacialKeyPointsDataset( csv_file='./data/test_frames_keypoints.csv', root_dir='./data/test', transform=data_transform) # 批量加载测试数据 test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True, num_workers=0) # 定义网络 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") net = Net() net.to(device) def net_sample_output(): """ 在一个批次测试图像上测试模型 :return: """ for i, sample in enumerate(test_loader): images, key_pts = sample['image'], sample['keypoints'] images = images.type(torch.FloatTensor) # 前向传播 output_pts = net(images) # 将输出reshpe为68个坐标点 output_pts = output_pts.view(output_pts.size()[0], 68, -1) # 测试一张
def train(data_folder, output_folder, es_patience, epochs, TTA): device = torch.device('cuda' if torch.cuda.is_available() else "cpu") print("使用デバイス:", device) train = pd.read_csv(data_folder + '/train.csv') test = pd.read_csv(data_folder + '/test.csv') arch = EfficientNet.from_pretrained('efficientnet-b1') #モデル meta_features = list(train.columns) meta_features.remove('image_name') meta_features.remove('target') meta_features.remove('fold') #パラメータ各種 oof = np.zeros((len(train), 1)) preds = torch.zeros((len(test), 1), dtype=torch.float32, device=device) skf = KFold(n_splits=5, shuffle=True, random_state=47) #=========================== # ループスタート #=========================== for fold, (idxT, idxV) in enumerate(skf.split(np.arange(15)), 1): print('=' * 20, 'Fold', fold, '=' * 20) #kfold train_idx = train.loc[train['fold'].isin(idxT)].index val_idx = train.loc[train['fold'].isin(idxV)].index #学習パラメータ model_path = f'/model_{fold}.pth' best_val = 0 patience = es_patience model = Net(arch=arch, n_meta_features=len(meta_features)) model = model.to(device) #optimizer optim = torch.optim.Adam(model.parameters(), lr=0.001) #scheduler scheduler = ReduceLROnPlateau(optimizer=optim, mode='max', patience=1, verbose=True, factor=0.2) criterion = nn.BCEWithLogitsLoss() trainDataset = MelanomaDataset( df=train.iloc[train_idx].reset_index(drop=True), imfolder=data_folder + '/train', train=True, transforms=train_transform, meta_features=meta_features) valDataset = MelanomaDataset( df=train.iloc[val_idx].reset_index(drop=True), imfolder=data_folder + '/train', train=True, transforms=test_transform, meta_features=meta_features) testDataset = MelanomaDataset(df=test, imfolder=data_folder + '/test', train=False, transforms=test_transform, meta_features=meta_features) train_loader = DataLoader(dataset=trainDataset, batch_size=64, shuffle=True, num_workers=2) val_loader = DataLoader(dataset=valDataset, batch_size=16, shuffle=False, num_workers=2) test_loader = DataLoader(dataset=testDataset, batch_size=16, shuffle=False, num_workers=2) #===================== # epochs #===================== for epoch in range(epochs): start_time = time.time() correct = 0 epoch_loss = 0 #train_loop model.train() for x, y in train_loader: x[0] = torch.tensor(x[0], device=device, dtype=torch.float32) x[1] = torch.tensor(x[1], device=device, dtype=torch.float32) y = torch.tensor(y, device=device, dtype=torch.float32) optim.zero_grad() z = model(x) loss = criterion(z, y.unsqueeze(1)) loss.backward() optim.step() pred = torch.round(torch.sigmoid(z)) correct += (pred.cpu() == y.cpu().unsqueeze(1)).sum().item() epoch_loss += loss.item() train_acc = correct / len(train_idx) model.eval() val_preds = torch.zeros((len(val_idx), 1), dtype=torch.float32, device=device) with torch.no_grad(): #validation_loop for j, (x_val, y_val) in enumerate(val_loader): x_val[0] = torch.tensor(x_val[0], device=device, dtype=torch.float32) x_val[1] = torch.tensor(x_val[1], device=device, dtype=torch.float32) y_val = torch.tensor(y_val, device=device, dtype=torch.float32) z_val = model(x_val) val_pred = torch.sigmoid(z_val) val_preds[j * val_loader.batch_size:j * val_loader.batch_size + x_val[0].shape[0]] = val_pred val_acc = accuracy_score(train.iloc[val_idx]['target'].values, torch.round(val_preds.cpu())) val_roc = roc_auc_score(train.iloc[val_idx]['target'].values, val_preds.cpu()) print( 'Epoch{:03}: | Loss:{:.3f} | Train acc:{:.3f} | Val acc:{:.3f} | Val roc_auc:{:.3f} | Training time:{}' .format( epoch + 1, epoch_loss, train_acc, val_acc, val_roc, str( datetime.timedelta(seconds=time.time() - start_time))[:7])) scheduler.step(val_roc) if val_roc >= best_val: best_val = val_roc patience = es_patience torch.save(model, output_folder + model_path) else: patience -= 1 if patience == 0: print('Early stopping. Best Val roc_auc:{:.3f}'.format( best_val)) break model = torch.load(output_folder + model_path) model.eval() val_preds = torch.zeros((len(val_idx), 1), dtype=torch.float32, device=device) #evaluation loop with torch.no_grad(): for j, (x_val, y_val) in enumerate(val_loader): x_val[0] = torch.tensor(x_val[0], device=device, dtype=torch.float32) x_val[1] = torch.tensor(x_val[1], device=device, dtype=torch.float32) y_val = torch.tensor(y_val, device=device, dtype=torch.float32) z_val = model(x_val) val_pred = torch.sigmoid(z_val) val_preds[j * val_loader.batch_size:j * val_loader.batch_size + x_val[0].shape[0]] = val_pred oof[val_idx] = val_preds.cpu().numpy() for _ in range(TTA): for i, x_test in enumerate(test_loader): x_test[0] = torch.tensor(x_test[0], device=device, dtype=torch.float32) x_test[1] = torch.tensor(x_test[1], device=device, dtype=torch.float32) z_test = model(x_test) z_test = torch.sigmoid(z_test) preds[i * test_loader.batch_size:i * test_loader.batch_size + x_test[0].shape[0]] += z_test preds /= TTA preds /= skf.n_splits return preds, oof
# print (hyperopt.pyll.stochastic.sample(space)) # minimize the objective over the space trials = Trials() best = fmin(ag.objective, space, algo=tpe.suggest, max_evals=10, trials=trials) print(best) print (trials.results) print (trials.losses()) print(space_eval(space, best)) num_of_neurons_list = [a['misc']['vals']['num_of_neurons'][0] for a in trials.trials] num_of_hidden_layers_list = [a['misc']['vals']['num_of_hidden_layers'][0] for a in trials.trials] num_of_epochs = [a['misc']['vals']['epochs'][0] for a in trials.trials] learning_rate_list = [a['misc']['vals']['learning_rate'][0] for a in trials.trials] for i, trial in enumerate(trials.losses()): print ("Experiment {:2}: Hidden Layers: {:3}, Neurons: {:3}, Learing Rate: {:3}, Epochs: {:3}, Loss: {:1.5}". format(i, num_of_hidden_layers_list[i], num_of_neurons_list[i],learning_rate_choices[learning_rate_list[i]],num_of_epochs[i], trial)) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter3D(num_of_neurons_list, num_of_hidden_layers_list, trials.losses()) ax.set_xlabel('#Neurons') ax.set_ylabel('#Layers') ax.set_zlabel('Loss') plt.show() best_list.append(best) print (best_list) net = Net(num_of_neurones=int(best['num_of_neurons']), num_of_hidden_layers=int(best['num_of_hidden_layers']), num_of_inputs=ag.hw_model.inputs, num_of_outputs=ag.hw_model.outputs) net = net.to(ag.device) print (ag.test(net))