model.train(mode=was_training) ds.cls = cls_cache print('Matching accuracy') for cls, single_acc in zip(classes, accs): print('{} = {:.4f}'.format(cls, single_acc)) print('average = {:.4f}'.format(torch.mean(accs))) return accs if __name__ == '__main__': from utils.dup_stdout_manager import DupStdoutFileManager from utils.parse_args import parse_args from utils.print_easydict import print_easydict args = parse_args('Deep learning of graph matching evaluation code.') import importlib mod = importlib.import_module(cfg.MODULE) Net = mod.Net torch.manual_seed(cfg.RANDOM_SEED) image_dataset = GMDataset(cfg.DATASET_FULL_NAME, sets='test', length=cfg.EVAL.SAMPLES, obj_resize=cfg.PAIR.RESCALE) dataloader = get_dataloader(image_dataset) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
import numpy as np import tensorflow as tf from utils.parse_args import parse_args from utils.prepare_net import select_net import os import utils.CIFAR10 as CIFAR10 if __name__ == "__main__": args = parse_args() ckpt_dir = args.ckpt_dir # 'Model/CIFAR10/TT_30_Adam' which_resnet = args.which_resnet bond_dim = args.bond_dim params = {} params['data_path'] = '../CIFAR10/cifar-10-batches-py' # batch_size here does not matter params['batch_size'] = 64 # CIFAR10 = read_data.CIFAR10(params) # data={} # data['X_train']= CIFAR10._train_image_set # data['y_train']= CIFAR10._train_label_set # data['X_val']= CIFAR10._val_image_set # data['y_val']= CIFAR10._val_label_set CIFAR10 = CIFAR10.CIFAR10(params) data = {} data['X_val'] = CIFAR10._test_image_set data['y_val'] = CIFAR10._test_label_set config = tf.ConfigProto(
def main(raw_args=None): args = parse_args(raw_args) result = run(args) return result
match_cnt[pred_type] += 1 MAE += abs(pred_event['time'] - event['time']) # print(match_cnt) # print(pred_cnt) # print(gt_cnt) precision = match_cnt / pred_cnt recall = match_cnt / gt_cnt f1_score = 2 * precision * recall / (precision + recall) MAE /= cnt return precision, recall, f1_score, MAE if __name__ == '__main__': args = parse_args( 'Use ADM4 algorithm to fit and predict on a ATM dataset.') np.random.seed(cfg.RANDOM_SEED) train_dataset = ATMDataset(mode='train') test_dataset = ATMDataset(mode='test') # A, mu = train(train_dataset) # pickle.dump(A, open('output/A.pkl', 'wb')) # pickle.dump(mu, open('output/mu.pkl', 'wb')) A = pickle.load(open('output/A.pkl', 'rb')) mu = pickle.load(open('output/mu.pkl', 'rb')) pred_samples = test(test_dataset, A, mu) print('Finish predicting samples.') precision, recall, f1_score, MAE = evaluate(pred_samples, test_dataset)
"--freeze-pattern", type=str, default="", help="regex pattern string, fix matched param when training") parser.add_argument( "--load-solver", type=str, default=None, help="YAML file that contains all args of an experiment, " "if this option presents, program will read all args from this " "yaml file. This mechanism is designed for reproducible experiments.") parser.add_argument( "--save-solver", type=str, default=None, help="the prefix to dump all args for current experiment, default is " "[symbol_name].[iterator_name].[timestamp].yaml") parser.add_argument( "--freeze-pattern", type=str, default="", help="regex pattern string, fix matched param when training") # TODO: divide the parse_args into two phase, parse to yaml, parse yaml to args # TODO: add support for run a yaml config args = parse_args(parser) if args.test: test(args) else: fit(args)
acc = 1 - torch.abs(D_pred / D - 1) #计算精度 if was_training is False: #只有在最终验证的时候才输出每一个样本的精度 print( 'predict / real : {:<8.4f} / {:<8.4f}, accary : {:<8.4f}'. format(D_pred.item(), D.item(), acc.item())) accs.append(acc) # statistics average_acc = torch.sum(torch.tensor(accs)) / cfg.EVAL.SAMPLES print('average accary:{:<8.4f}'.format(average_acc.item())) return accs, average_acc if __name__ == '__main__': args = parse_args('bp网络训练代码') import importlib mod = importlib.import_module(cfg.MODULE) Net = mod.Net #构建数据集 dataset_len = { 'train': cfg.TRAIN.EPOCH_ITERS * cfg.BATCH_SIZE, 'test': cfg.EVAL.SAMPLES } A_dataset = { x: MyDataset(cfg.DATASET_FULL_NAME, sets=x, Q=cfg.Q, number=cfg.NUMBER,
marker='^', markersize=10, markeredgecolor=color[d], label='Events in dimension {}'.format(d)) if intensities is not None: plt.plot([0] + d_events, intensities[d], label=r'Intensity $\lambda$(t) in dimension {}'.format(d)) plt.legend(loc='best') plt.show() if __name__ == '__main__': args = parse_args( 'Simulation of Multi-dimensional Hawkes Process using Thinning Algorithm.' ) np.random.seed(cfg.RANDOM_SEED) if cfg.GEN_DATA: for i in range(cfg.SEQ_NUM): events, intensities = simulation() pickle.dump(events, open('{}/events_{}.pkl'.format(cfg.OUT_DIR, i), 'wb')) pickle.dump( intensities, open('{}/intensities_{}.pkl'.format(cfg.OUT_DIR, i), 'wb')) # events = pickle.load(open('{}/events_{}.pkl'.format(cfg.OUT_DIR, 0), 'rb')) # intensities = pickle.load(open('{}/intensities_{}.pkl'.format(cfg.OUT_DIR, 0), 'rb')) # visualization(events, intensities)
precision = match_cnt / pred_cnt recall = match_cnt / gt_cnt f1_score = 2 * precision * recall / (precision + recall) MAE /= cnt print('Precision of the pred events is {}, avg is {}'.format( precision, precision.mean())) print('Recall of the pred events is {}, avg is {}'.format( recall, recall.mean())) print('F1_score of the pred events is {}, avg is {}'.format( f1_score, f1_score.mean())) print('MAE of the pred times is', MAE) if __name__ == '__main__': args = parse_args('Use INTPP to fit and predict on a ATM dataset.') torch.manual_seed(cfg.RAND_SEED) torch.cuda.manual_seed(cfg.RAND_SEED) torch.cuda.manual_seed_all(cfg.RAND_SEED) np.random.seed(cfg.RAND_SEED) random.seed(cfg.RAND_SEED) torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True train_dataset = ATMDataset(mode='train') test_dataset = ATMDataset(mode='test') train_dataloader = DataLoader(dataset=train_dataset, batch_size=cfg.BATCH_SIZE, shuffle=True, collate_fn=collate_fn)
parameters.append(b) multi_layer_outputs.append([layer_output, layer_inputs, parameters]) return multi_layer_outputs, net.get_layer_map(), net, scale_factor, model_path if __name__ == '__main__': """ Execute this file to run a software demo for supported networks. Command line args: network: name of the network. call Network.factory.list_networks to see the supported networks hw_sim: flag to see hardware results (low precision) image: path of the image (relative to the cnn_emu_data folder) resolution_mode: 0: highest resolution, 1: mid level resolution """ args = parse_args() # Get runtime command line args em_network = args.network_name em_isHardware = args.isHardware em_image = args.image em_image_resolution_mode = args.image_resolution_mode print_msg('Running RefModel in SW standalone mode ... ',3) print_msg('Network: '+str(em_network),3) print_msg('Test Image: '+str(em_image),3) print_msg('Resolution Mode: '+str(em_image_resolution_mode),3) #model = cfg.MODELS_DIR+str(em_network)+'.npy' em_image = cfg.DATA_DIR+str(em_image) # Sanity checks if not os.path.exists(em_image):
if opt.benchmark and batch_idx == 100: break pruned_preds_batch = processed_batch[0] processed_labels_batch = processed_batch[1] if cfg.eval.metrics: for idx, (pruned_preds, processed_labels) in enumerate( zip(pruned_preds_batch, processed_labels_batch)): stat_recorder.record_eval_stats(processed_labels, pruned_preds, image_sizes[idx]) stat_recorder.logging(print) if __name__ == "__main__": opt = parse_args() if len(opt.data) > 0. and opt.data[-1] != '/': opt.data += '/' cfg = get_cfg_defaults() cfg.merge_from_file(opt.config) cfg = override_cfg(opt, cfg) cfg.freeze() save_cfg('./configs/override-inference-yolov4p5.yaml', cfg) if opt.show_config: logger.info(f"Model options: \n'{cfg}'") inference(opt, cfg)
def main(): args = parse_args() args.cuda = not args.no_cuda and torch.cuda.is_available() # Horovod: initialize library. hvd.init() torch.manual_seed(args.seed) local_rank = hvd.local_rank() world_size = hvd.size() if args.cuda: device = torch.device(f'cuda:{local_rank}') # Horovod: pin GPU to local rank. torch.cuda.set_device(device) torch.cuda.manual_seed(args.seed) # Horovod: limit # of CPU threads to be used per worker. torch.set_num_threads(1) kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {} # When supported, use 'forkserver' to spawn dataloader workers instead of 'fork' to prevent # issues with Infiniband implementations that are not fork-safe if (kwargs.get('num_workers', 0) > 0 and hasattr(mp, '_supports_context') and mp._supports_context and 'forkserver' in mp.get_all_start_methods()): kwargs['multiprocessing_context'] = 'forkserver' # Horovod: use DistributedSampler to partition the training data. data = prepare_datasets(args, rank=local_rank, num_workers=world_size, data='mnist') model = Net() # By default, Adasum doesn't need scaling up learning rate. lr_scaler = hvd.size() if not args.use_adasum else 1 if args.cuda: # Move model to GPU. model.cuda() # If using GPU Adasum allreduce, scale learning rate by local_size. if args.use_adasum and hvd.nccl_built(): lr_scaler = hvd.local_size() # Horovod: scale learning rate by lr_scaler. optimizer = optim.SGD(model.parameters(), lr=args.lr * lr_scaler, momentum=args.momentum) # Horovod: (optional) compression algorithm. compression = (hvd.Compression.fp16 if args.fp16_allreduce else hvd.Compression.none) # Horovod: wrap optimizer with DistributedOptimizer. optimizer = hvd.DistributedOptimizer( optimizer, named_parameters=model.named_parameters(), compression=compression, op=hvd.Adasum if args.use_adasum else hvd.Average, gradient_predivide_factor=args.gradient_predivide_factor) # Horovod: broadcast parameters & optimizer state. hvd.broadcast_parameters(model.state_dict(), root_rank=0) hvd.broadcast_optimizer_state(optimizer, root_rank=0) loss_fn = nn.CrossEntropyLoss() epoch_times = [] for epoch in range(1, args.epochs + 1): t0 = time.time() train(epoch, data['training'], rank=local_rank, model=model, loss_fn=loss_fn, optimizer=optimizer, args=args, scaler=None) if epoch > 2: epoch_times.append(time.time() - t0) if epoch % 10 == 0: if hvd.local_rank() == 0: accuracy = evaluate(model=model, test_loader=data['testing'].loader) logger.log('-' * 75) logger.log(f'Epoch: {epoch}, Accuracy: {accuracy}') logger.log('-' * 75) if local_rank == 0: epoch_times_str = ', '.join(str(x) for x in epoch_times) logger.log('Epoch times:') logger.log(epoch_times_str) outdir = os.path.join(os.getcwd(), 'results_mnist', f'size{world_size}') if not os.path.isdir(outdir): os.makedirs(outdir) modeldir = os.path.join(outdir, 'saved_models') modelfile = os.path.join(modeldir, 'hvd_model_mnist.pth') if not os.path.isdir(modeldir): os.makedirs(modeldir) logger.log(f'Saving model to: {modelfile}') torch.save(model.state_dict(), modelfile) args_file = os.path.join(outdir, f'args_size{world_size}.json') logger.log(f'Saving args to: {args_file}.') with open(args_file, 'at') as f: json.dump(args.__dict__, f, indent=4) times_file = os.path.join(outdir, f'epoch_times_size{world_size}.csv') logger.log(f'Saving epoch times to: {times_file}') with open(times_file, 'a') as f: f.write(epoch_times_str + '\n')
epoch, epoch_loss / len(train_dataloader))) if (epoch + 1) % cfg.VERBOSE_STEP == 0: print('A', A) evaluate(model) def evaluate(model): model.eval() c, w = model.get_parameters() print('c', c) print('w', w) if __name__ == '__main__': args = parse_args('Use INTPP to fit and predict on a synthetic dataset.') torch.manual_seed(cfg.RAND_SEED) torch.cuda.manual_seed(cfg.RAND_SEED) torch.cuda.manual_seed_all(cfg.RAND_SEED) np.random.seed(cfg.RAND_SEED) random.seed(cfg.RAND_SEED) torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True if cfg.Z == 10: train_dataset = SyntheticDataset() else: train_dataset = DemoDataset() train_dataloader = DataLoader(dataset=train_dataset, batch_size=cfg.BATCH_SIZE,