Ejemplo n.º 1
0
def main(_):
    assert FLAGS.train_dir, '`train_dir` is missing.'

    if FLAGS.pipeline_config_path:
        model_config, train_config, input_config = get_configs_from_pipeline_file(
        )
    else:
        model_config, train_config, input_config = get_configs_from_multiple_files(
        )

    model_fn = functools.partial(model_builder.build,
                                 model_config=model_config,
                                 is_training=True)

    create_input_dict_fn = functools.partial(input_reader_builder.build,
                                             input_config)

    env = json.loads(os.environ.get('TF_CONFIG', '{}'))
    cluster_data = env.get('cluster', None)
    cluster = tf.train.ClusterSpec(cluster_data) if cluster_data else None
    task_data = env.get('task', None) or {'type': 'master', 'index': 0}
    task_info = type('TaskSpec', (object, ), task_data)

    # Parameters for a single worker.
    ps_tasks = 0
    worker_replicas = 1
    worker_job_name = 'lonely_worker'
    task = 0
    is_chief = True
    master = ''

    if cluster_data and 'worker' in cluster_data:
        # Number of total worker replicas include "worker"s and the "master".
        worker_replicas = len(cluster_data['worker']) + 1
    if cluster_data and 'ps' in cluster_data:
        ps_tasks = len(cluster_data['ps'])

    if worker_replicas > 1 and ps_tasks < 1:
        raise ValueError(
            'At least 1 ps task is needed for distributed training.')

    if worker_replicas >= 1 and ps_tasks > 0:
        # Set up distributed training.
        server = tf.train.Server(tf.train.ClusterSpec(cluster),
                                 protocol='grpc',
                                 job_name=task_info.type,
                                 task_index=task_info.index)
        if task_info.type == 'ps':
            server.join()
            return

        worker_job_name = '%s/task:%d' % (task_info.type, task_info.index)
        task = task_info.index
        is_chief = (task_info.type == 'master')
        master = server.target

    trainer.train(create_input_dict_fn, model_fn, train_config, input_config,
                  master, task, 1, worker_replicas, False, ps_tasks,
                  worker_job_name, is_chief, FLAGS.train_dir,
                  FLAGS.save_interval_secs, FLAGS.log_every_n_steps)
Ejemplo n.º 2
0
def main():
    gc.collect()  # Garbage collect

    # Check arguments
    if len(sys.argv) < 2:
        return showUsage()
    ui.clear()
    # Pre-process PDFs
    dirname = sys.argv[1]
    images, targets, plotType = pproc.processPDFs(dirname)

    # Extract feature vectors (until user quits)
    doneExtracting = False
    while not doneExtracting:
        data, ftType = ft.extract_features(images)

        # Create, train, and evaluate model (until user quits)
        doneTraining = False
        while not doneTraining:
            tr.train(data, targets, plotType, ftType)
            options = ["Try another model", "Extract new features", "Quit"]
            res = ui.prompt(options=options)
            if options[int(res)] == "Quit":
                doneTraining = True
                doneExtracting = True
            elif options[int(res)] == "Extract new features":
                doneTraining = True
        gc.collect()  # Garbage collect
    def policyIteration(self, start_round, rounds, episodes, iterations, dup):
        for i in range(start_round, start_round + rounds + 1):

            net = self.nnet
            self.mcts = MCTS(net, iterations)
            mcts = self.mcts
            print("ROUND")
            print(i)
            path = "Models/checkpoint" + "_" + str(i) + "_" + str(episodes) + "_" + str(mcts.iterations) + "_" + str(dup) + ".pth"
            print("model " + path + " saved")
            torch.save(net.state_dict(), path)
            state_dict = torch.load(path)
            net.load_state_dict(state_dict)
            
            if i >= rounds:
                return self.nnet
            
            for e in range(episodes):
                print(e)
                self.data += self.executeEpisode()       # collect examples from this game
                print(len(self.data))
            
            if dup:
                duplicate =  [(encode_reverse(x[0]), x[1], x[2]) for x in self.data]
                self.data += duplicate
            
            datasets = np.array(self.data)
            optimizer = optim.Adam(net.parameters(), lr=0.001, betas=(0.8, 0.999))
            scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[50,100,150,200,250,300,400], gamma=0.77)
            train(net, datasets, optimizer, scheduler, 0, 0, 0)
            self.nnet = net
            self.data = []
        
        return self.nnet
Ejemplo n.º 4
0
def main():
    args = setup_parser().parse_args()
    param = load_json(args.config)
    args = vars(args)  # Converting argparse Namespace to a dict.
    args.update(param)  # Add parameters from json

    train(args)
Ejemplo n.º 5
0
def main():
    process_URL_list('URL.txt', 'url_features.csv')
    # process_test_list("query.txt",'query_features.csv')
    tr.train(
        'url_features.csv', 'url_features.csv'
    )  # arguments:(input_training feature,test/query traning features)
    tr.train('url_features.csv', 'query_features.csv')
Ejemplo n.º 6
0
def main():
    args = arguments()

    num_templates = 25  # 29  # 25  # aka the number of clusters

    train_loader, weights_dir = get_dataloader(args.traindata, args, num_templates)

    model = DetectionModel(num_objects=1, num_templates=num_templates)
    loss_fn = DetectionCriterion(num_templates)

    optimizer = optim.SGD(model.learnable_parameters(args.lr), lr=args.lr, momentum=args.momentum,
                          weight_decay=args.weight_decay)
    # optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay)

    if args.resume:
        checkpoint = torch.load(args.resume)
        model.load_state_dict(checkpoint['model'])
        optimizer.load_state_dict(checkpoint['optimizer'])
        # Set the start epoch if it has not been
        if not args.start_epoch:
            args.start_epoch = checkpoint['epoch']

    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=20, last_epoch=args.start_epoch-1)

    # train and evalute for `epochs`
    for epoch in range(args.start_epoch, args.epochs):
        scheduler.step()
        trainer.train(model, loss_fn, optimizer, train_loader, epoch, save_path=weights_dir)
