Пример #1
0
    def _eval_valid_multiple_shuffle(self, model, nb_test_per_step):
        nb_shuffles = []
        avg_nll = []

        x_label = 'Nb Shuffle'
        y_label = 'Avg NLL'

        start_time = t.time()
        print "#",
        steps = [10, 100, 500]
        nb_test_per_step += 1
        for stepIdx in range(len(steps)):
            step = range_start = steps[stepIdx]
            if stepIdx != 0:
                range_start = steps[stepIdx - 1] * (nb_test_per_step -
                                                    1) + step

            for current_nb_shuffle in range(range_start,
                                            nb_test_per_step * step, step):
                print "/{0}\\".format(current_nb_shuffle),
                # TODO Fix missing variable due to change of scope
                # avg_valid_nll, avg_valid_nll_std = 0, 0  # get_mean_error_and_std(model, model.valid_log_prob, validset_theano.shape.eval()[0], shuffle_mask, current_nb_shuffle)
                avg_valid_nll = 0
                nb_shuffles += [current_nb_shuffle]
                avg_nll += [round(avg_valid_nll, 2)]
            self._save_graph('{0}shuffle_test_temp'.format(step), x_label,
                             y_label, (nb_shuffles, avg_nll, 'purple'))
            print ".",
        print get_done_text(start_time)
        return nb_shuffles, avg_nll
Пример #2
0
    def _eval_valid_multiple_shuffle(self, model, nb_test_per_step):
        nb_shuffles = []
        avg_nll = []

        x_label = 'Nb Shuffle'
        y_label = 'Avg NLL'

        start_time = t.time()
        print "#",
        steps = [10, 100, 500]
        nb_test_per_step += 1
        for stepIdx in range(len(steps)):
            step = range_start = steps[stepIdx]
            if stepIdx != 0:
                range_start = steps[stepIdx - 1] * (nb_test_per_step - 1) + step

            for current_nb_shuffle in range(range_start, nb_test_per_step * step, step):
                print "/{0}\\".format(current_nb_shuffle),
                # TODO Fix missing variable due to change of scope
                # avg_valid_nll, avg_valid_nll_std = 0, 0  # get_mean_error_and_std(model, model.valid_log_prob, validset_theano.shape.eval()[0], shuffle_mask, current_nb_shuffle)
                avg_valid_nll = 0
                nb_shuffles += [current_nb_shuffle]
                avg_nll += [round(avg_valid_nll, 2)]
            self._save_graph('{0}shuffle_test_temp'.format(step), x_label, y_label, (nb_shuffles, avg_nll, 'purple'))
            print ".",
        print get_done_text(start_time)
        return nb_shuffles, avg_nll
Пример #3
0
def get_model(model_path):
    hyperparams = utils.load_dict_from_json_file(
        os.path.join(model_path, "hyperparams"))
    hyperparams['weights_initialization'] = "Zeros"

    trainingparams = utils.load_dict_from_json_file(
        os.path.join(model_path, "trainingparams"))
    dataset_name = trainingparams['dataset_name']

    if dataset_name != "binarized_mnist":
        raise (Exception(
            "Invalid dataset. Only model trained on MNIST supported."))

    #
    # LOAD DATASET ####
    dataset = Dataset.get(dataset_name)
    if trainingparams['batch_size'] == -1:
        trainingparams['batch_size'] = dataset['train']['length']

    model = build_model(dataset, trainingparams, hyperparams,
                        hyperparams['hidden_sizes'])

    print "### Loading model | Hidden:{0} CondMask:{1} Activation:{2} ... ".format(
        hyperparams['hidden_sizes'], hyperparams['use_cond_mask'],
        hyperparams['hidden_activation']),
    start_time = t.time()
    load_model_params(model, model_path)
    print utils.get_done_text(start_time), "###"

    return model, dataset_name, dataset
