# LD_LIBRARY_PATH /usr/local/cuda-8.0/lib64:$LD_LIBRARY_PATH os.environ["CUDA_VISIBLE_DEVICES"] = "2" def eval_print(y_true, y_pred, y_logits): print("accuracy %.6f" % metrics.accuracy_score(y_true, y_pred)) print("Precision %.6f" % metrics.precision_score(y_true, y_pred)) print("Recall %.6f" % metrics.recall_score(y_true, y_pred)) print("f1_score %.6f" % metrics.f1_score(y_true, y_pred)) fpr, tpr, threshold = metrics.roc_curve(y_true, y_logits) print("auc_socre %.6f" % metrics.auc(fpr, tpr)) batch_size = 512 loader = DataLoader(train_mode=False) model = AutoEncoder() config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) # store saver = tf.train.Saver() saver.restore(sess, '../model/ae_model') print('begin testing:') losses = [] for iter, indices in enumerate(range(0, loader.test_size, batch_size)): #
idx_train, idx_valid = train_test_split(idx, test_size=0.1) x_train, x_valid = x_train[idx_train], x_train[idx_valid] y_train, y_valid = y_train[idx_train], y_train[idx_valid] dataset_train = GetDataset(x=x_train, y=y_train, num_classes=max(y_test) + 1, preproc_fn=preproc_fn, augment_fn=TrainingAugmentation.augmentation) dataset_valid = GetDataset(x=x_valid, y=y_valid, num_classes=max(y_test) + 1, preproc_fn=preproc_fn, augment_fn=TestingAugmentation.augmentation) dataloader = DataLoader(dataset=dataset_train, batch_size=cfg.MODEL.BATCH_SIZE) """ Pre-occupy the gpu, prevent after loading data but found gpu has already been taken""" if cfg.MODEL.BACKBONE == "": model = build_model(input_shape=(256, 256, 3), output_num=2, use_deformable=cfg.MODEL.USE_DEFORMABLE_CONV, num_deform_group=cfg.MODEL.NUM_DEFORM_GROUP) else: model = build_resnet_model(input_shape=(256, 256, 3), output_num=2, use_deformable=cfg.MODEL.USE_DEFORMABLE_CONV, num_deform_group=cfg.MODEL.NUM_DEFORM_GROUP, backbone=cfg.MODEL.BACKBONE) optim = tf.keras.optimizers.SGD(lr=cfg.MODEL.LEARNING_RATE, nesterov=True,
net.load_state_dict(torch.load(args.load)) print('Model loaded from {}'.format(args.load)) if args.gpu: net.cuda() #net = torch.nn.DataParallel(net, device_ids=args.gpu).cuda() # cudnn.benchmark = True # faster convolutions, but more memory input_path = '../data/train_feature.npy' target_path = '../data/train_social_label.npy' train_set = get_train_data(input_path, target_path) test_set = get_test_data(input_path, target_path) train_data_loader = DataLoader(dataset=train_set, num_workers=4, batch_size=args.batchsize, shuffle=True) test_data_loader = DataLoader(dataset=test_set, num_workers=4, batch_size=args.batchsize, shuffle=False) # predit(net=net, # train_loader = train_data_loader, # val_loader = test_data_loader, # epochs=args.epochs, # batch_size=args.batchsize, # lr=args.lr, # gpu=args.gpu, # img_scale=1, # args =args)
def test_load_csv_data(): valid_csv_file_path = '../../examples/image_data/sample.csv' invalid_csv_file_path = 'invalid_csv_file_path' valid_image_dimensions = (48, 48) channels = 1 invalid_image_dimensions = (50, 77) csv_label_col = 0 csv_image_col = 1 valid_target_labels = [0, 1, 2, 3, 4, 5, 6] invalid_target_labels = [8, 9, 10] # should raise error when not given csv column indices for images and labels with pytest.raises(ValueError): DataLoader(from_csv=True, target_labels=valid_target_labels, datapath=valid_csv_file_path, image_dimensions=valid_image_dimensions, csv_label_col=csv_label_col) # should raise error when given invalid csv file path with pytest.raises(FileNotFoundError): DataLoader(from_csv=True, target_labels=valid_target_labels, datapath=invalid_csv_file_path, image_dimensions=valid_image_dimensions, csv_label_col=csv_label_col, csv_image_col=csv_image_col) # should raise error when given invalid csv column indices with pytest.raises(ValueError): DataLoader(from_csv=True, target_labels=valid_target_labels, datapath=valid_csv_file_path, image_dimensions=valid_image_dimensions, csv_label_col=csv_label_col, csv_image_col=10) # should raise error when given empty target_labels list with pytest.raises(ValueError): DataLoader(from_csv=True, datapath=valid_csv_file_path, image_dimensions=valid_image_dimensions, csv_label_col=csv_label_col, csv_image_col=csv_image_col) # should raise error when not given image dimensions with pytest.raises(ValueError): DataLoader(from_csv=True, target_labels=valid_target_labels, datapath=valid_csv_file_path, csv_label_col=csv_label_col, csv_image_col=csv_image_col) # should raise error when given invalid image dimensions with pytest.raises(ValueError): DataLoader(from_csv=True, target_labels=valid_target_labels, datapath=valid_csv_file_path, image_dimensions=invalid_image_dimensions, csv_label_col=csv_label_col, csv_image_col=csv_image_col) # should raise error if no image samples found in csv file with pytest.raises(AssertionError): data_loader = DataLoader(from_csv=True, target_labels=invalid_target_labels, datapath=valid_csv_file_path, image_dimensions=valid_image_dimensions, csv_label_col=csv_label_col, csv_image_col=csv_image_col) data_loader.get_data() data_loader = DataLoader(from_csv=True, target_labels=valid_target_labels, datapath=valid_csv_file_path, image_dimensions=valid_image_dimensions, csv_label_col=csv_label_col, csv_image_col=csv_image_col) images, labels = data_loader.get_data() # should return non-empty image and label arrays when given valid arguments assert len(images) > 0 and len(labels) > 0 # should return same number of labels and images when given valid arguments assert len(images) == len(labels) # should reshape the images to given valid image_dimensions assert list(images.shape[1:]) == list(valid_image_dimensions) + [channels]
def main(args): if not torch.cuda.is_available(): logging.info('no gpu device available') sys.exit(1) np.random.seed(args.seed) torch.cuda.set_device(args.gpu) cudnn.benchmark = True torch.manual_seed(args.seed) cudnn.enabled = True torch.cuda.manual_seed(args.seed) logging.info('gpu device = %d' % args.gpu) logging.info("args = %s", args) criterion = nn.BCELoss() criterion = criterion model = Network(args.init_channels, CLASSES, args.layers, criterion) model = model.cuda() logging.info("param size = %fMB", utils.count_parameters_in_MB(model)) optimizer = torch.optim.SGD(model.parameters(), args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) # * Data handling here train_data = DataLoader(x_path="E:/URBAN_DATASET_BGH/train_x.npy", y_path="E:/URBAN_DATASET_BGH/train_y.npy", batch_size=args.batch_size, shuffle=True) train_queue = train_data.make_queue() train_queue = train_queue[:int(len(train_queue) * args.train_portion)] val_data = DataLoader(x_path="E:/URBAN_DATASET_BGH/val_x.npy", y_path="E:/URBAN_DATASET_BGH/val_y.npy", batch_size=args.batch_size, shuffle=True) valid_queue = val_data.make_queue() scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( optimizer, float(args.epochs), eta_min=args.learning_rate_min) architect = Architect(model, args) mIoUs = [0] for epoch in range(args.epochs): scheduler.step() lr = scheduler.get_lr()[0] logging.info('epoch %d lr %e', epoch, lr) genotype = model.genotype() logging.info('genotype = %s', genotype) # training train_acc, train_iou = train(train_queue, valid_queue, model, architect, criterion, optimizer, lr) # here should be logging.info('Final Train Acc %f', train_acc) logging.info('Final Train mIoU %f', train_iou) # validation valid_acc, valid_iou = infer(valid_queue, model, criterion) logging.info('Final Valid Acc %f', valid_acc) logging.info('Final Valid mIoU %f', valid_iou) # save the final genotype if (max(mIoUs) < valid_iou): print( "Writing the computed genotype tp ./cnn/final_models/final_genotype.py" ) utils.write_genotype(genotype) mIoUs.append(valid_iou) np.save(os.path.join(args.save, "mIoUs.npy"), mIoUs)
d_optimizer.load_state_dict(check_point['d_optimizer']) generator.module.load_state_dict(check_point['generator']) discriminator.module.load_state_dict(check_point['discriminator']) else: global_step = 0 loss_log = {'g_loss': [], 'd_loss': []} global_step += 1 stage = 0 for i in range(len(iterations)): if global_step > iterations[i]: stage = i else: break dataset = DataLoader(data_path, batch_size[stage], resize=resolution[stage] / 64, preload=False) generator.module.set_resolution(resolution[stage]) discriminator.module.set_resolution(resolution[stage]) print( f'Starting at stage {stage}, batch_size:{batch_size[stage]}, resolution:{resolution[stage]}' ) # Training start = global_step for global_step in trange(start, iterations[-1] + 1): epoch_idx, batch_idx, real_image = dataset.get() # fade in fade_in_alpha = -1 if global_step < iterations[stage] + fade_in_itrs[stage]:
if opt.method == 'policy-MPUR': policy_network_mpur = torch.load(model_path)['model'] policy_network_mpur.stats = stats forward_model.policy_net = policy_network_mpur.policy_net forward_model.policy_net.stats = stats forward_model.policy_net.actor_critic = False forward_model.intype('gpu') forward_model.stats = stats if 'ten' in opt.mfile: forward_model.p_z = torch.load( path.join(opt.model_dir, f'{opt.mfile}.pz')) return forward_model, value_function, policy_network_il, policy_network_mper, stats dataloader = DataLoader(None, opt, 'i80') forward_model, value_function, policy_network_il, policy_network_mper, data_stats = load_models( ) splits = torch.load(path.join(data_path, 'splits.pth')) if opt.u_reg > 0.0: forward_model.train() forward_model.opt.u_hinge = opt.u_hinge if hasattr(forward_model, 'value_function'): forward_model.value_function.train() planning.estimate_uncertainty_stats(forward_model, dataloader, n_batches=50, npred=opt.npred) gym.envs.registration.register(id='I-80-v1',
parser.add_argument('--num_classes', type=int, default=10, help='number of classes') parser.add_argument('--lr', type=float, default=1e-3, help='learning rate') parser.add_argument('--epoches', type=int, default=20, help='epochs of training') parser.add_argument('--batchsize', type=int, default=64, help='batch size') #parser.add_argument('--keep_prob',type = float,default = 0.5,help = 'keep probality for dropout') opt = parser.parse_args() print(opt) criterion = nn.CrossEntropyLoss(size_average=False) dataloader = DataLoader(opt.dataset, opt.batchsize) trainloader, testloader = dataloader.load() all_test_loss = {} #all_train_loss = [] all_test_acc = {} step_test_loss = {} step_test_acc = {} #all_train_acc = [] models = { 'L1': VGG(vgg_name=opt.net, Fc_BN=False, Conv_BN=True, drop_prob=0, channels=opt.channels,
from utils import Log if __name__ == '__main__': device = torch.device("cuda:0") loader = DataLoader(split='training',path_to_data=Config.data_path) trainloader= data.DataLoader(loader, batch_size=Config.train_batch_size, num_workers=Config.train_num_workers, shuffle=True,drop_last=True) loader = DataLoader(split='testing',path_to_data=Config.data_path) testLoader= data.DataLoader(loader, batch_size=Config.test_batch_size, num_workers=Config.test_num_workers, shuffle=False,drop_last=False) (batch,lbls)=next(iter(trainloader)) predicted_size=list(lbls.size())[1] input_size=list(batch.size())[1] # model = models.resnet18(pretrained=False) # model.conv1 = nn.Conv2d(input_size, 64, kernel_size=7, stride=2, padding=3, bias=False) # num_ftrs = model.fc.in_features # model.fc = torch.nn.Linear(num_ftrs, predicted_size)
def train_net(net, epochs=5, data_dir='data/cells/', n_classes=2, lr=0.001, val_percent=0.1, save_cp=True, gpu=False): loader = DataLoader(data_dir) N_train = loader.n_train() optimizer = optim.SGD(net.parameters(), lr=lr, momentum=0.99, weight_decay=0.005) for epoch in range(epochs): print('Epoch %d/%d' % (epoch + 1, epochs)) print('Training...') net.train() loader.setMode('train') epoch_loss = 0 for i, (img, label) in enumerate(loader): shape = img.shape img = torch.from_numpy(img.reshape(1, 1, shape[0], shape[1])).float() if gpu: img = img.cuda() pred = net(img) loss = getLoss(pred, label) epoch_loss += loss.item() print('Training sample %d / %d - Loss: %.6f' % (i + 1, N_train, loss.item())) # optimize weights optimizer.zero_grad() loss.backward() optimizer.step() torch.save(net.state_dict(), join(data_dir, 'checkpoints') + '/CP%d.pth' % (epoch + 1)) print('Checkpoint %d saved !' % (epoch + 1)) print('Epoch %d finished! - Loss: %.6f' % (epoch + 1, epoch_loss / i)) # displays test images with original and predicted masks after training loader.setMode('test') net.eval() with torch.no_grad(): for _, (img, label) in enumerate(loader): shape = img.shape img_torch = torch.from_numpy(img.reshape(1, 1, shape[0], shape[1])).float() if gpu: img_torch = img_torch.cuda() pred = net(img_torch) pred_sm = softmax(pred) _, pred_label = torch.max(pred_sm, 1) plt.subplot(1, 3, 1) plt.imshow(img * 255.) plt.subplot(1, 3, 2) plt.imshow(label * 255.) plt.subplot(1, 3, 3) plt.imshow(pred_label.cpu().detach().numpy().squeeze() * 255.) plt.show()
def Using_DataLoader(): ''' ############################################## Step #2: Three variables are required to run DataLoader. Variable #1, Data_File_Path: A path and data file must be specified. Variable #2, dataType: CAEN digitizers will output data in one of three formats: DAFCA_STD, DAFCA_DPP_MIXED, or DAFCA_DPP_LIST. This defines the data structure for how data is pulled in. We will go through DAFCA_DPP_MIXED thoroughly. Variable #3, Num_Samples: This is the number of samples in a waveform, not the number of waves ############################################## ''' ############################################## Data_File_Path = "C:/Users/Giha/Documents/N3Glass/X1/1/dataFile0.dat" dataType = DataLoader.DAFCA_DPP_MIXED Num_Samples = 500 ############################################## Data = DataLoader(Data_File_Path, dataType, Num_Samples) print("DataLoader has two useful functions to new users.") print("\n") print( "The first useful function will tell you how many waves are in the specified file." ) print("\n") time.sleep(3) Number_of_data_structures = Data.GetNumberOfWavesInFile() print("In : " + str(Data_File_Path) + " , there are " + str(Number_of_data_structures) + " pulses, or more specifically, that many data structures.") print("\n") time.sleep(1) print( "The second useful function will load in a specified number of waves or data structures." ) print("\n") time.sleep(1) var = input( "Lets read in one wave and break down what we are reading in. Sound good? (Y/N): " ) if var == "Y": Waves = Data.LoadWaves(1) print("\n") time.sleep(1) print("This one wave has the following structure:") print("\n") print('EventSize is the event size in number of bytes: ' + str(Waves['EventSize'][0])) print('Format is referring to the CAEN datatype: ' + str(Waves['Format'][0])) print('Channel is referring to the input channel on the digitizer: ' + str(Waves['Channel'][0])) print('Baseline is the baseline of the pulse: ' + str(Waves['Baseline'][0])) print('ShortGate is the tail integral of the pulse: ' + str(Waves['ShortGate'][0])) print('LongGate is the total integral of the pulse: ' + str(Waves['LongGate'][0])) print( 'TimeTag is a course absolute time for when a pulse begins (ns): ' + str(Waves['TimeTag'][0])) print( 'Extras can be thought of as a finer time that can be combined with TimeTag: ' + str(Waves['Extras'][0])) print('Samples are the actual wave samples: ' + str(Waves['Samples'][0])) print("\n") time.sleep(1) print( "Baseline, ShortGate, and LongGate have generally not been used because they do not necessarily accuratley represent what they claim to." ) print( "For more infomration (especially when using Extras), please read the UM2580 DPP PSD User Manual found on CAEN's website." ) print("\n") time.sleep(1) print( "Now let's plot this pulse. When you are happy with looking at the pulse, close the figure." ) x = np.arange(0, Num_Samples * 2, 2) y = Waves['Samples'][0] plt.plot(x, y) plt.xlabel("Time (ns)") plt.xlabel("Digitizer Units") plt.show() plt.close() print("\n") time.sleep(1) print( "From this pulse, we can attain useful information, but first we must subtract the baseline." ) print("\n") print( "In DAFCA, the user can specify how much data of the pulse they want before the rising edge. This way a sufficient amount of data can be acquired to determine the baseline." ) print( "Generally, the baseline is determined by averaging the first 50 samples of the pulse." ) time.sleep(1) Baseline = np.average(Waves['Samples'][0][0:50]) print("\n") print("In this case, the baseline of the pulse is: " + str(Baseline)) print("\n") print("We can now subtract this baseline and plot the pulse.") print("\n") Baseline_Subtracted_Wave = Waves['Samples'][0] - Baseline x = np.arange(0, Num_Samples * 2, 2) y = Baseline_Subtracted_Wave plt.plot(x, y) plt.xlabel("Time (ns)") plt.xlabel("Digitizer Units") plt.show() plt.close() print("We can now attain some useful information about the pulse:") print("\n") Pulse_Height = np.max(Baseline_Subtracted_Wave) Max_Index = np.argmax(Baseline_Subtracted_Wave) negativeSamples = np.nonzero( Baseline_Subtracted_Wave[Max_Index:] < 0)[0] Pulse_Integral = np.sum( Baseline_Subtracted_Wave[:Max_Index + negativeSamples[0]]) * 2 dynamic_range_volts = 0.5 number_of_bits = 15 VperLSB = dynamic_range_volts / (2**number_of_bits) F = 0.2 Start_Time = CFD(Baseline_Subtracted_Wave, F) print("Pulse Height (Digitizer Units): " + str(Pulse_Height)) print("Pulse Integral (Digitizer Units-ns): " + str(Pulse_Integral)) print("Start Time (ns): " + str(Start_Time)) print("\n") print( "To convert from Digitizer Units to Votlage, it is necessary to multiply by the dynamic range of the digitizer and divide by 2^(number of bits). In this case the conversion is 0.5/2^14. This yields:" ) print("\n") Pulse_Height = np.max(Baseline_Subtracted_Wave) * VperLSB Pulse_Integral = np.sum( Baseline_Subtracted_Wave[:Max_Index + negativeSamples[0]]) * 2 * VperLSB print("Pulse Height (mV): " + str(Pulse_Height)) print("Pulse Integral (mV-ns): " + str(Pulse_Integral)) print("\n") print("The next code, GetWaveData, does these calculations for us.") print("\n") x = np.arange(0, Num_Samples * 2, 2) y = Baseline_Subtracted_Wave plt.plot(x, y) plt.xlabel("Time (ns)") plt.xlabel("Digitizer Units") plt.show() plt.close() else: print("Fine.")
def main(): opt = parse_args() device = 'cuda' if torch.cuda.is_available() else 'cpu' random.seed(opt.seed) numpy.random.seed(opt.seed) torch.manual_seed(opt.seed) data_path = 'traffic-data/state-action-cost/data_i80_v0' dataloader = DataLoader(None, opt, 'i80') (forward_model, value_function, policy_network_il, policy_network_mper, data_stats) = load_models(opt, data_path, device) splits = torch.load(path.join(data_path, 'splits.pth')) if opt.u_reg > 0.0: forward_model.train() forward_model.opt.u_hinge = opt.u_hinge if hasattr(forward_model, 'value_function'): forward_model.value_function.train() planning.estimate_uncertainty_stats(forward_model, dataloader, n_batches=50, npred=opt.npred) gym.envs.registration.register( id='I-80-v1', entry_point='map_i80_ctrl:ControlledI80', kwargs=dict( fps=10, nb_states=opt.ncond, display=False, delta_t=0.1, store_simulator_video=opt.save_sim_video, show_frame_count=False, )) print('Building the environment (loading data, if any)') env_names = { 'i80': 'I-80-v1', } env = gym.make(env_names[opt.map]) plan_file = build_plan_file_name(opt) print(f'[saving to {path.join(opt.save_dir, plan_file)}]') # different performance metrics time_travelled, distance_travelled, road_completed = [], [], [] # values saved for later inspection action_sequences, state_sequences, cost_sequences = [], [], [] writer = utils.create_tensorboard_writer(opt) n_test = len(splits['test_indx']) set_start_method('spawn') pool = Pool(opt.num_processes) async_results = [] time_started = time.time() total_images = 0 for j in range(n_test): car_path = dataloader.ids[splits['test_indx'][j]] timeslot, car_id = utils.parse_car_path(car_path) car_sizes = torch.tensor(dataloader.car_sizes[sorted( list(dataloader.car_sizes.keys()))[timeslot]][car_id])[None, :] async_results.append( pool.apply_async( process_one_episode, (opt, env, car_path, forward_model, policy_network_il, data_stats, plan_file, j, car_sizes))) for j in range(n_test): simulation_result = async_results[j].get() time_travelled.append(simulation_result.time_travelled) distance_travelled.append(simulation_result.distance_travelled) road_completed.append(simulation_result.road_completed) action_sequences.append( torch.from_numpy(simulation_result.action_sequence)) state_sequences.append( torch.from_numpy(simulation_result.state_sequence)) cost_sequences.append(simulation_result.cost_sequence) total_images += time_travelled[-1] log_string = ' | '.join(( f'ep: {j + 1:3d}/{n_test}', f'time: {time_travelled[-1]}', f'distance: {distance_travelled[-1]:.0f}', f'success: {road_completed[-1]:d}', f'mean time: {torch.Tensor(time_travelled).mean():.0f}', f'mean distance: {torch.Tensor(distance_travelled).mean():.0f}', f'mean success: {torch.Tensor(road_completed).mean():.3f}', )) print(log_string) utils.log(path.join(opt.save_dir, f'{plan_file}.log'), log_string) if writer is not None: # writer.add_video( # f'Video/success={simulation_result.road_completed:d}_{j}', # simulation_result.images.unsqueeze(0), # j # ) writer.add_scalar('ByEpisode/Success', simulation_result.road_completed, j) writer.add_scalar('ByEpisode/Collision', simulation_result.has_collided, j) writer.add_scalar('ByEpisode/OffScreen', simulation_result.off_screen, j) writer.add_scalar('ByEpisode/Distance', simulation_result.distance_travelled, j) pool.close() pool.join() diff_time = time.time() - time_started print('avg time travelled per second is', total_images / diff_time) torch.save(action_sequences, path.join(opt.save_dir, f'{plan_file}.actions')) torch.save(state_sequences, path.join(opt.save_dir, f'{plan_file}.states')) torch.save(cost_sequences, path.join(opt.save_dir, f'{plan_file}.costs')) if writer is not None: writer.close()
def evaluate(self, split): sim = PanoSimulatorWithGraph(self.args, disable_rendering=True) sim.record_traj(True) self.mapper.eval() self.model.eval() self.policy.eval() vln_eval = Evaluation(split) with torch.no_grad(): if split == "val_seen": self.dataloader = self.valseendata elif split == "val_unseen": self.dataloader = self.valunseendata else: self.dataloader = DataLoader(self.args, splits=[split]) iterations = int( math.ceil( len(self.dataloader.data) / float(self.args.batch_size))) for it in tqdm(range(iterations), desc="Evaluation Progress for %s split" % split): # Load minibatch and simulator seq, seq_mask, seq_lens, batch = self.dataloader.get_batch() sim.newEpisode(batch) # Initialize the mapper xyzhe = sim.getXYZHE() spatial_map, mask = self.mapper.init_map(xyzhe) if self.args.viz_eval and it < self.args.viz_iterations: floor_maps = self.floor_maps(sim.getState()) ended = torch.zeros(self.args.batch_size, device=self.args.device).byte() viz_counter = 0 for t in range(self.args.timesteps): if self.args.policy_gt_belief: path_xyzhe, path_len = self.dataloader.path_xyzhe() else: rgb, depth, states = sim.getPanos() spatial_map, mask, ftm = self.mapper( rgb, depth, states, spatial_map, mask) del states del ftm features, _, _ = sim.getGraphNodes() P = features.shape[0] # num graph nodes belief_features = torch.empty(P, self.args.max_steps, device=self.args.device) state = None steps = self.args.max_steps - 1 belief = self.mapper.belief_map( xyzhe, self.args.filter_input_sigma).log() if t == 0: belief_pred = torch.zeros(seq.shape[0], self.args.max_steps, self.args.heading_states, belief.shape[-2], belief.shape[-1], device=spatial_map.device) belief_pred[:, 0, :, :, :] = belief.exp() sigma = self.args.filter_heatmap_sigma gridcellsize = self.args.gridcellsize * self.args.belief_downsample_factor belief_features[:, 0] = belief_at_nodes( belief.exp(), features[:, :4], sigma, gridcellsize) act_att_weights = torch.zeros(seq.shape[0], steps, torch.max(seq_lens)) obs_att_weights = torch.zeros(seq.shape[0], steps, torch.max(seq_lens)) for k in range(steps): if self.args.policy_gt_belief: target_heatmap = self.mapper.belief_map( path_xyzhe[k + 1], self.args.filter_heatmap_sigma) belief_features[:, k + 1] = belief_at_nodes( target_heatmap, features[:, :4], sigma, gridcellsize) belief_pred[:, k + 1, :, :, :] = target_heatmap else: input_belief = belief # Train a filter new_belief, obs_likelihood, state, act_att, obs_att, _ = self.model( k, seq, seq_mask, seq_lens, input_belief, spatial_map, state) belief = new_belief + obs_likelihood # Renormalize belief = belief - belief.reshape( belief.shape[0], -1).logsumexp(dim=1).unsqueeze(1).unsqueeze( 1).unsqueeze(1) belief_pred[:, k + 1, :, :, :] = belief.exp() belief_features[:, k + 1] = belief_at_nodes( belief.exp(), features[:, :4], sigma, gridcellsize) act_att_weights[:, k] = act_att obs_att_weights[:, k] = obs_att # Probs from policy aug_features = torch.cat([features, belief_features], dim=1) log_prob = self.policy(aug_features) # Take argmax action in the sim _, action_idx = log_prob.exp().max(dim=1) if self.args.viz_eval and it < self.args.viz_iterations: num_cam_views = self.args.num_pano_views * self.args.num_pano_sweeps rgb = rgb.permute(0, 2, 3, 1).reshape(num_cam_views, self.args.batch_size, rgb.shape[-2], rgb.shape[-1], 3) depth = depth.expand(-1, 3, -1, -1).permute( 0, 2, 3, 1).reshape(num_cam_views, self.args.batch_size, depth.shape[-2], depth.shape[-1], 3) # Save attention over instruction if t == 0: att_ims = [] belief_ims = [[] for n in range(self.args.batch_size)] for n in range(seq.shape[0]): instruction = self.dataloader.tokenizer.decode_sentence( seq[n]).split() act_att = act_att_weights[n].cpu().numpy() obs_att = obs_att_weights[n].cpu().numpy() valid_act_att = act_att[:, : seq_lens[n]].transpose( ) valid_obs_att = obs_att[:, : seq_lens[n]].transpose( ) fig = viz_utils.plot_att_graph( valid_act_att, valid_obs_att, instruction, seq_lens[n].item(), black_background=True) if self.args.viz_gif: att_ims.append( viz_utils.figure_to_rgb(fig)) else: fig.savefig( "%s/attention-%s-it%d-n%d.png" % (self.args.viz_folder, split, it, n), facecolor=fig.get_facecolor(), transparent=True) plt.close('all') for k in range(3): if self.args.policy_gt_belief: viz = floor_maps else: viz = self.overlay_mask(floor_maps, mask) if k >= 1: viz = self.overlay_belief(viz, belief_pred) viz = self.overlay_goal( viz, self.dataloader.goal_coords() + self.mapper.map_center[:, :2]) if k >= 2: viz = self.overlay_local_graph( viz, features, action_idx) else: viz = self.overlay_local_graph(viz, features) for n in range(len(viz)): if not ended[n]: if self.args.viz_gif: image = viz[n] * 255 # Add attention image on left min_val = image.shape[ 0] // 2 - att_ims[n].shape[0] // 2 max_val = min_val + att_ims[n].shape[0] image = np.flip( image[min_val:max_val, min_val:max_val, :], 2) image = np.concatenate( [att_ims[n], image], axis=1) # Add rgb images at bottom new_width = int(image.shape[-2] / float(rgb.shape[0])) new_height = int(new_width * rgb.shape[-3] / float(rgb.shape[-2])) rgb_ims = [ cv2.resize( rgb[i, n].cpu().detach().numpy(), (new_width, new_height)) for i in range(rgb.shape[0]) ] rgb_ims = np.concatenate(rgb_ims, axis=1) # Add depth images at bottom depth_ims = [ cv2.resize( depth[i, n].cpu().detach( ).numpy() / 200.0, (new_width, new_height)) for i in range(depth.shape[0]) ] depth_ims = np.concatenate(depth_ims, axis=1) image = np.concatenate( [image, rgb_ims, depth_ims], axis=0) belief_ims[n].append( image.astype(np.uint8)) else: filename = '%s/belief-%s-it%d-n%d-t%d_%d.png' % ( self.args.viz_folder, split, it, n, t, viz_counter) cv2.imwrite(filename, viz[n] * 255) viz_counter += 1 ended |= sim.takeMultiStepAction(action_idx) if ended.all(): break if self.args.viz_gif and self.args.viz_eval and it < self.args.viz_iterations: import imageio for n in range(self.args.batch_size): filename = '%s/%s-%s-it%d-n%d' % ( self.args.viz_folder, split, batch[n]['instr_id'], it, n) if not os.path.exists(filename): os.makedirs(filename) with imageio.get_writer(filename + '.gif', mode='I', format='GIF-PIL', subrectangles=True, fps=1) as writer: for i, image in enumerate(belief_ims[n]): writer.append_data(image) cv2.imwrite("%s/%04d.png" % (filename, i), np.flip(image, 2)) # Eval out_dir = "%s/%s" % (args.result_dir, args.exp_name) if not os.path.exists(out_dir): os.makedirs(out_dir) output_file = "%s/%s_%s_%d.json" % (out_dir, split, args.exp_name, args.val_epoch) with open(output_file, 'w') as f: json.dump(sim.traj, f) scores = vln_eval.score(output_file) print(scores) with open(output_file.replace('.json', '_scores.json'), 'w') as f: json.dump(scores, f)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-task', type=str, default='ranking') parser.add_argument('-model', type=str, default='bert') parser.add_argument('-max_input', type=int, default=1280000) parser.add_argument('-test', type=str, default='./data/test_toy.jsonl') parser.add_argument('-vocab', type=str, default='allenai/scibert_scivocab_uncased') parser.add_argument('-ent_vocab', type=str, default='') parser.add_argument('-pretrain', type=str, default='allenai/scibert_scivocab_uncased') parser.add_argument('-checkpoint', type=str, default='./checkpoints/bert.bin') parser.add_argument('-res', type=str, default='./results/bert.trec') parser.add_argument('-mode', type=str, default='cls') parser.add_argument('-n_kernels', type=int, default=21) parser.add_argument('-max_query_len', type=int, default=32) parser.add_argument('-max_doc_len', type=int, default=256) parser.add_argument('-maxp', action='store_true', default=False) parser.add_argument('-batch_size', type=int, default=32) args = parser.parse_args() args.model = args.model.lower() if args.model == 'bert': tokenizer = AutoTokenizer.from_pretrained(args.vocab) print('reading test data...') if args.maxp: test_set = BertMaxPDataset( dataset=args.test, tokenizer=tokenizer, mode='test', query_max_len=args.max_query_len, doc_max_len=args.max_doc_len, max_input=args.max_input, task=args.task ) elif args.model == 'longformer': tokenizer = AutoTokenizer.from_pretrained(args.vocab) print('reading test data...') if args.maxp: test_set = longformerMaxpDataset( dataset=args.test, tokenizer=tokenizer, mode='test', query_max_len=args.max_query_len, doc_max_len=args.max_doc_len, max_input=args.max_input, task=args.task ) ''' else: test_set = om.data.datasets.BertDataset( dataset=args.test, tokenizer=tokenizer, mode='test', query_max_len=args.max_query_len, doc_max_len=args.max_doc_len, max_input=args.max_input, task=args.task ) ''' ''' elif args.model == 'roberta': tokenizer = AutoTokenizer.from_pretrained(args.vocab) print('reading test data...') test_set = om.data.datasets.RobertaDataset( dataset=args.test, tokenizer=tokenizer, mode='test', query_max_len=args.max_query_len, doc_max_len=args.max_doc_len, max_input=args.max_input, task=args.task ) ''' ''' else: tokenizer = om.data.tokenizers.WordTokenizer( pretrained=args.vocab ) print('reading test data...') test_set = om.data.datasets.Dataset( dataset=args.test, tokenizer=tokenizer, mode='test', query_max_len=args.max_query_len, doc_max_len=args.max_doc_len, max_input=args.max_input, task=args.task ) ''' test_loader = DataLoader( dataset=test_set, batch_size=args.batch_size, shuffle=False, num_workers=0 ) if args.model == 'bert' or args.model == 'roberta': if args.maxp: model = BertMaxP( pretrained=args.pretrain, max_query_len=args.max_query_len, max_doc_len=args.max_doc_len, mode=args.mode, task=args.task ) ''' else: model = om.models.Bert( pretrained=args.pretrain, mode=args.mode, task=args.task ) ''' elif args.model == "longformer": if args.maxp: model = LongformerMaxp( pretrained=args.pretrain, max_query_len=args.max_query_len, max_doc_len=args.max_doc_len, mode=args.mode, task=args.task ) else: raise ValueError('model name error.') state_dict = torch.load(args.checkpoint) if args.model == 'bert': st = {} for k in state_dict: print(k) if k.startswith('bert'): st['_model'+k[len('bert'):]] = state_dict[k] elif k.startswith('classifier'): st['_dense'+k[len('classifier'):]] = state_dict[k] else: st[k] = state_dict[k] model.load_state_dict(st) elif args.model == 'longformer': st = {} for k in state_dict: print(k) ''' if k.startswith('bert'): st['_model'+k[len('bert'):]] = state_dict[k] elif k.startswith('classifier'): st['_dense'+k[len('classifier'):]] = state_dict[k] else: st[k] = state_dict[k] ''' model.load_state_dict(state_dict) else: model.load_state_dict(state_dict) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model.to(device) if torch.cuda.device_count() > 1: model = nn.DataParallel(model) rst_dict = test(args, model, test_loader, device) with open("test_result.tmp", 'w') as writer: F1score=0 TP=0 FP=0 FN=0 for q_id, scores in rst_dict.items(): res = sorted(scores.items(), key=lambda x: x[1], reverse=True) for rank, value in enumerate(res): writer.write(q_id+' '+str(value[0])+' '+str(rank+1)+' '+ str(value[1])+' bertmaxp\n')
type=int, default=100, help="number of epochs") parser.add_argument("--batch_size", type=int, default=3, help="size of each image batch") parser.add_argument("--train_path", type=str, default="config/train.txt", help="txt path saving image paths") parser.add_argument("--img_size", type=int, default=416, help="size of each image dimension") opt = parser.parse_args() print(opt) dataset = DataLoader(opt.train_path) dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=0, pin_memory=False) for batch_i, (img_path, images, labels) in enumerate(dataloader): print("batch_i: ", batch_i) print("images: ", images) print("labels: ", labels) print("=" * 50)
# instance segmentation: lambda data_dict: { **data_dict, **dict( zip(["segm", "bboxes", "probs"], seg_engine(data_dict["input"], scaled_boxes))) }, ] ######################################## ## build async processor ######################################## loader = DataLoader( data_stream, batch_size=1, num_workers=1, pin_memory=True, processors=processors, ) @torch.no_grad() def main_loop(): for data_dict in tqdm.tqdm(loader): segm = data_dict["segm"].cpu().numpy()[0].transpose(1, 2, 0) # [512, 512, 4] input = (segm[:, :, 0:3] * 0.5) + 0.5 output = (segm[:, :, 0:3] * segm[:, :, 3:4] * 0.5) + 0.5 x1, y1, x2, y2 = scaled_boxes[0].cpu().numpy()[0] window = np.hstack([input, output]).astype(np.float32)
def train(args, net): # Begin tf session with tf.Session() as sess: # Initialize variables tf.global_variables_initializer().run() saver = tf.train.Saver(tf.global_variables(), max_to_keep=5) # load from previous save if len(args.ckpt_name) > 0: saver.restore(sess, os.path.join(args.save_dir, args.ckpt_name)) # Load data shift = sess.run(net.shift) scale = sess.run(net.scale) data_loader = DataLoader(args, shift, scale) sess.run(tf.assign(net.shift, data_loader.shift_x)) sess.run(tf.assign(net.scale, data_loader.scale_x)) #Function to evaluate loss on validation set def val_loss(): data_loader.reset_batchptr_val() loss = 0.0 for b in xrange(data_loader.n_batches_val): # Get inputs batch_dict = data_loader.next_batch_val() x = batch_dict["inputs"] # Construct inputs for network feed_in = {} feed_in[net.x] = np.reshape(x, (args.batch_size*(args.seq_length+1), 128, 256, 4)) if args.kl_weight > 0.0: feed_in[net.kl_weight] = args.kl_weight else: feed_in[net.kl_weight] = 1.0 # Find loss feed_out = net.cost cost = sess.run(feed_out, feed_in) loss += cost return loss/data_loader.n_batches_val # Initialize variable to track validation score over time old_score = 1e9 count_decay = 0 decay_epochs = [] # Set initial learning rate and weight on kl divergence print 'setting learning rate to ', args.learning_rate sess.run(tf.assign(net.learning_rate, args.learning_rate)) # Define temperature for annealing kl_weight T = 5*data_loader.n_batches_train count = 0 # Loop over epochs for e in xrange(args.num_epochs): # Initialize loss loss = 0.0 rec_loss = 0.0 kl_loss = 0.0 # Evaluate loss on validation set score = val_loss() print('Validation Loss: {0:f}'.format(score)) # Set learning rate if (old_score - score) < 0.01: count_decay += 1 decay_epochs.append(e) if len(decay_epochs) >= 3 and np.sum(np.diff(decay_epochs)[-2:]) == 2: break print 'setting learning rate to ', args.learning_rate * (args.decay_rate ** count_decay) sess.run(tf.assign(net.learning_rate, args.learning_rate * (args.decay_rate ** count_decay))) old_score = score data_loader.reset_batchptr_train() print 'learning rate is set to ', args.learning_rate * (args.decay_rate ** count_decay) # Loop over batches for b in xrange(data_loader.n_batches_train): start = time.time() count += 1 # Update kl_weight if args.kl_weight > 0.0: kl_weight = args.kl_weight else: kl_weight = min(0.1, 0.01 + count/float(T)) # Get inputs batch_dict = data_loader.next_batch_train() x = batch_dict["inputs"] # Construct inputs for network feed_in = {} feed_in[net.x] = np.reshape(x, (args.batch_size*(args.seq_length+1), 128, 256, 4)) feed_in[net.kl_weight] = kl_weight # Find loss and perform training operation feed_out = [net.cost, net.loss_reconstruction, net.kl_loss, net.train] out = sess.run(feed_out, feed_in) # Update and display cumulative losses loss += out[0] rec_loss += out[1] kl_loss += out[2] end = time.time() # Print loss if (e * data_loader.n_batches_train + b) % 10 == 0 and b > 0: print "{}/{} (epoch {}), train_loss = {:.3f}, time/batch = {:.3f}" \ .format(e * data_loader.n_batches_train + b, args.num_epochs * data_loader.n_batches_train, e, loss/10., end - start) print "{}/{} (epoch {}), rec_loss = {:.3f}, time/batch = {:.3f}" \ .format(e * data_loader.n_batches_train + b, args.num_epochs * data_loader.n_batches_train, e, rec_loss/10., end - start) print "{}/{} (epoch {}), kl_loss = {:.3f}, time/batch = {:.3f}" \ .format(e * data_loader.n_batches_train + b, args.num_epochs * data_loader.n_batches_train, e, kl_loss/10., end - start) print '' loss = 0.0 rec_loss = 0.0 kl_loss = 0.0 # Save model every epoch checkpoint_path = os.path.join(args.save_dir, args.save_name + '.ckpt') saver.save(sess, checkpoint_path, global_step = e) print "model saved to {}".format(checkpoint_path)
import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim import time from tqdm import tqdm IF_SAVE = 0 SAVE_NAME = 'five_fc' ITERATION = 400 random.seed(0) np.random.seed(0) torch.manual_seed(0) CLASS = 10 dl = DataLoader(True,cuda = 1) images,labels = dl.get_all() #images, labels = images[:18000],labels[:18000] dl_test = DataLoader(False,cuda = 1) images_t,labels_t = dl_test.get_all() accumulate = torch.ones((labels.shape[0],CLASS),dtype = torch.float32).cuda() accumulate_t = torch.ones((labels_t.shape[0],CLASS),dtype = torch.float32).cuda() saved_data = np.zeros((ITERATION,5,2),dtype = int) saved_mask = np.zeros((ITERATION,CLASS),dtype = int) FC_TRAINING_ITERATION = 5000 FC_START_TIME = 1
def train_pixpro(args, logger, initial_epoch, strategy, num_workers): ########################## # Dataset ########################## trainset = set_dataset(args.task, args.data_path) steps_per_epoch = args.steps or len(trainset) // args.batch_size logger.info("TOTAL STEPS OF DATASET FOR TRAINING") logger.info("========== TRAINSET ==========") logger.info(f" --> {len(trainset)}") logger.info(f" --> {steps_per_epoch}") ########################## # Model & Generator ########################## train_generator = DataLoader(args, 'train', trainset, args.batch_size).dataloader with strategy.scope(): model = PixPro(logger, norm='bn' if num_workers == 1 else 'syncbn', channel=256, gamma=args.gamma, num_layers=args.num_layers, snapshot=args.snapshot) if args.summary: model.summary() return lr_scheduler = OptionalLearningRateSchedule( lr=args.lr, lr_mode=args.lr_mode, lr_interval=args.lr_interval, lr_value=args.lr_value, total_epochs=args.epochs, steps_per_epoch=steps_per_epoch, initial_epoch=initial_epoch) model.compile( # TODO : apply LARS optimizer=tf.keras.optimizers.SGD(lr_scheduler, momentum=.9), batch_size=args.batch_size, num_workers=num_workers, run_eagerly=None) ########################## # Train ########################## callbacks, initial_epoch = create_callbacks(args, logger, initial_epoch) if callbacks == -1: logger.info('Check your model.') return elif callbacks == -2: return model.fit( train_generator, epochs=args.epochs, callbacks=callbacks, initial_epoch=initial_epoch, steps_per_epoch=steps_per_epoch, )
pprint(config) # create save_dir folder if not exists if not os.path.exists(config['save_dir']): os.makedirs(config['save_dir']) # Load tokenizer tokenizer = WPTokenizer(os.path.join(config['pretrained_model_dir'], 'vocab.txt'), lowercase=True) tokenizer.enable_truncation(max_length=config['max_len']) print("load data...") dataloader = DataLoader(tokenizer, config['max_len'], use_vae=True, batch_size=config["batch_size"], ae_epochs=config['ae_epochs']) dataloader.set_train(config['train_path']) dataloader.set_dev(config['dev_path']) dataloader.save_autoencoder( os.path.join(config['save_dir'], 'autoencoder.weights')) dataloader.save_vocab(os.path.join(config['save_dir'], 'vocab.pickle')) accuracy_list = [] f1_list = [] for idx in range(1, config['iterations'] + 1): print("build generator") generator = DataGenerator(config['batch_size'], config['max_len']) generator.set_dataset(dataloader.train_set) metrics_callback = Metrics(
def test_load_time_series_directory_data(): invalid_directory_path = 'invalid_directory_path' valid_dummy_directory = '../resources/dummy_time_series_data_directory' empty_dummy_directory = '../resources/dummy_empty_data_directory' valid_time_steps = 4 channels = 1 # should raise error when receives an invalid directory path with pytest.raises(NotADirectoryError): DataLoader(from_csv=False, datapath=invalid_directory_path, time_steps=4) # should raise error when tries to load empty directory data_loader = DataLoader(from_csv=False, datapath=empty_dummy_directory, time_steps=4) with pytest.raises(AssertionError): data_loader.get_data() # should raise error when given time_step argument that is less than 1 with pytest.raises(ValueError): DataLoader(from_csv=False, datapath=valid_dummy_directory, time_steps=-4) # should raise error when given time_step argument that not an integer with pytest.raises(ValueError): DataLoader(from_csv=False, datapath=valid_dummy_directory, time_steps=4.7) # should raise error when tries to load time series sample # containing a quantity of images less than the time_steps argument with pytest.raises(ValueError): data_loader = DataLoader(from_csv=False, datapath=valid_dummy_directory, time_steps=10) data_loader.get_data() # should assign an image's parent directory name as its label data_loader = DataLoader(from_csv=False, datapath=valid_dummy_directory, time_steps=valid_time_steps) samples, labels, label_index_map = data_loader.get_data() label_count = len(label_index_map.keys()) label = [0] * label_count label[label_index_map['happiness']] = 1 assert label == labels[0] data_loader = DataLoader(from_csv=False, datapath=valid_dummy_directory, time_steps=valid_time_steps) samples, labels, label_index_map = data_loader.get_data() # should return non-empty image and label arrays when given valid arguments assert len(samples) > 0 and len(labels) > 0 # should return same number of labels and images when given valid arguments assert len(samples) == len(labels) # should reshape image to contain channel_axis in channel_last format assert samples.shape[1] == valid_time_steps # should reshape image to contain channel_axis in channel_last format assert samples.shape[-1] == channels
from vocab import VocabBuilder from dataloader import DataLoader from model import RNN filepath = "./dataset/dataset.csv" vocab_obj = VocabBuilder(filepath=filepath) word_to_index = vocab_obj.word_to_index label_to_index = vocab_obj.label_to_index index_to_label = {} for label, index in label_to_index.items(): index_to_label[index] = label loader = DataLoader(filepath=filepath, word_to_index=word_to_index, label_to_index=label_to_index, batch_size=128) vocab_size = len(word_to_index) embedding_size = 128 num_output = len(label_to_index) model = RNN(vocab_size=vocab_size, embed_size=embedding_size, num_output=num_output, rnn_model="LSTM", use_last=True, hidden_size=128, embedding_tensor=None, num_layers=2, batch_first=True)
# stats = torch.load('/misc/vlgscratch4/LecunGroup/nvidia-collab/traffic-data-atcold/data_i80_v0/data_stats.pth') # model.stats=stats if 'ten' in opt.mfile: pzfile = opt.model_dir + opt.mfile + '.pz' p_z = torch.load(pzfile) model.p_z = p_z if opt.actions_subsample == -1: opt.context_dim = 0 model.intype('gpu') model.cuda() model.disable_unet = False print('[loading data]') dataloader = DataLoader(None, opt, opt.dataset) # training and testing functions. We will compute several losses: # loss_i: images # loss_s: states # loss_c: costs # loss_p: prior (optional) def compute_loss(targets, predictions, gamma=1.0, r=True): target_images, target_states, target_costs = targets pred_images, pred_states, pred_costs, loss_p = predictions loss_i = F.mse_loss(pred_images, target_images, reduce=False).mean(4).mean(3).mean(2) loss_s = F.mse_loss(pred_states, target_states, reduce=False).mean(2) # loss_c = F.mse_loss(pred_costs, target_costs, reduce=False).mean(2)
self.fc3 = nn.Linear(32, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): # print(x.shape) out = self.backbone(x) # print('backbone', out.shape) out = out.view(out.size(0), -1) # print('view', out.shape) out = self.fc1(out) # print('fc1',out.shape) out = self.dropout1(out) out = self.fc2(out) out = self.dropout2(out) out = self.fc3(out) # print('fc2',out.shape) out = self.sigmoid(out) return out if __name__ == '__main__': loader = DataLoader('data/', 'train') train_data_loader = torch.utils.data.DataLoader(loader, batch_size=1, shuffle=False, num_workers=0) idx, (image, label) = next(enumerate(train_data_loader)) net = ResNet() net.forward(image)
import numpy as np import matplotlib.pyplot as plt from matplotlib.colors import ListedColormap from sklearn import neighbors, datasets from mpldatacursor import datacursor from dataloader import DataLoader from transformer import Transformer dataLoader = DataLoader() path = 'D:/Documents/учёба/КНТ/4 курс 2 семестр/dataset недвижимость СПБ/обработанные данные/РАЙОНЫ2.csv' fit_path = None # загружаем датасет (X_train, Y_train), (X_test, Y_test) = dataLoader.load(path=path, labels=['Широта', 'Долгота', 'Район'], test_size=0.2, fit_path=fit_path) # нормализуем координаты тем же методом, что и для нейронной сети x_transformer = Transformer(transformer='QuantileTransformer') x_transformer.fit(X_train) X_train_norm = x_transformer.transform(X_train) # нормализуем классы в вектора [ 2. 16. 7. ... 9. 16. 7.] y_transformer = Transformer(transformer='OrdinalEncoder') y_transformer.fit(Y_train) y_train_norm = y_transformer.transform(Y_train).reshape(-1) labels = y_transformer.transformer.categories_[0]
model.load_json(args.load_model, clone_tensors=True) model.replace_tokendata(args.input_json) print(model.layers) logger.info('%s model with %d parameters' % ('Created' if args.load_model is None else 'Loaded', sum((p.numel() for p in model.parameters())))) optimizer = optim.Adam(model.parameters(), lr=args.learning_rate) scheduler = optim.lr_scheduler.StepLR(optimizer, args.lrdecay_every, args.lrdecay_factor) crit = nn.CrossEntropyLoss(reduction='none' if args.use_masks else 'mean') logger.info('Loading data') loader = DataLoader(filename=args.input_h5, batch_size=args.batch_size, seq_length=args.seq_length) device = torch.device(args.device) if args.layerdevices: for ld in args.layerdevices: start, end, device = ld.split(',') for layerid in range(int(start), int(end) + 1): print("Moving layer %d-%s to device %s" % (layerid, model.layers[layerid], device)) model.layers[layerid].to(device) else: model.to(device) double_seq_on = [int(x) for x in args.double_seq_on.split(',') ] if args.double_seq_on else []
def main(): parser = argparse.ArgumentParser() parser.add_argument('--device', type=str, default='cuda:0', help='gpu device number of using') parser.add_argument('--config', type=str, default=os.path.join('.', 'config', '5way_1shot_resnet12_mini-imagenet.py'), help='config file with parameters of the experiment. ' 'It is assumed that the config file is placed under the directory ./config') parser.add_argument('--checkpoint_dir', type=str, default=os.path.join('.', 'checkpoints'), help='path that checkpoint will be saved and loaded. ' 'It is assumed that the checkpoint file is placed under the directory ./checkpoints') parser.add_argument('--num_gpu', type=int, default=1, help='number of gpu') parser.add_argument('--display_step', type=int, default=100, help='display training information in how many step') parser.add_argument('--log_step', type=int, default=100, help='log information in how many steps') parser.add_argument('--log_dir', type=str, default=os.path.join('.', 'logs'), help='path that log will be saved. ' 'It is assumed that the checkpoint file is placed under the directory ./logs') parser.add_argument('--dataset_root', type=str, default='./data', help='root directory of dataset') parser.add_argument('--seed', type=int, default=222, help='random seed') parser.add_argument('--mode', type=str, default='train', help='train or eval') args_opt = parser.parse_args() config_file = args_opt.config # Set train and test datasets and the corresponding data loaders config = imp.load_source("", config_file).config train_opt = config['train_config'] eval_opt = config['eval_config'] args_opt.exp_name = '{}way_{}shot_{}_{}'.format(train_opt['num_ways'], train_opt['num_shots'], config['backbone'], config['dataset_name']) train_opt['num_queries'] = 1 eval_opt['num_queries'] = 1 set_logging_config(os.path.join(args_opt.log_dir, args_opt.exp_name)) logger = logging.getLogger('main') # Load the configuration params of the experiment logger.info('Launching experiment from: {}'.format(config_file)) logger.info('Generated logs will be saved to: {}'.format(args_opt.log_dir)) logger.info('Generated checkpoints will be saved to: {}'.format(args_opt.checkpoint_dir)) print() logger.info('-------------command line arguments-------------') logger.info(args_opt) print() logger.info('-------------configs-------------') logger.info(config) # set random seed np.random.seed(args_opt.seed) torch.manual_seed(args_opt.seed) torch.cuda.manual_seed_all(args_opt.seed) random.seed(args_opt.seed) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False if config['dataset_name'] == 'mini-imagenet': dataset = MiniImagenet print('Dataset: MiniImagenet') elif config['dataset_name'] == 'tiered-imagenet': dataset = TieredImagenet print('Dataset: TieredImagenet') elif config['dataset_name'] == 'cifar-fs': dataset = Cifar print('Dataset: Cifar') elif config['dataset_name'] == 'cub-200-2011': dataset = CUB200 print('Dataset: CUB200') else: logger.info('Invalid dataset: {}, please specify a dataset from ' 'mini-imagenet, tiered-imagenet, cifar-fs and cub-200-2011.'.format(config['dataset_name'])) exit() cifar_flag = True if args_opt.exp_name.__contains__('cifar') else False if config['backbone'] == 'resnet12': enc_module = ResNet12(emb_size=config['emb_size'], cifar_flag=cifar_flag) print('Backbone: ResNet12') elif config['backbone'] == 'convnet': enc_module = ConvNet(emb_size=config['emb_size'], cifar_flag=cifar_flag) print('Backbone: ConvNet') else: logger.info('Invalid backbone: {}, please specify a backbone model from ' 'convnet or resnet12.'.format(config['backbone'])) exit() gnn_module = DPGN(config['num_generation'], train_opt['dropout'], train_opt['num_ways'] * train_opt['num_shots'], train_opt['num_ways'] * train_opt['num_shots'] + train_opt['num_ways'] * train_opt['num_queries'], train_opt['loss_indicator'], config['point_distance_metric'], config['distribution_distance_metric']) # multi-gpu configuration [print('GPU: {} Spec: {}'.format(i, torch.cuda.get_device_name(i))) for i in range(args_opt.num_gpu)] if args_opt.num_gpu > 1: print('Construct multi-gpu model ...') enc_module = nn.DataParallel(enc_module, device_ids=range(args_opt.num_gpu), dim=0) gnn_module = nn.DataParallel(gnn_module, device_ids=range(args_opt.num_gpu), dim=0) print('done!\n') if not os.path.exists(os.path.join(args_opt.checkpoint_dir, args_opt.exp_name)): os.makedirs(os.path.join(args_opt.checkpoint_dir, args_opt.exp_name)) logger.info('no checkpoint for model: {}, make a new one at {}'.format( args_opt.exp_name, os.path.join(args_opt.checkpoint_dir, args_opt.exp_name))) best_step = 0 else: if not os.path.exists(os.path.join(args_opt.checkpoint_dir, args_opt.exp_name, 'model_best.pth.tar')): best_step = 0 else: logger.info('find a checkpoint, loading checkpoint from {}'.format( os.path.join(args_opt.checkpoint_dir, args_opt.exp_name))) best_checkpoint = torch.load(os.path.join(args_opt.checkpoint_dir, args_opt.exp_name, 'model_best.pth.tar')) logger.info('best model pack loaded') best_step = best_checkpoint['iteration'] enc_module.load_state_dict(best_checkpoint['enc_module_state_dict']) gnn_module.load_state_dict(best_checkpoint['gnn_module_state_dict']) logger.info('current best test accuracy is: {}, at step: {}'.format(best_checkpoint['test_acc'], best_step)) dataset_train = dataset(root=args_opt.dataset_root, partition='train') dataset_valid = dataset(root=args_opt.dataset_root, partition='val') dataset_test = dataset(root=args_opt.dataset_root, partition='test') train_loader = DataLoader(dataset_train, num_tasks=train_opt['batch_size'], num_ways=train_opt['num_ways'], num_shots=train_opt['num_shots'], num_queries=train_opt['num_queries'], epoch_size=train_opt['iteration']) valid_loader = DataLoader(dataset_valid, num_tasks=eval_opt['batch_size'], num_ways=eval_opt['num_ways'], num_shots=eval_opt['num_shots'], num_queries=eval_opt['num_queries'], epoch_size=eval_opt['iteration']) test_loader = DataLoader(dataset_test, num_tasks=eval_opt['batch_size'], num_ways=eval_opt['num_ways'], num_shots=eval_opt['num_shots'], num_queries=eval_opt['num_queries'], epoch_size=eval_opt['iteration']) data_loader = {'train': train_loader, 'val': valid_loader, 'test': test_loader} # create trainer trainer = DPGNTrainer(enc_module=enc_module, gnn_module=gnn_module, data_loader=data_loader, log=logger, arg=args_opt, config=config, best_step=best_step) if args_opt.mode == 'train': trainer.train() elif args_opt.mode == 'eval': trainer.eval() else: print('select a mode') exit()
def train_net(net, epochs=1, data_dir='data/', n_classes=3, lr=0.1, val_percent=0.1, save_cp=True, gpu=True): ## path to save images output_dir = 'samples/' train_groundtruth = os.path.join(output_dir, 'train_groundtruth') train_input = os.path.join(output_dir, 'train_input') train_output = os.path.join(output_dir, 'train_output') test_groundtruth = os.path.join(output_dir, 'test_groundtruth') test_input = os.path.join(output_dir, 'test_input') test_output = os.path.join(output_dir, 'test_output') # load data loader = DataLoader(data_dir) #N_train = loader.n_train() N_train = 160 ## change to MSEloss adam criterion = nn.MSELoss() optimizer = optim.Adam( net.parameters(), #lr=lr, #momentum=0.99, weight_decay=0.0005) training_time = time.time() for epoch in range(epochs): print('Epoch %d/%d' % (epoch + 1, epochs)) print('Training...') net.train() loader.setMode('train') epoch_loss = 0 ## load data for j, (img, label) in enumerate(loader): image = torch.tensor(img) # [160,4,128,128] label = torch.tensor(label) # [160,3,128,128] if gpu: image = image.cuda() label = label.cuda() batch = 16 for i in range(0, int(N_train / batch)): ## get inputs x with batch 16 [16,4,128,128] [16,3,128,128] train_x = image[i * batch:(i + 1) * batch, :, :, :] train_y = label[i * batch:(i + 1) * batch, :, :, :] pred = net(train_x.float()) optimizer.zero_grad() loss = criterion(pred, train_y.float()) loss.backward() optimizer.step() epoch_loss += loss.item() print('Training sample %d / %d - Loss: %.6f' % ((i + 1) * batch, N_train, loss.item())) print('Epoch %d finished! - Loss: %.6f' % (epoch + 1, epoch_loss / i)) print('End of training. Time Taken: %d sec.' % (time.time() - training_time)) ## image should be [128,128,3] ## Can't call numpy() on Variable that requires grad. Use var.detach().numpy() instead. plot_label = np.resize(label[-1, :, :, :], (128, 128, 3)) plot_image = np.resize(image[-1, 0:3, :, :], (128, 128, 3)) plot_pred = np.resize(pred[-1, :, :, :], (128, 128, 3)) torchvision.utils.save_image( plot_label, os.path.join(train_groundtruth, '{}.png').format('train_groundtruth')) torchvision.utils.save_image( plot_image, os.path.join(train_input, '{}.png').format('train_input')) torchvision.utils.save_image( plot_pred, os.path.join(train_output, '{}.png').format('train_output')) # displays test images with original and predicted masks after training loader.setMode('test') net.eval() with torch.no_grad(): (img, label) = enumerate(loader) img_torch = torch.tensor(img) # [6,4,128,128] if gpu: img_test = img_torch.cuda() pred_test = net(img_test) # [6,3,128,128] # plot test result for j in range(len(img)): plot_label_test = np.resize(label[j, :, :, :], (128, 128, 3)) plot_img_test = np.resize(img[j, 0:3, :, :], (128, 128, 3)) plot_pred = np.resize(pred_test[j, :, :, :], (128, 128, 3)) self.plot(plot_label_test, plot_img_test, plot_pred) torchvision.utils.save_image( plot_label_test, os.path.join(test_groundtruth, '{}.png').format('test_groundtruth')) torchvision.utils.save_image( plot_img_test, os.path.join(test_input, '{}.png').format('test_input')) torchvision.utils.save_image( plot_pred, os.path.join(test_output, '{}.png').format('test_output')) def plot(self, img, label, pred): plt.subplot(1, 3, 1) plt.imshow(img * 255.) plt.subplot(1, 3, 2) plt.imshow(label * 255.) plt.subplot(1, 3, 3) #plt.imshow(pred.cpu().detach().numpy().squeeze()*255.) plt.imshow(pred * 255.) plt.show()
def get_train_data(input_path, target_path): return DataLoader(input_path, target_path, 'train')
help='path to corpus dir') parser.add_argument('-src', '--corpus-name', type=str, default='data.txt', help='path to corpus data') parser.add_argument('--save-dir', type=str, default='./data/', help='path to save processed data') parser.add_argument('--pre-w2v', type=str, default='../data/w2v') args = parser.parse_args() args.corpus_data = args.corpus_dir + args.corpus_name corpus = Corpus(args.corpus_data, args.pre_w2v, args.save_dir, train_dev=0) dl = DataLoader(args.save_dir, batch_size=128, train_dev=0)() # dl_train, dl_test = train_test_split(dl, test_size=0.33) pre_w2v = torch.load(args.save_dir + 'pre_w2v') pre_w2v = torch.Tensor(pre_w2v).to(device) model_ckpt = torch.load(os.path.join( args.save_dir, '{}.pyt'.format("Transformer_NER_best")), map_location=torch.device(device)) config = load_obj(args.save_dir + 'Config.json') model = Transformer_Mix(config, pre_w2v).to(device) model.load_state_dict(model_ckpt['model']) # pred_tags = [] # true_tags = [] # loss_epoch_test, f1_cls, f1_tgt, f1_tgt_merged = evaluate_f1(model, dl_test, args.save_dir, verbose=1)