Ejemplo n.º 7
0
def main(argv=None):
    writer = Writer(RESULTS_DIR)
    trainer = Trainer(RESULTS_DIR, 'train', writer)
    trainer.train(LEARNING_RATE,
                  EVAL_FREQUENCY,
                  init_step=None,
                  restoring_file=RESTORING_FILE)
def train_skip_wandb():
    # env = SimpleRandomGeometricNonEpisodicShapeEnv(side_length, max_steps, random_starting_pos=False)
    env = SimpleSequentialGeometricNonEpisodicShapeEnv(side_length, max_steps, random_starting_pos=False,
                                                       random_missing_pixel=False, subtract_canvas=True)
    replace = 1000
    lr = 0.001
    gamma = 0.6
    epsilon = 1
    epsilon_min = 0
    epsilon_dec = 1e-5
    # epsilon_dec = 2.5e-6  # from 1 to 0 in 400000 steps
    mem_size = 1000000
    batch_size = 32
    # checkpoint_dir = config.checkpoint_dir

    n_states = env.num_states
    n_actions = env.num_actions - 2
    n_hidden = 128
    name = test_name + '/lr' + str(lr) + '_gamma' + str(gamma) + '_epsilon' + str(
        epsilon) + '_batch_size' + str(batch_size) + '_fc_size' + str(n_hidden)
    # agent = Agent(n_states, n_actions, n_hidden, lr, gamma, epsilon, epsilon_min, epsilon_dec, replace, mem_size,
    # batch_size, name, 'models/')
    # agent = Agent(n_states, n_actions, n_hidden, lr, gamma, epsilon, epsilon_min, epsilon_dec, replace, mem_size,
    #               batch_size, name, 'models/')
    # agent = DuelingDDQNAgent(n_states, n_actions, n_hidden, lr, gamma, epsilon, epsilon_min, epsilon_dec, replace, mem_size,
    #              batch_size, name, 'models/')
    agent = AgentDoubleOut(n_states, n_actions, n_hidden, lr, gamma, epsilon, epsilon_min, epsilon_dec, replace, mem_size,
                 batch_size, name, 'models/')
    train(name, env, agent, n_train_games_to_avg=50, eval_games_freq=1000, n_eval_games=50, plots_path='plots/', max_steps=50)
Ejemplo n.º 9
0
def main(args):
    # Create directories
    if not os.path.exists("./logs"):
        os.makedirs("./logs")
    if not os.path.exists("./pytorch_models"):
        os.makedirs("./pytorch_models")

    # Set logs
    tb_writer = SummaryWriter('./logs/tb_{0}'.format(args.log_name))
    log = set_log(args)

    # Create env
    env = make_env(log, args)

    # Set seeds
    env.seed(args.seed)
    torch.manual_seed(args.seed)
    np.random.seed(args.seed)

    # Initialize policy
    agent = set_policy(env, tb_writer, log, args, name=args.algorithm)

    if args.test:
        from tester import test
        test(agent=agent, env=env, log=log, tb_writer=tb_writer, args=args)
    else:
        from trainer import train
        train(agent=agent, env=env, log=log, tb_writer=tb_writer, args=args)
Ejemplo n.º 10
0
def main():
    # Setup logging
    logging.basicConfig(
        format='%(asctime)s - %(levelname)s - %(name)s -   %(message)s',
        datefmt='%m/%d/%Y %H:%M:%S',
        level=logging.INFO)

    # Parse args
    args = parse_args()
    logger.info(vars(args))

    # Setup CUDA, GPU training
    os.environ["CUDA_VISIBLE_DEVICES"] = args.cuda_id
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    args.device = device
    logger.info('Device is %s', args.device)

    # Set seed
    set_seed(args)

    tokenizer = BertTokenizer.from_pretrained(args.bert_model_dir)
    args.tokenizer = tokenizer

    # Load datasets and vocabs
    train_dataset, test_dataset, word_vocab, dep_tag_vocab, pos_tag_vocab = load_datasets_and_vocabs(
        args)

    model = Aspect_CS_GAT_BERT(args)

    model.to(args.device)
    # Train
    train(args, train_dataset, model, test_dataset, word_vocab)
Ejemplo n.º 11
0
def main():
    """Main function to run model."""
    config = get_config(os.environ)

    sys.path.append(os.path.join('tasks', config.task_folder))
    # pylint: disable=import-error
    from trainer import train
    from tester import test
    # pylint: enable=import-error

    if config.is_distributed:
        torch.cuda.set_device(config.local_rank)
        torch.distributed.init_process_group(backend='nccl',
                                             init_method='env://')

    logger = setup_logger(config.work_dir, distributed_rank=get_rank())
    logger.info(f'Using {config.num_gpus} GPUs.')
    logger.info(f'Collecting environment info:{get_env_info()}')
    logger.info(f'------------------------------')
    logger.info(f'Running configurations:')
    for key, val in config.__dict__.items():
        logger.info(f'  {key}: {val}')
    logger.info(f'------------------------------')

    if config.run_mode == 'train':
        train(config, logger)
    elif config.run_mode == 'test':
        test(config, logger)
Ejemplo n.º 12
0
def main(args):
    # Set logging
    if not os.path.exists("./log"):
        os.makedirs("./log")

    log = set_log(args)
    tb_writer = SummaryWriter('./log/tb_{0}'.format(args.log_name))

    # Set seed
    set_seed(args.seed, cudnn=args.make_deterministic)

    # Set sampler
    sampler = BatchSampler(args, log)

    # Set policy
    policy = CaviaMLPPolicy(
        input_size=int(np.prod(sampler.observation_space.shape)),
        output_size=int(np.prod(sampler.action_space.shape)),
        hidden_sizes=(args.hidden_size, ) * args.num_layers,
        num_context_params=args.num_context_params,
        device=args.device)

    # Initialise baseline
    baseline = LinearFeatureBaseline(
        int(np.prod(sampler.observation_space.shape)))

    # Initialise meta-learner
    metalearner = MetaLearner(sampler, policy, baseline, args, tb_writer)

    # Begin train
    train(sampler, metalearner, args, log, tb_writer)