Пример #4
0
def train_model(model,
                dataset,
                look_ahead,
                max_epochs,
                batch_size,
                save_model_path=None,
                trainer_status=None):
    start_training_time = t.time()

    if trainer_status is None:
        trainer_status = {
            "best_valid_error": np.inf,
            "best_epoch": 0,
            "epoch": 0,
            "nb_of_epocs_without_improvement": 0
        }

    print '\n### Training NADE ###'
    while (trainer_status["epoch"] < max_epochs
           and trainer_status["nb_of_epocs_without_improvement"] < look_ahead):
        trainer_status["epoch"] += 1

        print 'Epoch {0} (Batch Size {1})'.format(trainer_status["epoch"],
                                                  batch_size)
        print '\tTraining   ...',
        start_time = t.time()
        nb_iterations = int(np.ceil(dataset['train']['length'] / batch_size))
        train_err = 0
        for index in range(nb_iterations):
            #current_iteration = ((trainer_status["epoch"] - 1) * nb_iterations) + index
            #train_err += model.learn(index, current_iteration)
            train_err += model.learn(index)
            # print train_err

        print utils.get_done_text(start_time), " avg NLL: {0:.6f}".format(
            train_err / nb_iterations)

        print '\tValidating ...',
        start_time = t.time()
        valid_err, valid_err_std = get_mean_error_and_std(
            model, model.valid_log_prob, batch_size)
        print utils.get_done_text(start_time), " NLL: {0:.6f}".format(
            valid_err)

        if valid_err < trainer_status["best_valid_error"]:
            trainer_status["best_valid_error"] = valid_err
            trainer_status["best_epoch"] = trainer_status["epoch"]
            trainer_status["nb_of_epocs_without_improvement"] = 0
            # Save best model
            if save_model_path is not None:
                save_model_params(model, save_model_path)
                utils.save_dict_to_json_file(
                    os.path.join(save_model_path, "trainer_status"),
                    trainer_status)
        else:
            trainer_status["nb_of_epocs_without_improvement"] += 1

    print "### Training", utils.get_done_text(start_training_time), "###"
    total_train_time = t.time() - start_training_time
    return trainer_status["best_epoch"], total_train_time
Пример #5
0
    def get(dataset_name):
        datasets = ['adult',
                    'binarized_mnist',
                    'connect4',
                    'dna',
                    'mushrooms',
                    'nips',
                    'ocr_letters',
                    'rcv1',
                    'web']

        if dataset_name not in datasets:
            raise ValueError('Dataset unknown: ' + dataset_name)

        print '### Loading dataset [{0}] ...'.format(dataset_name),
        start_time = t.time()

        raw_dataset = np.load(os.path.join("datasets", dataset_name) + ".npz")
        full_dataset = {'input_size': raw_dataset['inputsize']}

        trainset_theano = theano.shared(value=raw_dataset['train_data'], borrow=True)
        validset_theano = theano.shared(value=raw_dataset['valid_data'], borrow=True)
        testset_theano = theano.shared(value=raw_dataset['test_data'], borrow=True)

        full_dataset['train'] = {'data': trainset_theano, 'length': raw_dataset['train_length']}
        full_dataset['valid'] = {'data': validset_theano, 'length': raw_dataset['valid_length']}
        full_dataset['test'] = {'data': testset_theano, 'length': raw_dataset['test_length']}

        print "(Dim:{0} Train:{1} Valid:{2} Test:{3})".format(full_dataset['input_size'], full_dataset['train']['length'], full_dataset['valid']['length'], full_dataset['test']['length']),
        print get_done_text(start_time), "###"
        return full_dataset
