def main(args): if args.adapt_setting == 'svhn2mnist': target_dataset = ImageClassdata(txt_file=args.tar_list, root_dir=args.tar_root, img_type=args.img_type, transform=transforms.Compose([ transforms.Resize(28), transforms.ToTensor(), ])) elif args.adapt_setting == 'mnist2usps': target_dataset = ImageClassdata(txt_file=args.tar_list, root_dir=args.tar_root, img_type=args.img_type, transform=transforms.Compose([ transforms.Resize(28), transforms.ToTensor(), ])) else: raise NotImplementedError dataloader = DataLoader(target_dataset, batch_size=args.batch_size, shuffle=False, drop_last=False, num_workers=1, pin_memory=True) model = Net().to(device) model.load_state_dict(torch.load(args.MODEL_FILE)) model.eval() total_accuracy = 0 with torch.no_grad(): for x, y_true in tqdm(dataloader, leave=False): x, y_true = x.to(device), y_true.to(device) y_pred = model(x) total_accuracy += (y_pred.max(1)[1] == y_true).float().mean().item() mean_accuracy = total_accuracy / len(dataloader) print(f'Accuracy on target data: {mean_accuracy:.4f}')
def get_prediction(image_bytes): model = Net() model.load_state_dict(torch.load('model.pt', map_location='cpu'), strict=False) model.eval() tensor = transform_image(image_bytes=image_bytes) outputs = F.softmax(model(tensor), dim=1) top_p, top_class = outputs.topk(1, dim=1) return top_p, top_class
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(): model = Net() model.load_state_dict(torch.load(checkpoint_path)) model.eval() tar = prep_data() output = model(Variable(tar)) res = output.cpu().data.numpy() res_ = np.squeeze(res) num = np.argwhere(res_ == np.max(res_)) print(int(num))
def main(): # load in a haar cascade classifier for detecting frontal faces face_cascade = cv2.CascadeClassifier( 'detector_architectures/haarcascade_frontalface_default.xml') model = Net() model.load_state_dict(torch.load('./saved_models/keypoints_model_1.pt')) model.eval() show_webcam(model, face_cascade)
def load_model(dir): """ Loads models :param dir: directory to load the models from :return: a list of all the models in the directory """ networks = [] for filename in os.listdir(dir): net = Net() net.load_state_dict(torch.load(os.path.join(dir, filename))) net.train(True) net.cuda() networks.append(net) return networks
def main(): # models net = Net(base=opt.base) net = nn.DataParallel(net).cuda() sdict = torch.load('./net.pth') net.load_state_dict(sdict) val_loader = torch.utils.data.DataLoader(ImageFiles(opt.img_dir, opt.prior_dir, size=256, mean=mean, std=std), batch_size=opt.b, shuffle=False, num_workers=4, pin_memory=True) validate(val_loader, net, 'results', opt.gt_dir)
def load_model(): """ Get the newest checkpoint (best one) in the checkpoint directory For more detail about torch's load/save progress, see: https://stackoverflow.com/questions/42703500/best-way-to-save-a-trained-model-in-pytorch :param filename: :return: model (with training progress, can be used for either inference or further training) """ model = Net(int(args['in_size']), int(args['hidden_size']), int(args['out_size']), int(args['nb_lstm_layers']), int(args['batch_size']), int(bool(args['bidirectional']))) newest_dir = [ xxx for xxx in subprocess.check_output("ls -t checkpoints/".split( " ")).decode("utf8").strip().split("\n") if os.path.isdir("checkpoints/" + xxx) ][0] # | head -n 1"]) print(newest_dir) newest_pth = [ "checkpoints/{}/{}".format(newest_dir, xxx) for xxx in subprocess.check_output("ls -t checkpoints/{}/".format( newest_dir).split(" ")).decode("utf8").strip().split("\n") if os.path.isfile("checkpoints/{}/{}".format(newest_dir, xxx)) ] list_file = { get_epoch_from_filename(filename)[0]: get_epoch_from_filename(filename)[1] for filename in newest_pth } best_epoch = max(list_file.keys()) best_loss = list_file[best_epoch] print(best_epoch, best_loss) state = torch.load("checkpoints/{}/checkpoint_epoch{}_{}".format( newest_dir, best_epoch, best_loss), map_location='cpu') model.load_state_dict(state['state_dict']) optimizer = optim.RMSprop(model.parameters()) optimizer.load_state_dict(state['optimizer']) return model, optimizer
def main(): use_cuda = torch.cuda.is_available() and args.cuda device = torch.device('cuda' if use_cuda else 'cpu') print('Loading model ...') model = Net(device) if args.load is not None: print('Loading checkpoint ...') model.load_state_dict(torch.load(args.load)) if use_cuda: model.cuda() print('Loading data ...') data_loader = get_data_loader(args.data_root, args.stage, args.batch_size) print('Preparation done') optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, betas=(0.9, 0.999)) criterion = nn.CrossEntropyLoss() if args.stage == 'train': train(model, data_loader, optimizer, criterion)
def main(args): X_target, y_target = preprocess_test() target_dataset = torch.utils.data.TensorDataset(X_target, y_target) target_loader = DataLoader(target_dataset, batch_size=args.batch_size, shuffle=False, num_workers=1, pin_memory=True) model = Net().to(device) model.load_state_dict(torch.load(args.MODEL_FILE)) model.eval() total_accuracy = 0 with torch.no_grad(): for x, y_true in tqdm(target_loader, leave=False): x, y_true = x.to(device), y_true.to(device) y_pred = model(x) total_accuracy += (y_pred.max(1)[1] == y_true).float().mean().item() mean_accuracy = total_accuracy / len(target_loader) print(f'Accuracy on target data: {mean_accuracy:.4f}')
def pred_homography(batch, patch_size, model_file='homography_model.pytorch', scale=32): device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') batch = normalize_batch(batch).to(device) net = Net() net.load_state_dict(torch.load(model_file)) net.eval().to(device) with torch.no_grad(): output = net(batch).detach().cpu().numpy() * scale mean_shift = np.mean(output, axis=0) pts1 = np.float32( [0, 0, patch_size, 0, patch_size, patch_size, 0, patch_size]).reshape(-1, 1, 2) pts2 = mean_shift.reshape(-1, 1, 2) + pts1 h = np.linalg.inv(cv2.findHomography(pts1, pts2)[0]) return h
def main(args): dataset = MNISTM(train=False) dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, drop_last=False, num_workers=1, pin_memory=True) model = Net().to(device) model.load_state_dict(torch.load(args.MODEL_FILE)) model.eval() total_accuracy = 0 with torch.no_grad(): for x, y_true in tqdm(dataloader, leave=False): x, y_true = x.to(device), y_true.to(device) y_pred = model(x) total_accuracy += ( y_pred.max(1)[1] == y_true).float().mean().item() mean_accuracy = total_accuracy / len(dataloader) print(f'Accuracy on target data: {mean_accuracy:.4f}')
class dueling_agent: def __init__(self, env, args): # define some important self.env = env self.args = args # trying to define the network self.net = Net(self.env.action_space.n) self.target_net = Net(self.env.action_space.n) # make sure the target net has the same weights as the network self.target_net.load_state_dict(self.net.state_dict()) if self.args.cuda: self.net.cuda() self.target_net.cuda() # define the optimizer self.optimizer = torch.optim.Adam(self.net.parameters(), lr=self.args.lr) # define the replay memory self.buffer = replay_memory(self.args.buffer_size) # define the linear schedule of the exploration self.exploration_schedule = linear_schedule(int(self.args.total_timesteps * self.args.exploration_fraction), \ self.args.final_ratio, self.args.init_ratio) # create the folder to save the models if not os.path.exists(self.args.save_dir): os.mkdir(self.args.save_dir) # set the environment folder self.model_path = os.path.join(self.args.save_dir, self.args.env_name) if not os.path.exists(self.model_path): os.mkdir(self.model_path) # start to do the training def learn(self): episode_reward = [0.0] obs = np.array(self.env.reset()) td_loss = 0 for timestep in range(self.args.total_timesteps): explore_eps = self.exploration_schedule.get_value(timestep) with torch.no_grad(): obs_tensor = self._get_tensors(obs) action_value = self.net(obs_tensor) # select actions action = select_actions(action_value, explore_eps) # excute actions obs_, reward, done, _ = self.env.step(action) obs_ = np.array(obs_) # tryint to append the samples self.buffer.add(obs, action, reward, obs_, float(done)) obs = obs_ # add the rewards episode_reward[-1] += reward if done: obs = np.array(self.env.reset()) episode_reward.append(0.0) if timestep > self.args.learning_starts and timestep % self.args.train_freq == 0: # start to sample the samples from the replay buffer batch_samples = self.buffer.sample(self.args.batch_size) td_loss = self._update_network(batch_samples) if timestep > self.args.learning_starts and timestep % self.args.target_network_update_freq == 0: # update the target network self.target_net.load_state_dict(self.net.state_dict()) if len(episode_reward[-101:-1]) == 0: mean_reward_per_100 = 0 else: mean_reward_per_100 = np.mean(episode_reward[-101:-1]) num_episode = len(episode_reward) - 1 if done and num_episode % self.args.display_interval == 0: print('[{}] Frames: {}, Episode: {}, Mean: {:.3f}, Loss: {:.3f}'.format(datetime.now(), timestep, num_episode, \ mean_reward_per_100, td_loss)) torch.save(self.net.state_dict(), self.model_path + '/model.pt') # update the network def _update_network(self, samples): obses, actions, rewards, obses_next, dones = samples # convert the data to tensor obses = self._get_tensors(obses) actions = torch.tensor(actions, dtype=torch.int64).unsqueeze(-1) rewards = torch.tensor(rewards, dtype=torch.float32).unsqueeze(-1) obses_next = self._get_tensors(obses_next) dones = torch.tensor(1 - dones, dtype=torch.float32).unsqueeze(-1) # convert into gpu if self.args.cuda: actions = actions.cuda() rewards = rewards.cuda() dones = dones.cuda() # calculate the target value with torch.no_grad(): q_value_temp = self.net(obses_next) action_max_idx = torch.argmax(q_value_temp, dim=1, keepdim=True) target_action_value = self.target_net(obses_next) target_action_max_value = target_action_value.gather( 1, action_max_idx) target_action_max_value = target_action_max_value.detach() # target expected_value = rewards + self.args.gamma * target_action_max_value * dones # get the real q value action_value = self.net(obses) real_value = action_value.gather(1, actions) loss = (expected_value - real_value).pow(2).mean() # start to update self.optimizer.zero_grad() loss.backward() self.optimizer.step() return loss.item() # get tensors def _get_tensors(self, obs): if obs.ndim == 3: obs = np.transpose(obs, (2, 0, 1)) obs = np.expand_dims(obs, 0) elif obs.ndim == 4: obs = np.transpose(obs, (0, 3, 1, 2)) obs = torch.tensor(obs, dtype=torch.float32) if self.args.cuda: obs = obs.cuda() return obs
def main(): warnings.filterwarnings("ignore") ####################################################################################################################### """Command line interface""" parser = argparse.ArgumentParser() # parser.add_argument('--dataset', required=False, help='cifar10 | mnist | fmnist '| svhn', default='mnist') # parser.add_argument('--dataroot', required=False, help='path to dataset', default='./data/data.csv') parser.add_argument('--workers', type=int, help='number of data loading workers', default=6) # parser.add_argument('--batchSize', type=int, default=32, help='input batch size') parser.add_argument('--len', type=int, default=64, help='the height / width of the input to network') # parser.add_argument('--saveInt', type=int, default=14, help='number of epochs between checkpoints') parser.add_argument('--cuda', action='store_true', help='enables cuda', default=True) # parser.add_argument('--outf', default='output', help='folder to output images and model checkpoints') parser.add_argument('--manualSeed', type=int, help='manual seed') parser.add_argument('--net', help="path to net (to continue training)", default='./net_epoch_196.pth') parser.add_argument('--nc', default=20, help="number of channels", type=int) opt = parser.parse_args() with open("FocusMuseDataset_mean_std.pkl", "rb") as f: mean = pickle.load(f) std = pickle.load(f) ###################################################################################################################### if opt.manualSeed is None: opt.manualSeed = random.randint(1, 10000) random.seed(opt.manualSeed) torch.manual_seed(opt.manualSeed) if opt.cuda: torch.cuda.manual_seed_all(opt.manualSeed) cudnn.benchmark = True if torch.cuda.is_available() and not opt.cuda: print( "WARNING: You have a CUDA device, so you should probably run with --cuda" ) device = torch.device("cuda" if opt.cuda else "cpu") ###################################################################################################################### """Server""" HOST = '' PORT = 65531 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind((HOST, PORT)) print("binding") s.listen(5) conn, addr = s.accept() print('Connected by', addr) while True: data = conn.recv(16184) if not data: break test_x = np.fromstring(data, dtype=np.float).reshape(20, -1) test_x = torch.Tensor(test_x) print("test data: ", type(test_x), test_x.shape) # """Dataset loading""" # tensor_test_x = torch.stack([torch.Tensor(i) for i in test_x]) # transform to torch tensors # # dataset = vdata.TensorDataset(tensor_test_x) # create your datset # testloader = DataLoader(dataset, drop_last=False) # create your dataloader ####################################################################################################################### net = Net(insize=opt.len, output_size=128, nc=opt.nc, hidden_size=64, n_layers=2) # net.apply(weights_init) if opt.net != '': print("loading trained net...") net.load_state_dict(torch.load(opt.net)) # print(net) if opt.cuda: net.cuda() test_x.cuda() # total, nonzero = 0, 0 test_x = Variable(test_x) outputs = net(test_x) predicted = torch.argmax(outputs, dim=1) # if opt.cuda: # p2 = predicted.cpu().detach().numpy() # else: # p2 = predicted.numpy() # nonzero += np.count_nonzero(p2) # total += p2.shape[0] # # ratio = ((total - nonzero) / total) * 100 # ratio = _test(opt=opt, net=net, testloader=testloader) conn.send(outputs[1].encode()) conn.close()
# you may also need to change the width of the rectangle drawn depending on image resolution cv2.rectangle(image_with_detections,(x,y),(x+w,y+h),(255,0,0),3) fig = plt.figure(figsize=(9,9)) plt.imshow(image_with_detections) # ************************** Load Pre-trained Model **************************************** import torch from models import Net net = Net() net.load_state_dict(torch.load('saved_models/keypoints_model_1.pt')) ## print out your net and prepare it for testing (uncomment the line below) net.eval() # ************************** Display Keypoints Generated by model onto image **************** image_copy = np.copy(image) # loop over the detected faces from your haar cascade for (x,y,w,h) in faces: # Select the region of interest that is the face in the image roi = image_copy[y:y+h, x:x+w] # Convert the face region from RGB to grayscale
def main(args): source_model = Net().to(device) source_model.load_state_dict(torch.load(args.MODEL_FILE)) source_model.eval() set_requires_grad(source_model, requires_grad=False) clf = source_model source_model = source_model.feature_extractor target_model = Net().to(device) target_model.load_state_dict(torch.load(args.MODEL_FILE)) target_model = target_model.feature_extractor target_clf = clf.classifier discriminator = nn.Sequential(nn.Linear(320, 50), nn.ReLU(), nn.Linear(50, 20), nn.ReLU(), nn.Linear(20, 1)).to(device) half_batch = args.batch_size // 2 source_dataset = MNIST(config.DATA_DIR / 'mnist', train=True, download=True, transform=Compose([GrayscaleToRgb(), ToTensor()])) source_loader = DataLoader(source_dataset, batch_size=half_batch, shuffle=True, num_workers=1, pin_memory=True) target_dataset = MNISTM(train=False) target_loader = DataLoader(target_dataset, batch_size=half_batch, shuffle=True, num_workers=1, pin_memory=True) discriminator_optim = torch.optim.Adam(discriminator.parameters()) target_optim = torch.optim.Adam(target_model.parameters()) criterion = nn.BCEWithLogitsLoss() for epoch in range(1, args.epochs + 1): batch_iterator = zip(loop_iterable(source_loader), loop_iterable(target_loader)) total_loss = 0 total_accuracy = 0 target_label_accuracy = 0 for _ in trange(args.iterations, leave=False): # Train discriminator set_requires_grad(target_model, requires_grad=False) set_requires_grad(discriminator, requires_grad=True) for _ in range(args.k_disc): (source_x, _), (target_x, _) = next(batch_iterator) source_x, target_x = source_x.to(device), target_x.to(device) source_features = source_model(source_x).view( source_x.shape[0], -1) target_features = target_model(target_x).view( target_x.shape[0], -1) discriminator_x = torch.cat([source_features, target_features]) discriminator_y = torch.cat([ torch.ones(source_x.shape[0], device=device), torch.zeros(target_x.shape[0], device=device) ]) preds = discriminator(discriminator_x).squeeze() loss = criterion(preds, discriminator_y) discriminator_optim.zero_grad() loss.backward() discriminator_optim.step() total_loss += loss.item() total_accuracy += (( preds > 0).long() == discriminator_y.long()).float().mean().item() # Train classifier set_requires_grad(target_model, requires_grad=True) set_requires_grad(discriminator, requires_grad=False) for _ in range(args.k_clf): _, (target_x, target_labels) = next(batch_iterator) target_x = target_x.to(device) target_features = target_model(target_x).view( target_x.shape[0], -1) # flipped labels discriminator_y = torch.ones(target_x.shape[0], device=device) preds = discriminator(target_features).squeeze() loss = criterion(preds, discriminator_y) target_optim.zero_grad() loss.backward() target_optim.step() target_label_preds = target_clf(target_features) target_label_accuracy += (target_label_preds.cpu().max(1)[1] == target_labels).float().mean().item() mean_loss = total_loss / (args.iterations * args.k_disc) mean_accuracy = total_accuracy / (args.iterations * args.k_disc) target_mean_accuracy = target_label_accuracy / (args.iterations * args.k_clf) tqdm.write( f'EPOCH {epoch:03d}: discriminator_loss={mean_loss:.4f}, ' f'discriminator_accuracy={mean_accuracy:.4f}, target_accuracy={target_mean_accuracy:.4f}' ) # Create the full target model and save it clf.feature_extractor = target_model torch.save(clf.state_dict(), 'trained_models/adda.pt')
transforms.RandomVerticalFlip(p=0.5), transforms.Resize(256), transforms.ToTensor(), ]) device = torch.device(DEVICE if torch.cuda.is_available() else "cpu") refine_net = Net() weights = torch.load("/content/weights_net_df2.pth", map_location='cpu') state_dict = {} 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)
class NNet(): """ Wrapper to manage neural net. """ def __init__(self, args): self.args = args self.num_channels = NUM_CHANNELS if args.netType == 1: self.net = Net(self.num_channels, args) elif args.netType == 2: self.net = Net2(self.num_channels, args) if args.cuda: self.net = self.net.cuda() self.load_dataset_from_folder() self.writer = SummaryWriter() self.unique_tok = str(time.time()) self.init_weights() def init_weights(self): """ Initialize by Xavier weights """ self.net.apply(init_weights) def load_dataset_from_folder(self): """ Load complete dataset """ all_data_path = self.args.all_data_path validation_split_size = self.args.validation_split_size batch_size = self.args.batch_size num_workers = self.args.num_workers shuffle = self.args.shuffle all_data = ImageFolder(root=all_data_path, transform=TRANSFORM) classes = all_data.classes self.classes = classes validation_size = int(validation_split_size * len(all_data)) test_size = int(validation_split_size * len(all_data)) train_size = len(all_data) - 2 * validation_size train_dataset, val_dataset, test_dataset = random_split( all_data, [train_size, validation_size, test_size]) training_data_loader = DataLoader(train_dataset, batch_size=batch_size, num_workers=num_workers, shuffle=shuffle) validation_dataset_loader = DataLoader(val_dataset, batch_size=batch_size, num_workers=num_workers, shuffle=shuffle) test_dataset_loader = DataLoader(test_dataset, batch_size=batch_size, num_workers=num_workers, shuffle=shuffle) self.train_loader = training_data_loader self.val_loader = validation_dataset_loader self.test_loader = test_dataset_loader def train(self): """ Train Neural Net """ if self.args.optim == 'RMSprop': optimizer = optim.RMSprop(self.net.parameters(), lr=self.args.lr, momentum=self.args.momentum, weight_decay=self.args.l2_regularization) elif self.args.optim == 'SGD': optimizer = optim.SGD(self.net.parameters(), lr=self.args.lr, momentum=self.args.momentum) elif self.args.optim == 'Adam': optimizer = optim.Adam(self.net.parameters(), lr=self.args.lr) criterion = nn.CrossEntropyLoss() # scheduler = optim.lr_scheduler.StepLR( # optimizer, step_size=self.args.scheduler_step_size, gamma=self.args.scheduler_gamma) self.net.train() for epoch in range(self.args.epoch): start_time = time.time() running_loss_t = 0.0 num_batches = 0 y_true = [] y_pred = [] # print('Epoch: {} , LR: {}'.format(epoch+1, scheduler.get_lr())) for data in tqdm(self.train_loader): inputs, labels = data labels_cp = labels.clone() # imshow(torchvision.utils.make_grid(inputs[:,:3,:,:])) if len(inputs) < 2: continue if self.args.cuda: inputs = inputs.cuda() labels = labels.cuda() outputs = self.net(inputs) loss = criterion(outputs, labels) _, predicted = torch.max(outputs, 1) predicted = predicted.cpu() for i, pred in enumerate(predicted): y_pred.append(pred) y_true.append(labels_cp[i]) optimizer.zero_grad() loss.backward() optimizer.step() running_loss_t += loss.item() num_batches += 1 end_time = time.time() train_f1 = f1_score(y_true, y_pred, average='weighted') # scheduler.step() self.save(epoch + 1) self.writer.add_scalar('Loss/train', running_loss_t / num_batches, epoch + 1) self.writer.add_scalar('F1/train', train_f1, epoch + 1) loss_v, val_f1 = self.get_validation_loss(criterion) self.writer.add_scalar('Loss/val', loss_v, epoch + 1) self.writer.add_scalar('F1/val', val_f1, epoch + 1) print( "Epoch {} Time {:.2f}s Train-Loss {:.3f} Val-Loss {:.3f} Train-F1 {:.3f} Val-F1 {:.3f}" .format(epoch + 1, end_time - start_time, running_loss_t / num_batches, loss_v, train_f1, val_f1)) def get_validation_loss(self, criterion): """ Check validation loss """ running_loss = 0.0 num_batches = 0 self.net.eval() y_true = [] y_pred = [] with torch.no_grad(): for data in tqdm(self.val_loader): images, labels = data labels_cp = labels.clone() if self.args.cuda: images = images.cuda() labels = labels.cuda() outputs = self.net(images) _, predicted = torch.max(outputs, 1) predicted = predicted.cpu() for i, pred in enumerate(predicted): y_pred.append(pred) y_true.append(labels_cp[i]) loss = criterion(outputs, labels) running_loss += loss.item() num_batches += 1 self.net.train() val_f1 = f1_score(y_true, y_pred, average='weighted') return running_loss / num_batches, val_f1 def get_test_accuracy(self): """ Check overall accuracy of model """ y_true = [] y_pred = [] class_correct = list(0. for i in range(4)) class_total = list(0. for i in range(4)) with torch.no_grad(): for data in tqdm(self.test_loader): images, labels = data labels_cp = labels.clone() if self.args.cuda: images = images.cuda() labels = labels.cuda() outputs = self.net(images) _, predicted = torch.max(outputs, 1) predicted = predicted.cpu() for i, pred in enumerate(predicted): y_pred.append(pred) y_true.append(labels_cp[i]) c = (predicted == labels_cp).squeeze() for i in range(min(self.args.batch_size, len(labels_cp))): label = labels_cp[i] class_correct[label] += c[i].item() class_total[label] += 1 print("Test F1: ", f1_score(y_true, y_pred, average='weighted')) def save(self, epochs, folder_path="../models/"): """ Save Model """ dict_save = {'params': self.net.state_dict(), 'classes': self.classes} name = folder_path + self.unique_tok + '_' + str(epochs) + '.model' torch.save(dict_save, name) print('Model saved at {}'.format(name)) return name def load(self, path): """ Load a saved model """ device = torch.device("cuda" if torch.cuda.is_available() else "cpu") dict_load = torch.load(path, map_location=torch.device(device)) self.net.load_state_dict(dict_load['params']) return dict_load['classes'] def predict(self, inp): """ Predict using net """ if self.args.cuda: inp = inp.cuda() self.net.eval() with torch.no_grad(): vals = self.net(inp) print(vals) _, predicted = torch.max(vals, 1) predicted = predicted.cpu() result_class = self.classes[predicted] return result_class
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))
def test(pathModel, nnClassCount, testTensor, trBatchSize): print("\n\n\n") print("Inside test funtion") CLASS_NAMES = ['Broken', 'Normal'] # cudnn.benchmark = True model = Net() # model = model.cuda() # -------------------- SETTINGS: NETWORK ARCHITECTURE, MODEL LOAD print("Is model==None:", model is None) print("Is pathModel==None:", pathModel is None) # cudnn.benchmark = True # if pathModel!=None: # model = Trainer.loadModel(nnArchitecture, nnClassCount, nnIsTrained) # #model = torch.nn.DataParallel(model) # model.to(device) if os.path.isfile(pathModel): print("=> loading checkpoint: ", pathModel) modelCheckpoint = torch.load(pathModel, map_location='cpu') model.load_state_dict(modelCheckpoint['state_dict'], strict=False) print("=> loaded checkpoint: ", pathModel) else: print("=> no checkpoint found: ") print( "\n============================ Loading data into RAM ======================================== " ) testImage = testTensor testSize = testImage.size()[0] print( "============================= Evaluation of model starts ====================================" ) model.eval() broken = 0 normal = 0 batchID = 1 with torch.no_grad(): for i in range(0, testSize, trBatchSize): if (batchID % 1) == 0: print("batchID:" + str(batchID) + '/' + str(testImage.size()[0] / trBatchSize)) if i + trBatchSize >= testSize: input = testImage[i:] else: input = testImage[i:i + trBatchSize] input = trans_test(input) input = input.type(torch.FloatTensor) varInput = torch.autograd.Variable(input) out = model(varInput) _, predicted = torch.max(out.data, 1) print(predicted) if i + trBatchSize <= testSize: for k in range(trBatchSize): if (predicted[k] == 1): normal += 1 elif (predicted[k] == 0): broken += 1 else: for k in range(testSize % trBatchSize): if (predicted[k] == 1): normal += 1 elif (predicted[k] == 0): broken += 1 batchID += 1 print(' Number of broken grains in sample : ', broken) print(' Number of normal grains in sample :', normal)
def main(args): clf_model = Net().to(device) clf_model.load_state_dict(torch.load(args.MODEL_FILE)) feature_extractor = clf_model.feature_extractor discriminator = clf_model.classifier critic = nn.Sequential(nn.Linear(320, 50), nn.ReLU(), nn.Linear(50, 20), nn.ReLU(), nn.Linear(20, 1)).to(device) half_batch = args.batch_size // 2 source_dataset = MNIST(config.DATA_DIR / 'mnist', train=True, download=True, transform=Compose([GrayscaleToRgb(), ToTensor()])) source_loader = DataLoader(source_dataset, batch_size=half_batch, drop_last=True, shuffle=True, num_workers=0, pin_memory=True) target_dataset = MNISTM(train=False) target_loader = DataLoader(target_dataset, batch_size=half_batch, drop_last=True, shuffle=True, num_workers=0, pin_memory=True) critic_optim = torch.optim.Adam(critic.parameters(), lr=1e-4) clf_optim = torch.optim.Adam(clf_model.parameters(), lr=1e-4) clf_criterion = nn.CrossEntropyLoss() for epoch in range(1, args.epochs + 1): batch_iterator = zip(loop_iterable(source_loader), loop_iterable(target_loader)) total_loss = 0 total_accuracy = 0 for _ in trange(args.iterations, leave=False): (source_x, source_y), (target_x, _) = next(batch_iterator) # Train critic set_requires_grad(feature_extractor, requires_grad=False) set_requires_grad(critic, requires_grad=True) source_x, target_x = source_x.to(device), target_x.to(device) source_y = source_y.to(device) with torch.no_grad(): h_s = feature_extractor(source_x).data.view( source_x.shape[0], -1) h_t = feature_extractor(target_x).data.view( target_x.shape[0], -1) for _ in range(args.k_critic): gp = gradient_penalty(critic, h_s, h_t) critic_s = critic(h_s) critic_t = critic(h_t) wasserstein_distance = critic_s.mean() - critic_t.mean() critic_cost = -wasserstein_distance + args.gamma * gp critic_optim.zero_grad() critic_cost.backward() critic_optim.step() total_loss += critic_cost.item() # Train classifier set_requires_grad(feature_extractor, requires_grad=True) set_requires_grad(critic, requires_grad=False) for _ in range(args.k_clf): source_features = feature_extractor(source_x).view( source_x.shape[0], -1) target_features = feature_extractor(target_x).view( target_x.shape[0], -1) source_preds = discriminator(source_features) clf_loss = clf_criterion(source_preds, source_y) wasserstein_distance = critic(source_features).mean() - critic( target_features).mean() loss = clf_loss + args.wd_clf * wasserstein_distance clf_optim.zero_grad() loss.backward() clf_optim.step() mean_loss = total_loss / (args.iterations * args.k_critic) tqdm.write(f'EPOCH {epoch:03d}: critic_loss={mean_loss:.4f}') torch.save(clf_model.state_dict(), 'trained_models/wdgrl.pt')
def main(args): # TODO: add DTN model model = Net().to(device) model.load_state_dict(torch.load(args.MODEL_FILE)) feature_extractor = model.feature_extractor clf = model.classifier discriminator = nn.Sequential(GradientReversal(), nn.Linear(320, 50), nn.ReLU(), nn.Linear(50, 20), nn.ReLU(), nn.Linear(20, 1)).to(device) half_batch = args.batch_size // 2 if args.adapt_setting == 'mnist2mnistm': source_dataset = MNIST(config.DATA_DIR / 'mnist', train=True, download=True, transform=Compose( [GrayscaleToRgb(), ToTensor()])) target_dataset = MNISTM(train=False) elif args.adapt_setting == 'svhn2mnist': source_dataset = ImageClassdata(txt_file=args.src_list, root_dir=args.src_root, img_type=args.img_type, transform=transforms.Compose([ transforms.Resize(28), transforms.ToTensor(), ])) target_dataset = ImageClassdata(txt_file=args.tar_list, root_dir=args.tar_root, img_type=args.img_type, transform=transforms.Compose([ transforms.ToTensor(), ])) elif args.adapt_setting == 'mnist2usps': source_dataset = ImageClassdata(txt_file=args.src_list, root_dir=args.src_root, img_type=args.img_type, transform=transforms.Compose([ transforms.ToTensor(), ])) target_dataset = ImageClassdata(txt_file=args.tar_list, root_dir=args.tar_root, img_type=args.img_type, transform=transforms.Compose([ transforms.Resize(28), transforms.ToTensor(), ])) else: raise NotImplementedError source_loader = DataLoader(source_dataset, batch_size=half_batch, shuffle=True, num_workers=1, pin_memory=True, drop_last=True) target_loader = DataLoader(target_dataset, batch_size=half_batch, shuffle=True, num_workers=1, pin_memory=True, drop_last=True) optim = torch.optim.Adam( list(discriminator.parameters()) + list(model.parameters())) if not os.path.exists('logs'): os.makedirs('logs') f = open(f'logs/{args.adapt_setting}_{args.name}.txt', 'w+') for epoch in range(1, args.epochs + 1): batches = zip(source_loader, target_loader) n_batches = min(len(source_loader), len(target_loader)) total_domain_loss = total_label_accuracy = 0 target_label_accuracy = 0 for (source_x, source_labels), (target_x, target_labels) in tqdm(batches, leave=False, total=n_batches): x = torch.cat([source_x, target_x]) x = x.to(device) domain_y = torch.cat([ torch.ones(source_x.shape[0]), torch.zeros(target_x.shape[0]) ]) domain_y = domain_y.to(device) label_y = source_labels.to(device) features = feature_extractor(x).view(x.shape[0], -1) domain_preds = discriminator(features).squeeze() label_preds = clf(features[:source_x.shape[0]]) domain_loss = F.binary_cross_entropy_with_logits( domain_preds, domain_y) label_loss = F.cross_entropy(label_preds, label_y) loss = domain_loss + label_loss optim.zero_grad() loss.backward() optim.step() total_domain_loss += domain_loss.item() total_label_accuracy += ( label_preds.max(1)[1] == label_y).float().mean().item() target_label_preds = clf(features[source_x.shape[0]:]) target_label_accuracy += (target_label_preds.cpu().max(1)[1] == target_labels).float().mean().item() mean_loss = total_domain_loss / n_batches mean_accuracy = total_label_accuracy / n_batches target_mean_accuracy = target_label_accuracy / n_batches tqdm.write( f'EPOCH {epoch:03d}: domain_loss={mean_loss:.4f}, ' f'source_accuracy={mean_accuracy:.4f}, target_accuracy={target_mean_accuracy:.4f}' ) f.write( f'EPOCH {epoch:03d}: domain_loss={mean_loss:.4f}, ' f'source_accuracy={mean_accuracy:.4f}, target_accuracy={target_mean_accuracy:.4f}\n' ) torch.save( model.state_dict(), f'trained_models/{args.adapt_setting}_{args.name}_ep{epoch}.pt') f.close()
DEVICE_ID = 1 DEVICE = "cuda" MEAN = np.array([0.485, 0.456, 0.406]) STD = np.array([0.229, 0.224, 0.225]) mask_transform = transforms.Compose([ transforms.RandomHorizontalFlip(p=0.5), transforms.RandomVerticalFlip(p=0.5), transforms.Resize(256), transforms.ToTensor(), ]) device = torch.device(DEVICE if torch.cuda.is_available() else "cpu") refine_net = Net() refine_net.load_state_dict( torch.load("exp_2/weights/weights_net_epoch_20.pth", map_location='cpu')) 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)
# loop over the detected faces, mark the image where each face is found for (x, y, w, h) in faces: # draw a rectangle around each detected face # change the width of the rectangle drawn depending on image resolution cv2.rectangle(image_with_detections, (x, y), (x + w, y + h), (255, 0, 0), 3) fig = plt.figure(figsize=(9, 9)) plt.imshow(image_with_detections) ## Loading in a trained model net = Net() # load saved model parameters net.load_state_dict(torch.load('saved_models/test_run_2.pt')) # print out the net and prepare it for testing net.eval() # Keypoint detection ### Transform each detected face into an input Tensor # perform the following steps for each detected face: # 1. Convert the face from RGB to grayscale # 2. Normalize the grayscale image so that its color range falls in [0,1] instead of [0,255] # 3. Rescale the detected face to be the expected square size for your CNN (224x224, suggested) # 4. Reshape the numpy image into a torch image.
import numpy as np import pandas as pd import matplotlib.pyplot as plt import matplotlib.image as mpimg import cv2 import torch from torch.utils.data import DataLoader from torchvision import transforms from data_load import FacialKeypointsDataset, Rescale, RandomCrop, Normalize, ToTensor from models import Net net = Net() net.load_state_dict( torch.load( r'C:\Users\Semanti Basu\Documents\OneDrive_2020-02-19\3D Ceaser dataset\Image and point generation\Image and point generation\frontaltrainedmodel_10epoch.pth' )) ## print out your net and prepare it for testing (uncomment the line below) net.eval() data_transform = transforms.Compose( [Rescale(225), RandomCrop(224), Normalize(), ToTensor()]) transformed_dataset = FacialKeypointsDataset( csv_file= r'C:\Users\Semanti Basu\Documents\OneDrive_2020-02-19\3D Ceaser dataset\Image and point generation\Image and point generation\frontalpoints.csv', root_dir= r'C:\Users\Semanti Basu\Documents\OneDrive_2020-02-19\3D Ceaser dataset\Image and point generation\Image and point generation\ceasar_mat', transform=data_transform) # load training data in batches batch_size = 10
img = cv2.imread('../img/ys.jpg') img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) face_cascade = cv2.CascadeClassifier('../detector_architectures/haarcascade_frontalface_default.xml') faces = face_cascade.detectMultiScale(img, 1.2, 2) img_with_detections = img.copy() for (x,y,w,h) in faces: cv2.rectangle(img_with_detections, (x,y), (x+w,y+h), (255,0,0),3) net = Net() print(net) net.load_state_dict(torch.load('../saved_models/facial_keypoint_detection.pt')) net.eval() image_copy = np.copy(img) for (x,y,w,h) in faces: height, width = image_copy.shape[:2] h_start = int(max(y-h/2, 0)) h_end = int(min(y+h+h/2, height)) w_start = int(max(x-w/2, 0)) w_end = int(min(x+w+w/2, width)) roi = image_copy[h_start:h_end, w_start:w_end] roi = cv2.cvtColor(roi, cv2.COLOR_RGB2GRAY) roi = roi / 255.0
obs = np.transpose(obs, (2, 0, 1)) obs = np.expand_dims(obs, 0) obs = torch.tensor(obs, dtype=torch.float32) return obs if __name__ == '__main__': args = get_args() # create the environment env = make_atari(args.env_name) env = wrap_deepmind(env, frame_stack=True) # create the network net = Net(env.action_space.n) # model path model_path = args.save_dir + args.env_name + '/model.pt' # load the models net.load_state_dict( torch.load(model_path, map_location=lambda storage, loc: storage)) # start to test the demo obs = env.reset() for _ in range(2000): env.render() with torch.no_grad(): obs_tensor = get_tensors(obs) action_value = net(obs_tensor) action = torch.argmax(action_value.squeeze()).item() obs, reward, done, _ = env.step(action) if done: obs = env.reset() env.close()
# make a copy of the original image to plot detections on image_with_detections = image.copy() # loop over the detected faces, mark the image where each face is found for (x, y, w, h) in faces: # draw a rectangle around each detected face # you may also need to change the width of the rectangle drawn depending on image resolution cv2.rectangle(image_with_detections, (x, y), (x + w, y + h), (255, 0, 0), 3) fig = plt.figure(figsize=(9, 9)) plt.savefig("saved_images/face_detected_img.jpg") net = Net() net.load_state_dict(torch.load('keypoints_model_final.pt')) ## print out your net and prepare it for testing net.eval() image_copy = np.copy(image) # loop over the detected faces from your haar cascade count = 0 for (x, y, w, h) in faces: count += 1 # Select the region of interest that is the face in the image roi = image_copy[y:y + h, x:x + w] roi_gray = cv2.cvtColor(roi, cv2.COLOR_RGB2GRAY) roi_gray_copy = np.copy(roi_gray)
def main(args): model = Net().to(device) model.load_state_dict(torch.load(args.MODEL_FILE)) feature_extractor = model.feature_extractor clf = model.classifier discriminator = nn.Sequential(GradientReversal(), nn.Linear(320, 50), nn.ReLU(), nn.Linear(50, 20), nn.ReLU(), nn.Linear(20, 1)).to(device) half_batch = args.batch_size // 2 source_dataset = MNIST(config.DATA_DIR / 'mnist', train=True, download=True, transform=Compose([GrayscaleToRgb(), ToTensor()])) source_loader = DataLoader(source_dataset, batch_size=half_batch, shuffle=True, num_workers=1, pin_memory=True) target_dataset = MNISTM(train=False) target_loader = DataLoader(target_dataset, batch_size=half_batch, shuffle=True, num_workers=1, pin_memory=True) optim = torch.optim.Adam( list(discriminator.parameters()) + list(model.parameters())) for epoch in range(1, args.epochs + 1): batches = zip(source_loader, target_loader) n_batches = min(len(source_loader), len(target_loader)) total_domain_loss = total_label_accuracy = 0 target_label_accuracy = 0 for (source_x, source_labels), (target_x, target_labels) in tqdm(batches, leave=False, total=n_batches): x = torch.cat([source_x, target_x]) x = x.to(device) domain_y = torch.cat([ torch.ones(source_x.shape[0]), torch.zeros(target_x.shape[0]) ]) domain_y = domain_y.to(device) label_y = source_labels.to(device) features = feature_extractor(x).view(x.shape[0], -1) domain_preds = discriminator(features).squeeze() label_preds = clf(features[:source_x.shape[0]]) domain_loss = F.binary_cross_entropy_with_logits( domain_preds, domain_y) label_loss = F.cross_entropy(label_preds, label_y) loss = domain_loss + label_loss optim.zero_grad() loss.backward() optim.step() total_domain_loss += domain_loss.item() total_label_accuracy += ( label_preds.max(1)[1] == label_y).float().mean().item() target_label_preds = clf(features[source_x.shape[0]:]) target_label_accuracy += (target_label_preds.cpu().max(1)[1] == target_labels).float().mean().item() mean_loss = total_domain_loss / n_batches mean_accuracy = total_label_accuracy / n_batches target_mean_accuracy = target_label_accuracy / n_batches tqdm.write( f'EPOCH {epoch:03d}: domain_loss={mean_loss:.4f}, ' f'source_accuracy={mean_accuracy:.4f}, target_accuracy={target_mean_accuracy:.4f}' ) torch.save(model.state_dict(), 'trained_models/revgrad.pt')
def main(args): source_model = Net().to(device) source_model.load_state_dict(torch.load(args.MODEL_FILE)) source_model.eval() set_requires_grad(source_model, requires_grad=False) clf = source_model source_model = source_model.feature_extractor target_model = Net().to(device) target_model.load_state_dict(torch.load(args.MODEL_FILE)) target_model = target_model.feature_extractor classifier = clf.classifier discriminator = nn.Sequential(nn.Linear(EXTRACTED_FEATURE_DIM, 64), nn.ReLU(), nn.BatchNorm1d(64), nn.Linear(64, 1), nn.Sigmoid()).to(device) #half_batch = args.batch_size // 2 batch_size = args.batch_size # X_source, y_source = preprocess_train() X_source, y_source = preprocess_train_single(1) source_dataset = torch.utils.data.TensorDataset(X_source, y_source) source_loader = DataLoader(source_dataset, batch_size=batch_size, shuffle=False, num_workers=1, pin_memory=True) X_target, y_target = preprocess_test(args.person) target_dataset = torch.utils.data.TensorDataset(X_target, y_target) target_loader = DataLoader(target_dataset, batch_size=batch_size, shuffle=False, num_workers=1, pin_memory=True) discriminator_optim = torch.optim.Adam(discriminator.parameters()) target_optim = torch.optim.Adam(target_model.parameters(), lr=3e-6) criterion = nn.BCEWithLogitsLoss() criterion_class = nn.CrossEntropyLoss() best_tar_acc = test(args, clf) final_accs = [] for epoch in range(1, args.epochs + 1): source_loader = DataLoader(source_loader.dataset, batch_size=batch_size, shuffle=True) target_loader = DataLoader(target_loader.dataset, batch_size=batch_size, shuffle=True) batch_iterator = zip(loop_iterable(source_loader), loop_iterable(target_loader)) total_loss = 0 adv_loss = 0 total_accuracy = 0 second_acc = 0 total_class_loss = 0 for _ in trange(args.iterations, leave=False): # Train discriminator set_requires_grad(target_model, requires_grad=False) set_requires_grad(discriminator, requires_grad=True) discriminator.train() for _ in range(args.k_disc): (source_x, source_y), (target_x, _) = next(batch_iterator) source_y = source_y.to(device).view(-1) source_x, target_x = source_x.to(device), target_x.to(device) source_features = source_model(source_x).view( source_x.shape[0], -1) target_features = target_model(target_x).view( target_x.shape[0], -1) discriminator_x = torch.cat([source_features, target_features]) discriminator_y = torch.cat([ torch.ones(source_x.shape[0], device=device), torch.zeros(target_x.shape[0], device=device) ]) preds = discriminator(discriminator_x).squeeze() loss = criterion(preds, discriminator_y) discriminator_optim.zero_grad() loss.backward() discriminator_optim.step() total_loss += loss.item() total_accuracy += ((preds >= 0.5).long() == discriminator_y. long()).float().mean().item() # Train feature extractor set_requires_grad(target_model, requires_grad=True) set_requires_grad(discriminator, requires_grad=False) target_model.train() for _ in range(args.k_clf): _, (target_x, _) = next(batch_iterator) target_x = target_x.to(device) target_features = target_model(target_x).view( target_x.shape[0], -1) source_features = target_model(source_x).view( source_x.shape[0], -1) source_pred = classifier(source_features) # (batch_size, 4) # flipped labels discriminator_y = torch.ones(target_x.shape[0], device=device) preds = discriminator(target_features).squeeze() second_acc += ((preds >= 0.5).long() == discriminator_y.long() ).float().mean().item() loss_adv = criterion(preds, discriminator_y) adv_loss += loss_adv.item() loss_class = criterion_class(source_pred, source_y) total_class_loss += loss_class.item() loss = loss_adv #+ 0.001*loss_class target_optim.zero_grad() loss.backward() target_optim.step() mean_loss = total_loss / (args.iterations * args.k_disc) mean_adv_loss = adv_loss / (args.iterations * args.k_clf) total_class_loss = total_class_loss / (args.iterations * args.k_clf) dis_accuracy = total_accuracy / (args.iterations * args.k_disc) sec_acc = second_acc / (args.iterations * args.k_clf) clf.feature_extractor = target_model tar_accuarcy = test(args, clf) final_accs.append(tar_accuarcy) if tar_accuarcy > best_tar_acc: best_tar_acc = tar_accuarcy torch.save(clf.state_dict(), 'trained_models/adda.pt') tqdm.write( f'EPOCH {epoch:03d}: discriminator_loss={mean_loss:.4f}, adv_loss = {mean_adv_loss:.4f}, ' f'discriminator_accuracy={dis_accuracy:.4f}, tar_accuary = {tar_accuarcy:.4f}, best_accuracy = {best_tar_acc:.4f}, ' f'sec_acc = {sec_acc:.4f}, total_class_loss: {total_class_loss:.4f}' ) # Create the full target model and save it clf.feature_extractor = target_model #torch.save(clf.state_dict(), 'trained_models/adda.pt') jd = {"test_acc": final_accs} with open(str(args.seed) + '/acc' + str(args.person) + '.json', 'w') as f: json.dump(jd, f)