Ejemplo n.º 13
0
def main():
    """ Main Function. """
    # dataloader parameters
    data_path = 'data/kitti2012/training'
    receptive_size = 9
    max_disp = 128
    batch_size = 5
    num_workers = 0
    # training parameters
    learning_rate = 1e-2
    max_epochs = 2
    criterion = nn.CrossEntropyLoss()

    # create network
    net = SiameseNetwork()
    print(net)

    # create dataloader
    dataloaders, dataset_sizes = get_loaders(data_path, receptive_size,
                                             max_disp, batch_size, num_workers)
    # create optimizer
    p = net.parameters()
    optimizer = torch.optim.Adagrad(p, learning_rate)

    # train the network
    train(net, dataloaders, dataset_sizes, criterion, optimizer, max_epochs)
 def train(self, train_x, train_y):
     input_dim = train_x.shape[1]
     self.model = MetricLearningModel(input_dim=input_dim,
                                      hidden_dim=self.hidden_dim,
                                      aplha=self.alpha,
                                      lambda1=self.lambda1,
                                      lambda2=self.lambda2,
                                      dropout_p=self.dropout,
                                      num_layers=self.num_layers)
     self.optimizer = Adam(self.model.parameters())
     if self.cuda:
         self.model.cuda(device=0)
     self.dataset = DataSet(self.batch_size, train_x.shape[1])
     for _x, _y in zip(train_x, train_y):
         if numpy.random.uniform() <= 0.1:
             self.dataset.add_data_entry(_x.tolist(), _y.item(), 'valid')
         else:
             self.dataset.add_data_entry(_x.tolist(), _y.item(), 'train')
     self.dataset.initialize_dataset(balance=self.balance,
                                     output_buffer=self.output_buffer)
     train(model=self.model,
           dataset=self.dataset,
           optimizer=self.optimizer,
           num_epochs=self.num_epoch,
           max_patience=self.max_patience,
           cuda_device=0 if self.cuda else -1,
           output_buffer=self.output_buffer)
     if self.output_buffer is not None:
         print('Training Complete', file=self.output_buffer)
Ejemplo n.º 15
0
def run(args, device):
    train_set, dev_set, test_set, train_labels, train_label_freq, input_indexer = prepare_datasets(
        args.data_setting, args.batch_size, args.max_len)
    logging.info(f'Taining labels are: {train_labels}\n')
    embed_weights = load_embedding_weights()
    label_desc = None  # load_label_embedding(train_labels, input_indexer.index_of(constants.PAD_SYMBOL))
    model = None
    for hyper_params in get_hyper_params_combinations(args):
        if args.model == 'Transformer':
            model = Transformer(embed_weights, args.embed_size,
                                args.freeze_embed, args.max_len,
                                args.num_trans_layers, args.num_attn_heads,
                                args.trans_forward_expansion,
                                train_set.get_code_count(), args.dropout_rate,
                                device)
        elif args.model == 'TransICD':
            model = TransICD(embed_weights, args.embed_size, args.freeze_embed,
                             args.max_len, args.num_trans_layers,
                             args.num_attn_heads, args.trans_forward_expansion,
                             train_set.get_code_count(),
                             args.label_attn_expansion, args.dropout_rate,
                             label_desc, device, train_label_freq)
        else:
            raise ValueError(
                "Unknown value for args.model. Pick Transformer or TransICD")

        if model:
            model.to(device)
            logging.info(f"Training with: {hyper_params}")
            train(model, train_set, dev_set, test_set, hyper_params,
                  args.batch_size, device)
Ejemplo n.º 16
0
 def cap_(self):
         global path3
         f=open('write_data.txt','r')
         lines = f.readlines()
         id = len(lines)
         f.close()          
         faceDetect = cv2.CascadeClassifier('haarcascade_frontalface_default.xml');
         sampleNum=0
         while (True):
             ret, img = cap.read()
             if len(img.shape) == 3 or len(img.shape) == 4:
                 gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
             else:
                 gray=img
             faces = faceDetect.detectMultiScale(gray, 2.5, 5)
             x=0
             y=0
             w=0
             h=0
             for (x, y, w, h) in faces:
                 sampleNum = sampleNum + 1;
                 cv2.imwrite(path3+"/User." +str(id)+ "." + str(sampleNum) + ".jpg", gray[y:y + h, x:x + w])
             cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
             height, width, bytesPerComponent = img.shape
             bytesPerLine = bytesPerComponent * width
             cv2.cvtColor(img, cv2.COLOR_BGR2RGB, img)
             self.image=QImage(img.data,width,height,bytesPerLine,QImage.Format_RGB888)
             self.label_camera.setPixmap(QPixmap.fromImage(self.image).scaled(self.label_camera.width(),self.label_camera.height()))
             cv2.waitKey(200);
             if (sampleNum > 100):
                 QMessageBox.information(self,"成功","录入完毕")
                 break
             cv2.destroyAllWindows()
         trainer.train(id)
Ejemplo n.º 17
0
def main():
    args = parse_args()
    print('\nCalled with args:')
    for key in args:
        print(f"{key:<10}:  {args[key]}")
    print("=" * 78)

    # get the command line args
    max_lr = args["max_lr"]
    min_lr = args["min_lr"]
    batch_size = args["batch_size"]
    num_epochs = args["epochs"]
    save_dir_path = args["save_dir_path"]
    if save_dir_path == "":
        save_dir_path = './model_checkpoints'

    # get the data
    print("\nLoading data now.", end=" ")
    x_train, y_train, x_test, y_test, y_train_cat, y_test_cat = get_cifar_data(
    )
    training_data = [x_train, y_train, y_train_cat]
    validation_data = [x_test, y_test, y_test_cat]
    print("Data loading complete. \n")

    # pass the arguments to the trainer
    train(training_data=training_data,
          validation_data=validation_data,
          batch_size=batch_size,
          nb_epochs=num_epochs,
          min_lr=min_lr,
          max_lr=max_lr,
          save_dir_path=save_dir_path)