Пример #6
0
    def get(dataset_name):
        # List of datasets that works with the current model ?
        datasets = ['adult',
                    'binarized_mnist',
                    'connect4',
                    'dna',
                    'mushrooms',
                    'nips',
                    'ocr_letters',
                    'rcv1',
                    'rcv2_russ',
                    'web']

        # Setup dataset env
        if dataset_name not in datasets:
            raise ValueError('Dataset unknown: ' + dataset_name)
        mldataset = __import__('mlpython.datasets.' + dataset_name, globals(), locals(), [dataset_name], -1)
        datadir = os.path.join(os.getenv("MLPYTHON_DATASET_REPO"), dataset_name)

        # Verify if dataset exist and if not, download it
        if(not os.path.exists(datadir)):
            dataset_store.download(dataset_name)

        print '### Loading dataset [{0}] ...'.format(dataset_name),
        start_time = t.time()

        all_data = mldataset.load(datadir, load_to_memory=True)
        train_data, train_metadata = all_data['train']

        if dataset_name == 'binarized_mnist' or dataset_name == 'nips':
            trainset = mlpb.MLProblem(train_data, train_metadata)
        else:
            trainset = mlpb.SubsetFieldsProblem(train_data, train_metadata)

        trainset.setup()

        valid_data, valid_metadata = all_data['valid']

        validset = trainset.apply_on(valid_data, valid_metadata)

        test_data, test_metadata = all_data['test']
        testset = trainset.apply_on(test_data, test_metadata)

        # Cleaning up, packaging and theanized
        full_dataset = {'input_size': trainset.metadata['input_size']}

        trainset_theano = theano.shared(value=Dataset._clean(trainset), borrow=True)
        validset_theano = theano.shared(value=Dataset._clean(validset), borrow=True)
        testset_theano = theano.shared(value=Dataset._clean(testset), borrow=True)

        full_dataset['train'] = {'data': trainset_theano, 'length': all_data['train'][1]['length']}
        full_dataset['valid'] = {'data': validset_theano, 'length': all_data['valid'][1]['length']}
        full_dataset['test'] = {'data': testset_theano, 'length': all_data['test'][1]['length']}

        print "(Dim:{0} Train:{1} Valid:{2} Test:{3})".format(trainset.metadata['input_size'], full_dataset['train']['length'], full_dataset['valid']['length'], full_dataset['test']['length']),
        print get_done_text(start_time), "###"
        return full_dataset
Пример #7
0
def get_model(model_path):
    hyperparams = utils.load_dict_from_json_file(os.path.join(model_path, "hyperparams"))
    hyperparams['weights_initialization'] = "Zeros"

    trainingparams = utils.load_dict_from_json_file(os.path.join(model_path, "trainingparams"))
    dataset_name = trainingparams['dataset_name']

    if dataset_name != "binarized_mnist":
        raise ValueError("Invalid dataset. Only model trained on MNIST supported.")

    #
    # LOAD DATASET ####
    dataset = Dataset.get(dataset_name)
    if trainingparams['batch_size'] == -1:
        trainingparams['batch_size'] = dataset['train']['length']

    model = build_model(dataset, trainingparams, hyperparams, hyperparams['hidden_sizes'])

    print("### Loading model | Hidden:{0} CondMask:{1} Activation:{2} ... ".format(
        hyperparams['hidden_sizes'], hyperparams['use_cond_mask'], hyperparams['hidden_activation']), end=' ')
    start_time = t.time()
    load_model_params(model, model_path)
    print(utils.get_done_text(start_time), "###")

    return model, dataset_name, dataset
