def extract_feature(model, dataloader, save_path, load_from_disk=True, model_path=''): if load_from_disk: model = models.Network(base_net=args.model_name, n_class=args.num_class) model.load_state_dict(torch.load(model_path)) model = model.to(DEVICE) model.eval() correct = 0 fea_all = torch.zeros(1, 1 + model.base_network.output_num()).to(DEVICE) with torch.no_grad(): for inputs, labels in dataloader: inputs, labels = inputs.to(DEVICE), labels.to(DEVICE) feas = model.get_features(inputs) labels = labels.view(labels.size(0), 1).float() x = torch.cat((feas, labels), dim=1) fea_all = torch.cat((fea_all, x), dim=0) outputs = model(inputs) preds = torch.max(outputs, 1)[1] correct += torch.sum(preds == labels.data.long()) test_acc = correct.double() / len(dataloader.dataset) fea_numpy = fea_all.cpu().numpy() np.savetxt(save_path, fea_numpy[1:], fmt='%.6f', delimiter=',') print('Test acc: %f' % test_acc)
def add_network(values): session = get_session() with session.begin(): network_ref = models.Network() network_ref.update(values) network_ref.save(session=session) return network_ref.id
def build_model(self): """Creates and initializes the shared and controller models.""" if self.args.network_type == 'Net': self.shared = models.Network(self.args) else: raise NotImplementedError(f'Network type ' f'`{self.args.network_type}` is not ' f'defined') self.controller = models.Controller(self.args)
def network(): if request.method == 'POST': json_data = request.get_json(force=True) net = models.Network(json_data['name'], json_data['prefix']) db.session.add(net) db.session.commit() if request.method == 'GET': result = models.Network.query.first() network_schema = models.NetworkSchema() output = network_schema.dump(result).data return jsonify({'net': output})
def extract_feature(model, dataloader, save_path, load_from_disk=False, model_path=''): if load_from_disk: model = models.Network(base_net='alexnet', n_class=31) model.load_state_dict(torch.load(model_path)).to(DEVICE) model.eval() with torch.no_grad(): for inputs, labels in dataloader: inputs, labels = inputs.to(DEVICE), labels.to(DEVICE) feas = model.get_features(inputs) labels = labels.view(labels.size(0), 1).float() x = torch.cat((feas, labels), dim=1) fea_numpy = x.cpu().numpy() np.savetxt(save_path, fea_numpy[1:], fmt='%.6f', delimiter=',')
def GetOrCreateNetwork(self, download_bandwidth_kbps, upload_bandwidth_kbps, round_trip_time_ms, packet_loss_rate, protocol_str, load_type): network_type = NetworkPrettyString(download_bandwidth_kbps, upload_bandwidth_kbps, round_trip_time_ms, packet_loss_rate, protocol_str, load_type) query = models.Network.all() query.filter("network_type = ", network_type) networks = query.fetch(1) if networks: return networks[0] network = models.Network( network_type=network_type, download_bandwidth_kbps=download_bandwidth_kbps, upload_bandwidth_kbps=upload_bandwidth_kbps, round_trip_time_ms=round_trip_time_ms, packet_loss_rate=packet_loss_rate, protocol=protocol_str, load_type=load_type) network.put() return network
data_test = data_load.load_data(data_folder + domain['tar'] + 'images/', BATCH_SIZE['tar'], 'test') data_train = data_load.load_data(data_folder + domain['src'] + 'images/', BATCH_SIZE['src'], 'train', train_val_split=True, train_ratio=.8) dataloaders['train'], dataloaders['val'], dataloaders['test'] = data_train[ 0], data_train[1], data_test print('Data loaded: Source: {}, Target: {}'.format(args.source, args.target)) # Finetune if args.finetune == 1: print('Begin fintuning...') net = models.Network(base_net=args.model_name, n_class=args.num_class).to(DEVICE) criterion = nn.CrossEntropyLoss() optimizer = get_optimizer(net) if not os.path.exists('save_model/'): os.makedir('save_model/') save_path = 'save_model/best_{}_{}.pth'.format(args.model_name, args.source) model_best, best_acc, acc_hist = finetune(net, dataloaders, optimizer, criterion, save_path, use_lr_schedule=False) print('Finetune completed!') # Extract features from finetuned model
''' 进行数据读入,id为文件夹名称 ''' for id in range(2): id_string = str(id) for filename in glob(prev_dir + id_string + '\\*.jpg'): print(filename) ''' 提取出图片编号,并设置data_label[编号] = value ''' position = filename.replace(prev_dir + id_string + '\\', '') position = position.replace(after_dir, '') print(position) data_label[int(position)] = id # if there is GPU, choose GPU else CPU device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print('use device ', device) ''' 生成网络 ''' net = models.Network() net = net.float() net.to(device=device) all_data = models.Reader(prev_dir, data_label) batch_size = 4 test_loader = DataLoader(all_data, batch_size=batch_size, shuffle=True) print('Load data finish, ready to train') PATH = './model.pth' net.load_state_dict(torch.load(PATH)) correct = 0
return len(intersection) / len(union) device = 'cuda' if torch.cuda.is_available() else 'cpu' # specify directory of a learned model loaddir = sys.argsv[1] # load trained parameters to a network with open(loaddir + 'args.pkl', 'rb') as f: variables = pickle.load(f) args = variables[0] params = torch.load(loaddir + 'cnn_microscopy.pth', map_location=device) model = models.Network().to(device) model.load_state_dict(params) model.eval() # image size of a test image image_size = torch.Tensor([64, 64, 4]).to(device) # minimum coordinates of voxels of test image defaults = utils.gen_defaults(1/image_size, device, centering=False) lossclass = loss.LocationAndConfidenceLoss(defaults, 1/image_size, default_centering=False, negapos_ratio=3).to(device) # add random or fixed lateral drift # translation = numpy.random.randint(-2, 2, size=(4, 2)) # translation[2] = [0, 0] resolution_high = args.resolution_xy_low / args.scale_xy z_list = numpy.linspace(0, args.resolution_depth_low * (args.low_depth-1), args.low_depth)
log_name = './log/full_model' cpt_name = '/full_model_' writer = SummaryWriter(log_name) print("torch.cuda.is_available: ", torch.cuda.is_available()) print("torch.cuda.device_count: ", torch.cuda.device_count()) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") multiGPUs = [0, 1, 2, 3] netT = models.ResNet() sketExt = models.PWCExtractor() imagExt = models.PWCExtractor() flowEst = models.Network() blenEst = models.blendNet() flowRef = models.UNet(14, 8) ImagRef = model_deform.DeformUNet(21, 15) W = 576 H = 384 flowBackWarp = models.backWarp(W, H) occlusiCheck = models.occlusionCheck(W, H) if torch.cuda.device_count() >= 1: netT = nn.DataParallel(netT, device_ids=multiGPUs) sketExt = nn.DataParallel(sketExt, device_ids=multiGPUs) imagExt = nn.DataParallel(imagExt, device_ids=multiGPUs) flowEst = nn.DataParallel(flowEst, device_ids=multiGPUs) blenEst = nn.DataParallel(blenEst, device_ids=multiGPUs)
def main(): parser = argparse.ArgumentParser(description='DeepLoco') parser.add_argument('--batch-size', type=int, default=50, metavar='N', help='input batch size for training (default: 10)') parser.add_argument('--test-batch-size', type=int, default=50, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--epochs', type=int, default=10, metavar='N', help='number of epochs to train (default: 10)') parser.add_argument('--lr', type=float, default=1e-3, metavar='M', help='learning rate (default: 0.001)') parser.add_argument('--no-cuda', action='store_true', default=False, help='disable CUDA training') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument( '--log-interval', type=int, default=10, metavar='N', help='how many batches to wait before logging training status') parser.add_argument( '--low-patchsize', type=int, default=64, metavar='N', help='patch size of data in low resolution (default: 16)') parser.add_argument('--low-depth', type=int, default=4, metavar='N', help='depth of data in low resolution (default: 4)') parser.add_argument( '--resolution-xy-low', type=int, default=192, metavar='N', help= 'resolution(nm/pixel) of xy plane in low resolution image (default: 192)' ) parser.add_argument( '--resolution-depth-low', type=int, default=400, metavar='N', help= 'resolution(nm/plane) of depth in low resolution image (default: 400)') parser.add_argument( '--scale-xy', type=int, default=8, metavar='N', help='scaling factor of horizontal direction (default: 8)') parser.add_argument('--scale-depth', type=int, default=8, metavar='N', help='scaling factor of depth (default: 8)') parser.add_argument('--min-weight', type=float, default=1.0, metavar='F', help='minimum weight of a molecule (default: 1.0)') parser.add_argument('--max-weight', type=float, default=1.0, metavar='F', help='maximum weight of a molecule (default: 1.0)') parser.add_argument( '--num-particle-train', type=int, default=5, metavar='N', help= 'number of fluorescent particles in one frame in training data (default: 3)' ) parser.add_argument( '--num-particle-test', type=int, default=3, metavar='N', help= 'number of fluorescent particles in one frame int test data (default: 1)' ) parser.add_argument('--num-data-train', type=int, default=10000, metavar='N', help='number of training data (default: 10000)') parser.add_argument('--num-data-test', type=int, default=1000, metavar='N', help='number of test data (default: 1000)') parser.add_argument('--save-model', action='store_true', default=False, help='For Saving the current Model') parser.add_argument( '--savedir', default='./data/learned_models/', help= 'save directory is created inside this directory (default="data/learned_models")' ) args = parser.parse_args() use_cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(args.seed) numpy.random.seed(args.seed) device = torch.device('cuda' if use_cuda else 'cpu') kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {} # random lateral drifts within plus/minus 48 nm resolution_high = args.resolution_xy_low / args.scale_xy z_list = numpy.linspace(0, args.resolution_depth_low * (args.low_depth - 1), args.low_depth) aug = augmentation.RandomTranslation(2, 2, z_list, resolution_high) # train set trainset = datasets.RandomDataset( low_patchsize=args.low_patchsize, low_depth=args.low_depth, resolution_xy_low=args.resolution_xy_low, resolution_depth_low=args.resolution_depth_low, scale_xy=args.scale_xy, scale_depth=args.scale_depth, min_weight=args.min_weight, max_weight=args.max_weight, num_particles=args.num_particle_train, data_size=args.num_data_train, augmentation=aug) train_loader = torch.utils.data.DataLoader(trainset, batch_size=args.batch_size, shuffle=True, collate_fn=datasets.collate_fn, **kwargs) # test set (parameters are same as train set) testset = datasets.RandomDataset( low_patchsize=args.low_patchsize, low_depth=args.low_depth, resolution_xy_low=args.resolution_xy_low, resolution_depth_low=args.resolution_depth_low, scale_xy=args.scale_xy, scale_depth=args.scale_depth, min_weight=args.min_weight, max_weight=args.max_weight, num_particles=args.num_particle_test, data_size=args.num_data_test) test_loader = torch.utils.data.DataLoader(testset, batch_size=args.test_batch_size, shuffle=False, collate_fn=datasets.collate_fn, **kwargs) # minimum and maximum coordinate of x, y, z of the target space xlim = (0, args.resolution_xy_low * args.low_patchsize) ylim = (0, args.resolution_xy_low * args.low_patchsize) zlim = (0, args.resolution_depth_low * args.low_depth) # minimum coordinate coord_min = torch.Tensor((xlim[0], ylim[0], zlim[0])) # maximum coordinate coord_max = torch.Tensor((xlim[1], ylim[1], zlim[1])) # regression model model = models.Network().to(device) # size of the image image_size = torch.Tensor( [args.low_patchsize, args.low_patchsize, args.low_depth]).to(device) # minimum coordinates of each voxel defaults = utils.gen_defaults(1 / image_size, device, centering=False) # loss function (binary cross entropy + l1 distance) lossfunc = loss.LocationAndConfidenceLoss(defaults, 1 / image_size, default_centering=False, negapos_ratio=3).to(device) trainloss_history = [] testloss_history = [] optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) # iterate train and test for epoch in range(1, args.epochs + 1): trainloss = train(args, model, device, train_loader, optimizer, lossfunc, epoch) testloss = test(args, model, device, test_loader, lossfunc) trainloss_history.append(trainloss) testloss_history.append(testloss) # save initial model if epoch == 1 and args.save_model: dirname = make_savedir(args.savedir) if args.save_model: model = model.cpu() torch.save(model.state_dict(), dirname + '/cnn_microscopy.pth') with open(dirname + '/args.pkl', mode='wb') as f: pickle.dump([ args, train_loader, test_loader, trainloss_history, testloss_history ], f)
def run_experiment(args, seed): if args.train is not None: train_dl = MTCDataLoader(args.train) if args.dev is None: train_data, dev_data = train_dl.train_test_split( test_size=args.devsize) else: dev_dl = MTCDataLoader(args.dev) train_data = list(train_dl.sequences()) dev_data = list(dev_dl.sequences()) if args.test is not None: test_dl = MTCDataLoader(args.test) test_data = list(test_dl.sequences()) else: test_data = [] print( f'Train: {len(train_data)}, Dev: {len(dev_data)}, Test: {len(test_data)}' ) elif args.dataconf: if args.dataconf not in CONFIGS: print(f"Error. {args.dataconf} is not a valid data configuration.", file=sys.stderr) print(f"Choose one of: {' '.join(DataConf.confs.keys())}", file=sys.stderr) raise SystemExit train_data, dev_data, test_data = DataConf().getData( args.dataconf, args.devsize, args.testsize, args.cross_class_size) if args.test: print("Warning. Command line argument --test_data ignored.", file=sys.stderr) if args.savetrain: MTCDataLoader.writeJSON(args.savetrain, train_data) if args.savedev: MTCDataLoader.writeJSON(args.savedev, dev_data) if args.savetest: MTCDataLoader.writeJSON(args.savetest, test_data) cat_encoders = [CategoricalEncoder(f) for f in args.categorical_features] scaler = (StandardScaler if args.scaler == 'zscore' else MinMaxScaler if args.scaler == 'minmax' else IdentityScaler) cont_encoders = [ ContinuousEncoder(f, scaler=scaler) for f in args.continuous_features ] encoders = cat_encoders + cont_encoders train_selector, dev_selector = None, None if args.precompute_examples: if args.example_type == 'pairs': train_selector = samplers.PairSelector( pos_neg_ratio=args.pn_ratio, random_sample=args.sample_ratio) dev_selector = samplers.PairSelector(pos_neg_ratio=args.pn_ratio) else: train_selector = samplers.TripletSelector( sample_ratio=args.sample_ratio) dev_selector = samplers.TripletSelector( sample_ratio=args.sample_ratio) dataset_constructor = (datasets.Dataset if args.online_sampler else datasets.DupletDataset if args.example_type == 'pairs' else datasets.TripletDataset) train = dataset_constructor(train_data, *encoders, batch_size=args.batch_size, selector=train_selector, label='tunefamily', train=True).fit() dev = dataset_constructor(dev_data, *encoders, batch_size=args.batch_size, selector=dev_selector, label='tunefamily', train=False).fit() if args.precompute_examples: print(train_selector) print(dev_selector) collate_fn = datasets.collate_fn if args.balanced_batch_sampler: train_batch_sampler = datasets.BalancedBatchSampler( train.labels, n_classes=args.n_classes, n_samples=args.n_samples) dev_batch_sampler = datasets.BalancedBatchSampler( dev.labels, n_classes=args.n_classes, n_samples=args.n_samples) train_loader = DataLoader(train, batch_sampler=train_batch_sampler, collate_fn=collate_fn, num_workers=args.n_workers) dev_loader = DataLoader(dev, batch_sampler=dev_batch_sampler, collate_fn=collate_fn, num_workers=args.n_workers) elif not args.precompute_examples: train_loader = DataLoader(train, batch_size=args.batch_size, shuffle=True, collate_fn=collate_fn, num_workers=args.n_workers) dev_loader = DataLoader(dev, batch_size=args.batch_size, collate_fn=collate_fn, num_workers=args.n_workers) else: train_loader, dev_loader = datasets.DataLoader( train), datasets.DataLoader(dev) device = 'cuda' if args.cuda else 'cpu' emb_dims = [(encoder.size(), args.emb_dim) for encoder in cat_encoders] if args.model.lower() == 'rnn': network = models.RNN(emb_dims, args.hid_dim, cont_features=len(cont_encoders), n_layers=args.n_layers, cell=args.cell, dropout=args.dropout, bidirectional=args.bidirectional) elif args.model.lower() == 'cnn': network = models.CNN(emb_dims, cont_features=len(cont_encoders), kernel_sizes=tuple(args.kernel_sizes), highway_layers=args.highway_layers, out_channels=args.out_channels, dropout=args.dropout) else: network = models.CNNRNN(emb_dims, cont_features=len(cont_encoders), kernel_sizes=tuple(args.kernel_sizes), highway_layers=args.highway_layers, out_channels=args.out_channels, dropout=args.dropout, cell=args.cell, bidirectional=args.bidirectional, n_layers=args.n_layers) if args.example_type == 'pairs': if not args.online_sampler: if args.loss == 'cosine': loss_fn = models.CosinePairLoss(weight=args.weight, margin=args.margin) else: loss_fn = models.EuclideanPairLoss(margin=args.margin) model = models.TwinNetwork(network, loss_fn).to(device) # margin 0.16, 0.4 else: if args.loss == 'cosine': loss_fn = models.OnlineCosinePairLoss( samplers.HardNegativePairSelector(), weight=args.weight, margin=args.margin, cutoff=args.cutoff_cosine) else: loss_fn = models.OnlineEuclideanPairLoss( samplers.HardNegativePairSelector(), margin=args.margin) model = models.Network(network, loss_fn).to(device) else: if not args.online_sampler: if args.loss == 'cosine': loss_fn = models.CosineTripletLoss(margin=args.margin) else: loss_fn = models.EuclidianTripletLoss(margin=args.margin) model = models.TripletNetwork(network, loss_fn).to(device) else: if args.loss == 'cosine': loss_fn = models.OnlineCosineTripletLoss( samplers.NegativeTripletSelector( method=args.negative_pair_selector, margin=args.margin), margin=args.margin) else: loss_fn = models.OnlineEuclideanTripletLoss( samplers.NegativeTripletSelector( method=args.negative_pair_selector, margin=args.margin), margin=args.margin) model = models.Network(network, loss_fn).to(device) print(model) for embedding in model.network.embs: embedding.to(device) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( optimizer, 'min', verbose=True, patience=args.lr_scheduler, threshold=1e-4, cooldown=5) print( f'Number of parameters: {sum(p.nelement() for p in model.parameters())}' ) try: early_stop = fit_model(train_loader, dev_loader, model, optimizer, scheduler, args.epochs, args.log_interval, plot=False, patience=args.patience, early_stop_score=args.early_stop_score, eval_metric=args.loss) best_score = early_stop['best'] fails = early_stop['fails'] best_params = early_stop['best_params'] val_scores = early_stop['val_scores'] except EarlyStopException as e: print("Early stopping training") best_score = e.best fails = e.fails best_params = e.best_params val_scores = e.val_scores model.load_state_dict(best_params) model.eval() # serialize model if necessary print("Best", args.early_stop_score, best_score) if args.save_encodings is not None and args.dev is not None: utils.save_encodings(dev, model, args.save_encodings, 'dev') if args.test is not None: train_label_set = list(set(train_loader.dataset.labels)) test = dataset_constructor(test_data, *encoders, batch_size=args.batch_size, label='tunefamily', train=False).fit() test_scores = metrics.evaluate_ranking(model, test, train_label_set=train_label_set, metric=args.loss) message = 'Testing:\n' message += f' silouhette: {test_scores["silhouette"]:.3f}\n' message += f' MAP: {test_scores["MAP"]:.3f}\n' message += f' MAP (seen): {test_scores["MAP seen labels"]:.3f}\n' message += f' MAP (unseen): {test_scores["MAP unseen labels"]:.3f}\n' message += f' Margin: {test_scores["margin_score"]:.3f}' print(message) with open(f'{args.results_dir}/{args.results_path}', 'a+') as f: f.write( json.dumps( { "params": vars(args), "dev_score": float(best_score), "val_scores": val_scores, "test_scores": test_scores if args.test is not None else {}, "fails": fails, "seed": seed, "now": str(datetime.now()) }, cls=NumpyEncoder) + '\n') if args.save_encodings is not None and args.test is not None: utils.save_encodings(test, model, args.save_encodings, 'test') return model