Ejemplo n.º 18
0
def main(args):
    # Create directories
    if not os.path.exists("./logs"):
        os.makedirs("./logs")
    if not os.path.exists("./pytorch_models"):
        os.makedirs("./pytorch_models")

    # Set logs
    log = set_log(args)
    tb_writer = SummaryWriter('./logs/tb_{0}'.format(args.log_name))

    # Create env
    env = make_env(args)

    # Set seeds
    random.seed(args.seed)
    np.random.seed(args.seed)
    torch.manual_seed(args.seed)
    env.seed(args.seed)

    # Initialize agents
    agent1 = Agent(env, log, tb_writer, args, name="agent1", i_agent=1)
    agent2 = Agent(env, log, tb_writer, args, name="agent2", i_agent=2)

    # Start train
    train(agent1, agent2, env, log, tb_writer, args)
Ejemplo n.º 19
0
def main(config_file,mode,distributed):
    config = check_params(config_file)
    if mode in ["Train","train"]:
        train_dataset = Dataset(config["train_params"]["input_path"],config["train_params"]["imsize"])
        if distributed:
            import horovod as hvd
            hvd.init()
            if hvd.rank()==0:
                writer = setup_tensorboard(get_params(config["train_params"],"tensorboard_location","./summary/"))
            train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset, num_replicas=hvd.size(),
                                                                            rank=hvd.rank())

            train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=config["train_params"]["batch_size"],
                                                       sampler=train_sampler, shuffle=True)
            model = ConvLSTM(**config["model_params"])
            optimizer = hvd.DistributedOptimizer(model.optimizer, named_parameters=model.named_parameters())
            hvd.broadcast_parameters(model.state_dict(), root_rank=0)
            train_distributed(model,train_loader,optimizer,config,writer)
        else:
            writer = setup_tensorboard(get_params(config["train_params"], "tensorboard_location", "./summary/"))
            train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=config["train_params"]["batch_size"],
                                                     shuffle = True)
            model = ConvLSTM(**config["model_params"])
            train(model,train_loader,model.optimizer,config,writer)
    elif mode in ["infer","Infer"]:
        model = ConvLSTM(**config["model_params"])
        model.load_state_dict(config["infer_params"]["model_save_path"])
        output_file = open(config["infer_params"]["output_path"])
Ejemplo n.º 20
0
def rnn_main(dataset):
    model = LanguageModel(dataset.vocab).to(_flags.device())

    def sample():
        return dataset.sample_train(aug_ratio=FLAGS.aug_ratio)

    def score_utts(utts):
        fake = [((), utt) for utt in utts]
        batch = make_batch(fake, model.vocab, staged=False)
        mean = model(None, batch.out_data, None, None).item()
        tot = mean * sum(len(utt) - 1 for utt in utts)
        return tot

    def callback(i_epoch):
        model.eval()
        final = i_epoch == FLAGS.n_epochs - 1
        with hlog.task("eval_val", timer=False):
            val_acc = evaluate(score_utts, dataset.get_val(), dataset)
        if FLAGS.TEST and (final or FLAGS.test_curve):
            with hlog.task("eval_test", timer=False):
                evaluate(score_utts, dataset.get_test(), dataset)
        if (i_epoch + 1) % FLAGS.n_checkpoint == 0:
            torch.save(
                model.state_dict(),
                os.path.join(FLAGS.model_dir, "model.%05d.chk" % i_epoch))
        return val_acc

    train(dataset, model, sample, callback, staged=False)
Ejemplo n.º 21
0
def main():
    env_name = 'BreakoutNoFrameskip-v4'
    env = atari_wrappers.wrap_deepmind(atari_wrappers.make_atari(env_name),
                                       episode_life=True,
                                       clip_rewards=True,
                                       frame_stack=True,
                                       scale=True)
    output_size = env.action_space.n
    input_shape = env.observation_space.shape

    with tf.Session() as sess:
        with tf.variable_scope('Breakout_lr'):
            input = tf.placeholder(tf.float32, [None, *input_shape])

            model = PPO(sess,
                        input,
                        models.nature_cnn(input),
                        actiontype.Discrete,
                        output_size,
                        learning_rate=lambda f: 2.5e-4 * (1 - f),
                        epochs=4,
                        minibatch_size=4,
                        gamma=0.99,
                        beta2=0.01,
                        name='Breakout_lr')
        train(sess,
              model,
              env_name,
              1e7,
              256,
              log_interval=5,
              num_envs=16,
              atari=True)
        #run_only(sess, model, env, render=True)
        env.close()
Ejemplo n.º 22
0
def fit(args, model, device, optimizer, loss_fn, dataset, labels_list, task_id):
    # Dataloader
    train_loader = trainer.get_loader(mnist.getTrain(dataset), args, device, 'train')
    val_loader = trainer.get_loader(mnist.getVal(dataset), args, device, 'val')
    # Log Best Accuracy
    best_val_loss = 0
    # Early Stopping
    early_stop = 0

    # Training loop
    for epoch in range(1, args.epochs + 1):
        # Prepare model for current task
        model.set_task_id(labels_list[task_id])
        trainer.train(args, model, device, train_loader, optimizer, epoch, loss_fn)
        val_loss, _ = trainer.test(args, model, device, val_loader, loss_fn, val=True)
        if val_loss > best_val_loss:
            best_val_loss = val_loss
            best_state = model.state_dict()
            early_stop = 0
        else:
            early_stop += 1
            if early_stop >= args.early_stop_after:
                break
    
    return best_state