Пример #8
0
def train_model(model, dataset, look_ahead, max_epochs, batch_size, save_model_path=None, trainer_status=None):
    start_training_time = t.time()

    if trainer_status is None:
        trainer_status = {
            "best_valid_error": np.inf,
            "best_epoch": 0,
            "epoch": 0,
            "nb_of_epocs_without_improvement": 0
        }

    print '\n### Training NADE ###'
    while(trainer_status["epoch"] < max_epochs and trainer_status["nb_of_epocs_without_improvement"] < look_ahead):
        trainer_status["epoch"] += 1

        print 'Epoch {0} (Batch Size {1})'.format(trainer_status["epoch"], batch_size)
        print '\tTraining   ...',
        start_time = t.time()
        nb_iterations = int(np.ceil(dataset['train']['length'] / batch_size))
        train_err = 0
        for index in range(nb_iterations):
            #current_iteration = ((trainer_status["epoch"] - 1) * nb_iterations) + index
            #train_err += model.learn(index, current_iteration)
            train_err += model.learn(index)
            # print train_err

        print utils.get_done_text(start_time), " avg NLL: {0:.6f}".format(train_err / nb_iterations)

        print '\tValidating ...',
        start_time = t.time()
        valid_err, valid_err_std = get_mean_error_and_std(model, model.valid_log_prob, batch_size)
        print utils.get_done_text(start_time), " NLL: {0:.6f}".format(valid_err)

        if valid_err < trainer_status["best_valid_error"]:
            trainer_status["best_valid_error"] = valid_err
            trainer_status["best_epoch"] = trainer_status["epoch"]
            trainer_status["nb_of_epocs_without_improvement"] = 0
            # Save best model
            if save_model_path is not None:
                save_model_params(model, save_model_path)
                utils.save_dict_to_json_file(os.path.join(save_model_path, "trainer_status"), trainer_status)
        else:
            trainer_status["nb_of_epocs_without_improvement"] += 1

    print "### Training", utils.get_done_text(start_training_time), "###"
    total_train_time = t.time() - start_training_time
    return trainer_status["best_epoch"], total_train_time
Пример #9
0
def build_model(dataset, trainingparams, hyperparams, hidden_size):
    print '\n### Initializing NADE ... ',
    start_time = t.time()
    model = NADE(dataset,
                 learning_rate=trainingparams['learning_rate'],
                 decrease_constant=trainingparams['decrease_constant'],
                 hidden_size=hidden_size,
                 random_seed=hyperparams['random_seed'],
                 batch_size=trainingparams['batch_size'],
                 hidden_activation=activation_functions[hyperparams['hidden_activation']],
                 momentum=trainingparams['momentum'],
                 dropout_rate=trainingparams['dropout_rate'],
                 weights_initialization=hyperparams['weights_initialization'],
                 tied=hyperparams['tied'])
    print utils.get_done_text(start_time), "###"
    # printParams(model)
    return model
Пример #10
0
def build_model(dataset, trainingparams, hyperparams, hidden_size):
    print '\n### Initializing NADE ... ',
    start_time = t.time()
    model = NADE(dataset,
                 learning_rate=trainingparams['learning_rate'],
                 decrease_constant=trainingparams['decrease_constant'],
                 hidden_size=hidden_size,
                 random_seed=hyperparams['random_seed'],
                 batch_size=trainingparams['batch_size'],
                 hidden_activation=activation_functions[hyperparams['hidden_activation']],
                 momentum=trainingparams['momentum'],
                 dropout_rate=trainingparams['dropout_rate'],
                 weights_initialization=hyperparams['weights_initialization'],
                 tied=hyperparams['tied'])
    print utils.get_done_text(start_time), "###"
    # printParams(model)
    return model