Ejemplo n.º 23
0
def main(argv):
    torch.manual_seed(FLAGS.seed)
    np.random.seed(FLAGS.seed)

    hlog.flags()

    if not os.path.exists(FLAGS.model_dir):
        os.mkdir(FLAGS.model_dir)

    dataset = get_dataset()
    model = StagedModel(dataset.vocab, copy=True,
                        self_attention=False).to(_flags.device())
    #model = RetrievalModel(
    #    dataset.vocab
    #)
    model.prepare(dataset)

    def callback(i_epoch):
        model.eval()
        evaluate(dataset, model)
        if (i_epoch + 1) % FLAGS.n_checkpoint == 0:
            torch.save(
                model.state_dict(),
                os.path.join(FLAGS.model_dir, "model.%05d.chk" % i_epoch))

    train(dataset, model, dataset.sample_comp_train, callback, staged=True)
Ejemplo n.º 24
0
def main(_):

    if "absl.logging" in sys.modules:
        import absl.logging

        absl.logging.set_verbosity("info")
        absl.logging.set_stderrthreshold("info")

    config = FLAGS.config
    print(config)

    # Set the seed
    torch.manual_seed(config.seed)
    np.random.seed(config.seed)

    # Check if in the correct branch
    # group_name = config["model"][: config["model"].find("sa")]
    # if group_name not in ["z2", "mz2", "p4", "p4m"]:
    #     raise ValueError(
    #         "Mlp_encoding is required for rotations finer than 90 degrees. Please change to the mlp_encoding branch."
    #     )

    # initialize weight and bias
    os.environ["WANDB_API_KEY"] = "691777d26bb25439a75be52632da71d865d3a671"
    if not config.train:
        os.environ["WANDB_MODE"] = "dryrun"

    wandb.init(
        project="equivariant-attention",
        config=config,
        group=config["dataset"],
        entity="equivatt_team",
    )

    # Define the device to be used and move model to that device
    config["device"] = (
        "cuda:0" if (config.device == "cuda" and torch.cuda.is_available()) else "cpu"
    )
    model = get_model(config)

    # Define transforms and create dataloaders
    dataloaders = dataset.get_dataset(config, num_workers=4)

    # Create model directory and instantiate config.path
    model_path(config)

    if config.pretrained:
        # Load model state dict
        model.module.load_state_dict(torch.load(config.path), strict=False)

    # Train the model
    if config.train:
        # Print arguments (Sanity check)
        print(config)
        print(datetime.datetime.now())
        # Train the model
        trainer.train(model, dataloaders, config)

    # Test model
    tester.test(model, dataloaders["test"], config)
Ejemplo n.º 25
0
def process(conf):
    """
    
    :param conf: Configurator 
    :return: 
    """
    conf = dataset_creation(conf)
    train(conf)
Ejemplo n.º 26
0
def run(args):
    ms.context.set_context(
        mode=ms.context.GRAPH_MODE,
        device_target=args.device,
        save_graphs=False,
    )

    net = LeNet5(
        num_class=10,
        num_channel=3,
        use_bn=args.use_bn,
        dbg_log_tensor=args.log_tensor,
    )

    loss = ms.nn.loss.SoftmaxCrossEntropyWithLogits(
        sparse=True,
        reduction='mean',
    )
    opt = build_optimizer(args, net)

    if args.mode == 'init':
        save_checkpoint(
            net,
            ckpt_file_name=os.path.join('seeds', '%d.ckpt' % (time.time())),
        )

    if args.mode == 'train':
        ds_train = create_dataset(
            args=args,
            data_path=os.path.join(args.data_path, 'train'),
            batch_size=args.device_batch_size,
        )
        if args.init_ckpt:
            print('using init checkpoint %s' % (args.init_ckpt))
            load_ckpt(net, args.init_ckpt)
        train(args, net, loss, opt, ds_train)

    if args.mode == 'test':
        if args.use_kungfu:
            rank = kfops.kungfu_current_rank()
            if rank > 0:
                return
        ds_test = create_dataset(
            args=args,
            data_path=os.path.join(args.data_path, 'test'),
            batch_size=args.device_batch_size,
        )

        if args.ckpt_files:
            checkpoints = args.ckpt_files.split(',')
        else:
            checkpoint_dir = get_ckpt_dir(args)
            print('checkpoint_dir: %s' % (checkpoint_dir))
            checkpoints = list(sorted(glob.glob(checkpoint_dir + '/*.ckpt')))
        print('will test %d checkpoints' % (len(checkpoints)))
        # for i, n in enumerate(checkpoints):
        #     print('[%d]=%s' % (i, n))
        test(args, net, loss, opt, ds_test, checkpoints)
Ejemplo n.º 27
0
def main(config):

    if config.task == 'train':
        config.train = 1
    else:
        config.train = 0

    if config.dataset == 'life':
        config.task = 'regression'
        config.experiment = 'train-test'
    else:
        config.task = 'classification'
        config.experiment = 'doublecv'

    config.expt_name = "Exp" + str(
        config.experiment
    ) + "_" + config.mod_split + "_" + config.build_model + "_" + config.last_layer

    # Create save directories
    utils.create_directories(config)
    data = load_dataset(config)

    if config.experiment == 'mar_doublecv' or config.experiment == 'doublecv':
        n_feature_sets = len(data.keys()) - 1
    elif config.dataset == 'life':
        n_feature_sets = int(len(data.keys()) / 2) - 1

    X = [np.array(data['{}'.format(i)]) for i in range(n_feature_sets)]
    y = np.array(data['y'])

    X_test = None
    y_test = None

    if config.task == 'classification':
        config.n_classes = len(set(y))

    if config.dataset == 'life':
        X_test = [
            np.array(data['{}_test'.format(i)]) for i in range(n_feature_sets)
        ]
        y_test = np.array(data['y_test'])

    config.n_feature_sets = n_feature_sets
    config.feature_split_lengths = [i.shape[1] for i in X]

    if config.verbose > 0:
        print('Dataset used ', config.dataset)
        print('Number of feature sets ', n_feature_sets)
        [
            print('Shape of feature set {} {}'.format(e,
                                                      np.array(i).shape))
            for e, i in enumerate(X)
        ]

    trainer.train(X, y, config, X_test, y_test)

    print(config.expt_name)
    print(config.dataset)
Ejemplo n.º 28
0
def runner(args):
    config, name, port = args
    save_path = os.path.join(base_dir, name)
    os.makedirs(save_path, exist_ok=True)
    train(config,
          n_episodes=1000,
          save_path=save_path,
          base_port=port,
          name=name)
Ejemplo n.º 29
0
 def clicke_(self):
     name = self.text_name.text()
     f = open('write_data.txt', 'r')
     lines = f.readlines()
     id = len(lines)
     f.close()
     id += 1
     create.create(id, name)
     trainer.train()
def main():
    args = setup_parser().parse_args()
    param = load_json(args.config)
    args = vars(args)  # Converting argparse Namespace to a dict.
    args.update(param)  # Add parameters from json
    '''@Author:defeng
        first use args to get the parameter of config.json, then add the params in config.json to args.
    '''

    train(args)
Ejemplo n.º 31
0
def _train(command_list):

    # validate command list
    if _validate_train_commands(command_list):
        algorithm = command_list[1]
        filename = "input_data/" + command_list[2]

        # read training data from csv
        training_data = _read_csv(filename)

        # parse training data to build features and build classifier, catching errors returned by parser
        parsed_training_data = parser.prepare_training_data(training_data)
        if type(parsed_training_data) is str:
            print(parsed_training_data)
            return None
        else:
            classifier = trainer.train(parsed_training_data, algorithm)

            print("...Training complete.")

            # debugging output of classifier details
            # currently only works for naive Bayes... need tree-to-string to print random forest
            # _write_csv("output_data/classifier_details.csv", classifier.classifier_details)

            return classifier
    else:
        return None
Ejemplo n.º 32
0
def main(argv=None):
  writer = Writer(RESULTS_DIR)
  trainer = Trainer(RESULTS_DIR, 'train', writer)
  tester = Tester(RESULTS_DIR, 'valid', writer)

  step, _ = tester.test(EVAL_STEP_NUM)
  while (step < LAST_STEP):
    lr = learning_rate(step)
    step, _ = trainer.train(lr, EVAL_FREQUENCY, step, RESTORING_FILE)
    tester.test(EVAL_STEP_NUM, step)
Ejemplo n.º 33
0
def main(training_dir, test_file, output_file):
    print('Training...')
    training_data = train(training_dir)

    print('Processing...')
    final_data = process(training_data, test_file)
    
    print('Writing results...')
    output_result(final_data, output_file)

    print('Done.')
Ejemplo n.º 34
0
def train(batch, remote, debug, dependency = []):
    params = cache.get("batch/%s/params" % batch, remote)
    numEpisodes = params['episodes']['num']
    
    trainParams = params['train']
    numIters = trainParams['iters']
    
    ij_ = [(i, j) for i, j in it.product(range(numEpisodes), range(numIters))]
    f = lambda (i, j) : trainer.train(batch, params, i, j, remote, debug)
    
    logging.info("running %s train instances" % len(ij_))
    if (remote):
        k_ = cloud.map(f, ij_, _label = "%s/train" % batch, _depends_on = dependency, _type = 'c1', _max_runtime = 30)
        logging.info("k_ %s" % k_)
        return k_
    else:
        results = map(f, ij_)
        return results
def main(argv=None):

  writer = Writer(RESULTS_DIR)
  trainer = Trainer(RESULTS_DIR, 'train', writer)
  tester = Tester(RESULTS_DIR, 'valid', writer)

  params_file = os.path.join(RESULTS_DIR, PARAMS_FILE)
  if (os.path.isfile(params_file)):
    with open(params_file, 'r') as handle:
      params = json.load(handle)
  else:
    params = {}
    params['min_test_step'], params['min_test_loss'] = tester.test(EVAL_STEP_NUM)
    params['step'] = params['min_test_step']
    params['unchanged'] = 0
    params['num_decays'] = 0
    params['learning_rate'] = LEARNING_RATE

  while (params['num_decays'] <= MAX_DECAYS):
    params['step'], _ = trainer.train(params['learning_rate'], EVAL_FREQUENCY,
                                      params['step'], RESTORING_FILE)
    _, test_loss = tester.test(EVAL_STEP_NUM, params['step'])
    if (test_loss < params['min_test_loss']):
      params['min_test_loss'] = test_loss
      params['min_test_step'] = params['step']
      params['unchanged'] = 0
    else:
      params['unchanged'] += EVAL_FREQUENCY
      if (params['unchanged'] >= PATIENCE):
        params['learning_rate'] *= DECAY_FACTOR
        params['num_decays'] += 1
        params['step'] = params['min_test_step']
        params['unchanged'] = 0

    with open(params_file, 'w') as handle:
      json.dump(params, handle, indent=2)
    print(params)
Ejemplo n.º 36
0
import trainer
import numpy as np
import theanets
import glob


np.set_printoptions(precision=3)

mode = raw_input("1: Train\n2: Load\n3: Live\n")
exp = theanets.Experiment(
        theanets.feedforward.Regressor,
        layers=(config.IMG_W * config.IMG_H, 500, 1)
        )

if mode == "1":
    trainer.train(exp)

if mode == "2":
    exp = exp.load(path="net.data")
    print "Manual validation:"
    for file in glob.glob("data/manual/*.jpg"):
        image = util_image.load(file)
        input = util_image.data(image)
        input = input.reshape(1, len(input))
        output = exp.predict(input)
        print "Prediction for ", file, " = ", output