Пример #11
0
    def get(dataset_name):
        datasets = ['adult',
                    'binarized_mnist',
                    'connect4',
                    'dna',
                    'mushrooms',
                    'nips',
                    'ocr_letters-orig',
                    'rcv1',
                    'web',
                    'accidents',
                    'ad',
                    'baudio',
                    'bbc',
                    'bnetflix',
                    'book',
                    'c20ng',
                    'cr52',
                    'cwebkb',
                    'jester',
                    'kdd',
                    'msnbc',
                    'msweb',
                    'nltcs',
                    'plants',
                    'pumsb_star',
                    'tmovie',
                    'tretail',
                    'rectangles',
                    'convex',
                    'ocr_letters',
                    'caltech101',
                    'bmnist']

        # FIXME: disabling for a while
        # if dataset_name not in datasets:
        #     raise ValueError('Dataset unknown: ' + dataset_name)

        print('### Loading dataset [{0}] ...'.format(dataset_name), end=' ')
        start_time = t.time()

        raw_dataset = np.load(os.path.join("datasets", dataset_name) + ".npz")
        full_dataset = {'input_size': raw_dataset['inputsize']}

        trainset_theano = theano.shared(value=raw_dataset['train_data'], borrow=True)
        validset_theano = theano.shared(value=raw_dataset['valid_data'], borrow=True)
        testset_theano = theano.shared(value=raw_dataset['test_data'], borrow=True)

        full_dataset['train'] = {'data': trainset_theano, 'length': raw_dataset['train_length']}
        full_dataset['valid'] = {'data': validset_theano, 'length': raw_dataset['valid_length']}
        full_dataset['test'] = {'data': testset_theano, 'length': raw_dataset['test_length']}

        print("(Dim:{0} Train:{1} Valid:{2} Test:{3})".format(full_dataset['input_size'], full_dataset[
              'train']['length'], full_dataset['valid']['length'], full_dataset['test']['length']), end=' ')
        print(get_done_text(start_time), "###")
        return full_dataset
Пример #12
0
def build_model(dataset, trainingparams, hyperparams, hidden_sizes):
    print '\n### Initializing MADE ... ',
    start_time = t.time()
    model = MADE(dataset,
                 learning_rate=trainingparams['learning_rate'],
                 decrease_constant=trainingparams['decrease_constant'],
                 hidden_sizes=hidden_sizes,
                 random_seed=hyperparams['random_seed'],
                 batch_size=trainingparams['batch_size'],
                 hidden_activation=activation_functions[hyperparams['hidden_activation']],
                 use_cond_mask=hyperparams['use_cond_mask'],
                 direct_input_connect=hyperparams['direct_input_connect'],
                 direct_output_connect=hyperparams['direct_output_connect'],
                 update_rule=trainingparams['update_rule'],
                 dropout_rate=trainingparams['dropout_rate'],
                 weights_initialization=hyperparams['weights_initialization'],
                 mask_distribution=hyperparams['mask_distribution'])
    print utils.get_done_text(start_time), "###"
    return model
Пример #13
0
def build_model(dataset, trainingparams, hyperparams, hidden_sizes):
    print '\n### Initializing MADE ... ',
    start_time = t.time()
    model = MADE(dataset,
                 learning_rate=trainingparams['learning_rate'],
                 decrease_constant=trainingparams['decrease_constant'],
                 hidden_sizes=hidden_sizes,
                 random_seed=hyperparams['random_seed'],
                 batch_size=trainingparams['batch_size'],
                 hidden_activation=activation_functions[
                     hyperparams['hidden_activation']],
                 use_cond_mask=hyperparams['use_cond_mask'],
                 direct_input_connect=hyperparams['direct_input_connect'],
                 direct_output_connect=hyperparams['direct_output_connect'],
                 update_rule=trainingparams['update_rule'],
                 dropout_rate=trainingparams['dropout_rate'],
                 weights_initialization=hyperparams['weights_initialization'],
                 mask_distribution=hyperparams['mask_distribution'])
    print utils.get_done_text(start_time), "###"
    return model