if mode == "3":
    exp = exp.load(path="net.data")
    session = util_guru.start()
    while True:
Ejemplo n.º 37
0
            np.random.shuffle(train_epoch_data)
            #np.random.shuffle(val_epoch_data)

            #Full pass over the training data
            train_gen = ParallelBatchIterator(generator_train, train_epoch_data, ordered=False,
                                                batch_size=P.BATCH_SIZE_TRAIN//3,
                                                multiprocess=P.MULTIPROCESS_LOAD_AUGMENTATION,
                                                n_producers=P.N_WORKERS_LOAD_AUGMENTATION)

            self.do_batches(self.train_fn, train_gen, self.train_metrics)

            # And a full pass over the validation data:
            val_gen = ParallelBatchIterator(generator_val, val_epoch_data, ordered=False,
                                                batch_size=P.BATCH_SIZE_VALIDATION//3,
                                                multiprocess=P.MULTIPROCESS_LOAD_AUGMENTATION,
                                                n_producers=P.N_WORKERS_LOAD_AUGMENTATION)

            self.do_batches(self.val_fn, val_gen, self.val_metrics)
            self.post_epoch()

if __name__ == "__main__":
    X_train = glob.glob(P.FILENAMES_TRAIN)
    X_val = glob.glob(P.FILENAMES_VALIDATION)

    train_generator = dataset_2D.load_images
    validation_generator = dataset_2D.load_images

    trainer = ResNetTrainer()
    trainer.train(train_generator, X_train, validation_generator, X_val)
def main(argv=None):

  hyper_file = os.path.join(RESULTS_DIR, HYPER_FILE)
  if (os.path.isfile(hyper_file)):
    with open(hyper_file, 'r') as handle:
      hyper = json.load(handle)
  else:
    hyper = {}
    hyper['min_test_step'] = LAYERS_NUM
    hyper['step'] = hyper['min_test_step']
    hyper['unchanged'] = 0
    hyper['restfile'] = RESTORING_FILE

  while (hyper['unchanged'] < HYPER_PATIENCE):
    results_dir = os.path.join(RESULTS_DIR, str(hyper['step']))
    writer = Writer(results_dir)
    trainer = Trainer(results_dir, 'train', writer, hyper['step'])
    tester = Tester(results_dir, 'valid', writer, hyper['step'])

    params_file = os.path.join(results_dir, PARAMS_FILE)
    if (os.path.isfile(params_file)):
      with open(params_file, 'r') as handle:
        params = json.load(handle)
    else:
      params = {}
      params['min_test_step'], params['min_test_loss'] = tester.test(EVAL_STEP_NUM)
      params['step'] = params['min_test_step']
      params['unchanged'] = 0
      params['num_decays'] = 0
      params['learning_rate'] = LEARNING_RATE

    if ('min_test_loss' not in hyper):
      hyper['min_test_loss'] = params['min_test_loss']

    while (params['num_decays'] <= MAX_DECAYS):
      params['step'], _ = trainer.train(params['learning_rate'], EVAL_FREQUENCY,
                                        params['step'], hyper['restfile'])
      _, test_loss = tester.test(EVAL_STEP_NUM, params['step'])
      if (test_loss < params['min_test_loss']):
        params['min_test_loss'] = test_loss
        params['min_test_step'] = params['step']
        params['unchanged'] = 0
      else:
        params['unchanged'] += EVAL_FREQUENCY
        if (params['unchanged'] >= PATIENCE):
          params['learning_rate'] *= DECAY_FACTOR
          params['num_decays'] += 1
          params['step'] = params['min_test_step']
          params['unchanged'] = 0

      with open(params_file, 'w') as handle:
        json.dump(params, handle, indent=2)
      print(params)

    #tester.test(step_num=None, init_step=params['min_test_step'])

    if (params['min_test_loss'] < hyper['min_test_loss']):
      hyper['min_test_loss'] = params['min_test_loss']
      hyper['min_test_step'] = hyper['step']
      hyper['unchanged'] = 0
    else:
      hyper['unchanged'] += 1

    hyper['restfile'] = os.path.join(results_dir, model_file(params['min_test_step']))
    hyper['step'] += 2
    with open(hyper_file, 'w') as handle:
      json.dump(hyper, handle, indent=2)
    print(hyper)

    print('\n NEW HYPER PARAMETER: %d' %hyper['step'])
Ejemplo n.º 39
0
def main(argv=None):
  writer = Writer(RESULTS_DIR)
  trainer = Trainer(RESULTS_DIR, 'train', writer)
  trainer.train(LEARNING_RATE, EVAL_FREQUENCY, init_step=None, restoring_file=RESTORING_FILE)
Ejemplo n.º 40
0
    else:
        model_name = "model"

    np.random.seed(conf.RANDOM_SEED)

    t0 = time()

    ### convert data ###
    if not os.path.exists("../data"):

        print "Converting data...\n"

        os.makedirs("../data")

        vocabulary = utils.load_vocabulary(conf.VOCABULARY_FILE)

        converter.convert_files(conf.PHASE1["TRAIN_DATA"], vocabulary, conf.PUNCTUATIONS, conf.BATCH_SIZE, False, PHASE1_TRAIN_PATH)
        converter.convert_files(conf.PHASE1["DEV_DATA"], vocabulary, conf.PUNCTUATIONS, conf.BATCH_SIZE, False, PHASE1_DEV_PATH)
        if conf.PHASE2["TRAIN_DATA"] and conf.PHASE2["DEV_DATA"]:
            converter.convert_files(conf.PHASE2["TRAIN_DATA"], vocabulary, conf.PUNCTUATIONS, conf.BATCH_SIZE, conf.PHASE2["USE_PAUSES"], PHASE2_TRAIN_PATH)
            converter.convert_files(conf.PHASE2["DEV_DATA"], vocabulary, conf.PUNCTUATIONS, conf.BATCH_SIZE, conf.PHASE2["USE_PAUSES"], PHASE2_DEV_PATH)

    ### train model ###
    print "Training model...\n"

    if not os.path.exists("../out"):
        os.makedirs("../out")
    
    trainer.train(model_name, PHASE1_TRAIN_PATH, PHASE1_DEV_PATH, PHASE2_TRAIN_PATH, PHASE2_DEV_PATH)

    print "Done in %.2f minutes" % ((time() - t0) / 60.)