Пример #14
0
    def get(dataset_name):
        datasets = [
            'adult', 'binarized_mnist', 'connect4', 'dna', 'mushrooms', 'nips',
            'ocr_letters', 'rcv1', 'web', 'simple_tree'
        ]

        if dataset_name not in datasets:
            raise ValueError('Dataset unknown: ' + dataset_name)

        print '### Loading dataset [{0}] ...'.format(dataset_name),
        start_time = t.time()

        raw_dataset = np.load(os.path.join("datasets", dataset_name) + ".npz")
        full_dataset = {'input_size': raw_dataset['inputsize']}

        trainset_theano = theano.shared(value=raw_dataset['train_data'],
                                        borrow=True)
        validset_theano = theano.shared(value=raw_dataset['valid_data'],
                                        borrow=True)
        testset_theano = theano.shared(value=raw_dataset['test_data'],
                                       borrow=True)

        full_dataset['train'] = {
            'data': trainset_theano,
            'length': raw_dataset['train_length']
        }
        full_dataset['valid'] = {
            'data': validset_theano,
            'length': raw_dataset['valid_length']
        }
        full_dataset['test'] = {
            'data': testset_theano,
            'length': raw_dataset['test_length']
        }

        print "(Dim:{0} Train:{1} Valid:{2} Test:{3})".format(
            full_dataset['input_size'], full_dataset['train']['length'],
            full_dataset['valid']['length'], full_dataset['test']['length']),
        print get_done_text(start_time), "###"
        return full_dataset
Пример #15
0
def build_model(dataset, trainingparams, hyperparams, hidden_sizes):
    print("\n### Initializing MADE ... ", end=" ")
    start_time = t.time()
    model = MADE(
        dataset,
        learning_rate=trainingparams["learning_rate"],
        decrease_constant=trainingparams["decrease_constant"],
        hidden_sizes=hidden_sizes,
        random_seed=hyperparams["random_seed"],
        batch_size=trainingparams["batch_size"],
        hidden_activation=activation_functions[hyperparams["hidden_activation"]],
        use_cond_mask=hyperparams["use_cond_mask"],
        direct_input_connect=hyperparams["direct_input_connect"],
        direct_output_connect=hyperparams["direct_output_connect"],
        update_rule=trainingparams["update_rule"],
        dropout_rate=trainingparams["dropout_rate"],
        weights_initialization=hyperparams["weights_initialization"],
        mask_distribution=hyperparams["mask_distribution"],
    )
    print(utils.get_done_text(start_time), "###")
    return model
Пример #16
0
    model, dataset_name, dataset = get_model(args.model_path)

    for run in range(args.nb_images):
        print("Image {0}".format(run))
        print("### Generating {} samples ...".format(
            args.nb_samples_per_row * args.nb_rows), end=' ')
        name = "_samples_run{}".format(run)

        start_time = t.time()
        if args.change_mask:
            name += "_change_mask"
            samples = model.sample(args.nb_samples_per_row, 0)
            for i in range(1, args.nb_rows):
                samples = np.vstack([model.sample(args.nb_samples_per_row, i), samples])
        else:
            samples = model.sample(args.nb_samples_per_row * args.nb_rows)
        print(utils.get_done_text(start_time), "###")

        if args.find_nearest_neighbour:
            print("### Finding neighbours ...", end=' ')
            start_time = t.time()
            samples_neighbours = get_nearest_neighbours(samples, dataset)
            print(utils.get_done_text(start_time), "###")

            save_samples(args.nb_samples_per_row, args.nb_rows, samples_neighbours,
                         dataset_name + name + "_neighbours", os.path.basename(args.model_path))

        save_samples(args.nb_samples_per_row, args.nb_rows, samples,
                     dataset_name + name, os.path.basename(args.model_path))
Пример #17
0
def train_model(model,
                dataset,
                look_ahead,
                shuffle_mask,
                nb_shuffle_per_valid,
                max_epochs,
                batch_size,
                shuffling_type,
                save_model_path=None,
                trainer_status=None):
    start_training_time = t.time()

    if trainer_status is None:
        trainer_status = {
            "nb_shuffles": 0,
            "best_valid_error": np.inf,
            "best_epoch": 0,
            "epoch": 0,
            "nb_of_epocs_without_improvement": 0
        }

    # Always do a first shuffle so that the natural order does not gives us an edge
    model.shuffle("Full")
    # Reseting the mask to where they were when saved
    for i in range(trainer_status["nb_shuffles"]):
        model.shuffle(shuffling_type)

    print '\n### Training MADE ###'
    while (trainer_status["epoch"] < max_epochs
           and trainer_status["nb_of_epocs_without_improvement"] < look_ahead):
        trainer_status["epoch"] += 1

        print 'Epoch {0} (Batch Size {1})'.format(trainer_status["epoch"],
                                                  batch_size)
        print '\tTraining   ...',
        start_time = t.time()
        nb_iterations = int(np.ceil(dataset['train']['length'] / batch_size))
        train_err = 0
        for index in range(nb_iterations):
            train_err += model.learn(index, True)

            if shuffle_mask:
                if trainer_status["nb_shuffles"] == shuffle_mask:
                    trainer_status["nb_shuffles"] = 0
                    model.reset(shuffling_type)
                else:
                    model.shuffle(shuffling_type)
                    trainer_status["nb_shuffles"] += 1

        print utils.get_done_text(start_time), " avg NLL: {0:.6f}".format(
            train_err / nb_iterations)

        print '\tValidating ...',
        start_time = t.time()
        if shuffle_mask > 0:
            model.reset(shuffling_type)
        valid_err, valid_err_std = get_mean_error_and_std(
            model, model.valid_log_prob, dataset['valid']['length'],
            shuffle_mask, shuffling_type, nb_shuffle_per_valid)
        if shuffle_mask > 0:
            model.reset(shuffling_type, trainer_status["nb_shuffles"])
        print utils.get_done_text(start_time), " NLL: {0:.6f}".format(
            valid_err)

        if valid_err < trainer_status["best_valid_error"]:
            trainer_status["best_valid_error"] = valid_err
            trainer_status["best_epoch"] = trainer_status["epoch"]
            trainer_status["nb_of_epocs_without_improvement"] = 0
            # Save best model
            if save_model_path is not None:
                save_model_params(model, save_model_path)
                utils.save_dict_to_json_file(
                    os.path.join(save_model_path, "trainer_status"),
                    trainer_status)
        else:
            trainer_status["nb_of_epocs_without_improvement"] += 1

    print "### Training", utils.get_done_text(start_training_time), "###"
    total_train_time = t.time() - start_training_time
    return trainer_status["best_epoch"], total_train_time
Пример #18
0
    for run in range(args.nb_images):
        print "Image {0}".format(run)
        print "### Generating {} samples ...".format(args.nb_samples_per_row *
                                                     args.nb_rows),
        name = "_samples_run{}".format(run)

        start_time = t.time()
        if args.change_mask:
            name += "_change_mask"
            samples = model.sample(args.nb_samples_per_row, 0)
            for i in range(1, args.nb_rows):
                samples = np.vstack(
                    [model.sample(args.nb_samples_per_row, i), samples])
        else:
            samples = model.sample(args.nb_samples_per_row * args.nb_rows)
        print utils.get_done_text(start_time), "###"

        if args.find_nearest_neighbour:
            print "### Finding neighbours ...",
            start_time = t.time()
            samples_neighbours = get_nearest_neighbours(samples, dataset)
            print utils.get_done_text(start_time), "###"

            save_samples(args.nb_samples_per_row, args.nb_rows,
                         samples_neighbours,
                         dataset_name + name + "_neighbours",
                         os.path.basename(args.model_path))

        save_samples(args.nb_samples_per_row, args.nb_rows, samples,
                     dataset_name + name, os.path.basename(args.model_path))
Пример #19
0
    parser.add_argument('change_mask', metavar='change_mask', help="Change mask for every row when generating samples: {%(choices)s}", type=eval, choices=[False, True])
    parser.add_argument('nb_images', help="# of images to generate.", type=int, default=1)
    args = parser.parse_args()

    model, dataset_name, dataset = get_model(args.model_path)

    for run in range(args.nb_images):
        print "Image {0}".format(run)
        print "### Generating {} samples ...".format(args.nb_samples_per_row * args.nb_rows),
        name = "_samples_run{}".format(run)

        start_time = t.time()
        if args.change_mask:
            name += "_change_mask"
            samples = model.sample(args.nb_samples_per_row, 0)
            for i in range(1, args.nb_rows):
                samples = np.vstack([model.sample(args.nb_samples_per_row, i), samples])
        else:
            samples = model.sample(args.nb_samples_per_row * args.nb_rows)
        print utils.get_done_text(start_time), "###"

        if args.find_nearest_neighbour:
            print "### Finding neighbours ...",
            start_time = t.time()
            samples_neighbours = get_nearest_neighbours(samples, dataset)
            print utils.get_done_text(start_time), "###"

            save_samples(args.nb_samples_per_row, args.nb_rows, samples_neighbours, dataset_name + name + "_neighbours", os.path.basename(args.model_path))

        save_samples(args.nb_samples_per_row, args.nb_rows, samples, dataset_name + name, os.path.basename(args.model_path))
Пример #20
0
def train_model(model, dataset, look_ahead, shuffle_mask, nb_shuffle_per_valid, max_epochs, batch_size, shuffling_type, save_model_path=None, trainer_status=None):
    start_training_time = t.time()

    if trainer_status is None:
        trainer_status = {
            "nb_shuffles": 0,
            "best_valid_error": np.inf,
            "best_epoch": 0,
            "epoch": 0,
            "nb_of_epocs_without_improvement": 0
        }

    # Always do a first shuffle so that the natural order does not gives us an edge
    model.shuffle("Full")
    # Reseting the mask to where they were when saved
    for i in range(trainer_status["nb_shuffles"]):
        model.shuffle(shuffling_type)

    print '\n### Training MADE ###'
    while(trainer_status["epoch"] < max_epochs and trainer_status["nb_of_epocs_without_improvement"] < look_ahead):
        trainer_status["epoch"] += 1

        print 'Epoch {0} (Batch Size {1})'.format(trainer_status["epoch"], batch_size)
        print '\tTraining   ...',
        start_time = t.time()
        nb_iterations = int(np.ceil(dataset['train']['length'] / batch_size))
        train_err = 0
        for index in range(nb_iterations):
            train_err += model.learn(index, True)

            if shuffle_mask:
                if trainer_status["nb_shuffles"] == shuffle_mask:
                    trainer_status["nb_shuffles"] = 0
                    model.reset(shuffling_type)
                else:
                    model.shuffle(shuffling_type)
                    trainer_status["nb_shuffles"] += 1

        print utils.get_done_text(start_time), " avg NLL: {0:.6f}".format(train_err / nb_iterations)

        print '\tValidating ...',
        start_time = t.time()
        if shuffle_mask > 0:
            model.reset(shuffling_type)
        valid_err, valid_err_std = get_mean_error_and_std(model, model.valid_log_prob, dataset['valid']['length'], shuffle_mask, shuffling_type, nb_shuffle_per_valid)
        if shuffle_mask > 0:
            model.reset(shuffling_type, trainer_status["nb_shuffles"])
        print utils.get_done_text(start_time), " NLL: {0:.6f}".format(valid_err)

        if valid_err < trainer_status["best_valid_error"]:
            trainer_status["best_valid_error"] = valid_err
            trainer_status["best_epoch"] = trainer_status["epoch"]
            trainer_status["nb_of_epocs_without_improvement"] = 0
            # Save best model
            if save_model_path is not None:
                save_model_params(model, save_model_path)
                utils.save_dict_to_json_file(os.path.join(save_model_path, "trainer_status"), trainer_status)
        else:
            trainer_status["nb_of_epocs_without_improvement"] += 1

    print "### Training", utils.get_done_text(start_training_time), "###"
    total_train_time = t.time() - start_training_time
    return trainer_status["best_epoch"], total_train_time