Ejemplo n.º 41
0
input_path = "/home/jake/Dropbox/Projects/Sentiment Analysis/yelp_dataset/yelp_academic_dataset"
output_path = "/home/jake/Dropbox/Projects/Sentiment Analysis/my_data/training_test"

sc = SparkContext("local", "NBTrainer")

all_reviews = sc.textFile(input_path).map(simplejson.loads).filter(lambda datum: datum['type']=='review')

total = 330071

sample_size = 100

training_data = all_reviews.sample(False, float(sample_size)/float(total))

def categoryof(datum):
    if datum['stars'] > 3:
        return 'pos'
    else:
        return 'neg'

def textof(datum):
    return datum['text']



output = train(training_data, categoryof, textof)

output.map(simplejson.dumps).saveAsTextFile(output_path)


Ejemplo n.º 42
0
from trainer import train
import submission as subm
import numpy as np
import files_load as fl
import sys
from random import shuffle

if len(sys.argv) != 3:
    exit(1)
trainD = fl.loadmatrixs(sys.argv[1])
validD = fl.loadmatrixs(sys.argv[2])
ftrainD, mtrainD = zip(*trainD)

mean, eigenvec, thetas = train(mtrainD)
print "Mean: ", mean
print "eigenvec: \n", eigenvec
count = 0
for idx, data in enumerate(validD):
    success = False
    filename, mtx = data
    thetaSubmit = subm.submit(mtx, mean, eigenvec)
    matchIdx = subm.compareAvgGap(thetaSubmit, thetas)
    if filename[:filename.rfind("_")] == ftrainD[matchIdx][:ftrainD[matchIdx].rfind("_")]:
        success = True
        count = count + 1
    if success is True:
        print filename, " --> ", ftrainD[matchIdx], "[X]"
    else:
        print filename, " --> ", ftrainD[matchIdx], "[ ]"
print count, " / ", idx + 1, "===>", count / (idx + 1.) * 100, "%"
Ejemplo n.º 43
0
def do_experiment(experiment_dir,beats=0,bars=0,nCodes=0,nIter=1e7,
                  partialbar=0,keyInv=False,songKeyInv=True,lrate=1e-3,
                  mat_dir='',useModel='VQ',autobar=False,randoffset=False):
    """
    Main function to run an experiment, train a model and save to dir.
    """

    # check for 'done' file
    if os.path.exists(os.path.join(experiment_dir,'DONE.txt')):
        return

    # if experiment folder does not exist, create it
    if not os.path.exists(experiment_dir):
        print 'creating experiment dir:',experiment_dir
        os.mkdir(experiment_dir)

    # ec = exit code for training, 0 = ok, >0 = bad
    ec = 1

    # check if saved model exists
    alldirs = glob.glob(os.path.join(experiment_dir,'*'))
    if len(alldirs) > 0:
        alldirs = filter(lambda x: os.path.isdir(x), alldirs)
        alldirs = filter(lambda x: os.path.split(x)[-1][:4] == 'exp_',alldirs)
        # trim badly saved models
        alldirs = filter(lambda x: check_saved_model_full(x), alldirs)
    continue_training = len(alldirs) > 0

    # continue from saved model
    if continue_training:
        # find most recent saved mdoel, and continue!
        # ec = exit_code, 0 if due to StopIteration, >0 otherwise
        savedmodel = np.sort(alldirs)[-1]
        ec = trainer.train(savedmodel)

    # no prior saved model
    if not continue_training:
        #initialize and save codebook
        codebook = initializer.initialize(nCodes, pSize=beats, usebars=bars,
                                          keyInv=keyInv, songKeyInv=songKeyInv,
                                          positive=True, do_resample=True,
                                          partialbar=partialbar, nThreads=4,
                                          oracle='MAT', artistsdb='',
                                          matdir=mat_dir,randoffset=randoffset)
        codebook_fname = os.path.join(experiment_dir,'codebook.mat')
        scipy.io.savemat(codebook_fname,{'codebook':codebook})
        print 'after initialization, codebook saved to:',codebook_fname

        # train (from scratch)
        # ec = exit_code, 0 if due to StopIteration, >0 otherwise
        ec = trainer.train(codebook_fname, expdir=experiment_dir, pSize=beats,
                           usebars=bars, keyInv=keyInv, songKeyInv=songKeyInv,
                           positive=True, do_resample=True,
                           partialbar=partialbar, lrate=lrate, nThreads=4,
                           oracle='MAT', artistsdb='',
                           matdir=mat_dir, nIterations=nIter, useModel=useModel,
                           autobar=autobar,randoffset=randoffset)

    # write done file
    if ec == 0:
        f = open(os.path.join(experiment_dir,'DONE.txt'),'w')
        f.write('experiment appear to be done\n')
        f.close()

    # assume it's a keyboard interrupt, for multiprocessing purposes
    else:
        raise KeyboardInterruptError()
Ejemplo n.º 44
0
    else:
        filename = argv[1]
        data = get_data_sets(filename)

        hmms = {}

        for label in data:
            hmms[label] = make_model(14, 8)

        print('training')
        for label in hmms:
            model = hmms[label]
            data_set = data[label]
            epochs = 3

            hmms[label] = train(model, data_set, epochs, lambda x: None)
        print('training complete\n')

        count = 0
        correct = 0

        for label, data_set in data.items():

            for observed in data_set:
                best_label = None
                max_prob = 0

                for name, model in hmms.items():
                    prob = model.probability_of_observed(observed)

                    if prob > max_prob: