def setup_and_parse_conf():
    parser = ArgumentParser()
    parser.add_argument('config', help='Path to configuration file')
    parser.add_argument('--output_dir', help='where to store output')
    arguments = parser.parse_args()

    with open(arguments.config) as f:
        config = json.loads(f.read())

    _output_dir = conf_dir =\
        path.dirname(path.join(os.getcwd(), arguments.config))
    if arguments.output_dir:
        _output_dir = path.join(os.getcwd(), arguments.output)

    training_file = path.join(_output_dir, 'training-dataset.pickle')
    test_file = path.join(_output_dir, 'test-dataset.pickle')

    if path.exists(training_file) and path.exists(test_file):
        _training_data = pickle.load(open(training_file, 'r'))
        _test_data = pickle.load(open(test_file, 'r'))

        print "Using pickled training and test data from files (%s, %s)" % (
            training_file, test_file)
    else:
        _training_data = create_datasets(**config['datasets']['training'])[0]
        _test_data = create_datasets(**config['datasets']['test'])[0]

        pickle.dump(_training_data, open(training_file, 'w'))
        pickle.dump(_test_data, open(test_file, 'w'))

        print "Created fresh training and test data, stored in (%s, %s)" % (
            training_file, test_file)

    class AnalyticsConfiguration():
        output_dir = _output_dir

        # System
        n_cores = config['system']['n_cores']

        # Datasets
        training_data = _training_data
        test_data = _test_data

        # Reservoir
        connectivity = config['reservoir']['connectivity']

        # Distribution
        n_nodes_range = range(*config['distribution']['n_nodes_range'])
        n_samples = config['distribution']['n_samples']

        def input_connectivity_fn(self, *args):
            return eval(config['distribution']['input_connectivity_fn'])(*args)

        def output_connectivity_fn(self, *args):
            return eval(
                config['distribution']['output_connectivity_fn'])(*args)

    return AnalyticsConfiguration()
Example #2
0
def setup_and_parse_conf():
    parser = ArgumentParser()
    parser.add_argument('config', help='Path to configuration file')
    parser.add_argument('--output_dir', help='where to store output')
    arguments = parser.parse_args()

    with open(arguments.config) as f:
        config = json.loads(f.read())

    _output_dir = conf_dir =\
        path.dirname(path.join(os.getcwd(), arguments.config))
    if arguments.output_dir:
        _output_dir = path.join(os.getcwd(), arguments.output)

    training_file = path.join(_output_dir, 'training-dataset.pickle')
    test_file = path.join(_output_dir, 'test-dataset.pickle')

    if path.exists(training_file) and path.exists(test_file):
        _training_data = pickle.load(open(training_file, 'r'))
        _test_data = pickle.load(open(test_file, 'r'))

        print "Using pickled training and test data from files (%s, %s)" % (training_file, test_file)
    else:
        _training_data = create_datasets(**config['datasets']['training'])[0]
        _test_data = create_datasets(**config['datasets']['test'])[0]

        pickle.dump(_training_data, open(training_file, 'w'))
        pickle.dump(_test_data, open(test_file, 'w'))

        print "Created fresh training and test data, stored in (%s, %s)" % (training_file, test_file)

    class AnalyticsConfiguration():
	output_dir = _output_dir

        # System
        n_cores = config['system']['n_cores']

        # Datasets
        training_data = _training_data
        test_data = _test_data

        # Reservoir
        connectivity = config['reservoir']['connectivity']

        # Distribution
        n_nodes_range = range(*config['distribution']['n_nodes_range'])
        n_samples = config['distribution']['n_samples']

        def input_connectivity_fn(self, *args):
            return eval(config['distribution']['input_connectivity_fn'])(*args)

        def output_connectivity_fn(self, *args):
            return eval(config['distribution']['output_connectivity_fn'])(*args)


    return AnalyticsConfiguration()
Example #3
0
def estimate_reservoir_distribution(n_samples, n_nodes, connectivity,
                                    input_connectivity_range, window_size):
    results = []
    datasets = create_datasets(20,
                               task_size=200,
                               window_size=window_size,
                               dataset_type='temporal_parity')
    training_dataset, test_dataset = datasets[:-1], datasets[-1]

    for input_connectivity in input_connectivity_range:
        logging.info('Sampling N={} with L={}.'.format(n_samples,
                                                       input_connectivity))
        for sample in range(n_samples):
            try:
                reservoir = RBNNode(connectivity=connectivity,
                                    output_dim=n_nodes,
                                    input_connectivity=input_connectivity)
                readout = Oger.nodes.RidgeRegressionNode(
                    input_dim=reservoir.output_dim, output_dim=1)

                flow = mdp.Flow([reservoir, readout], verbose=1)
                flow.train([None, training_dataset])

                accuracy = calculate_accuracy(flow, test_dataset)
                #cc = measure_computational_capability(reservoir, 100, window_size)
                #result = [input_connectivity, accuracy, cc]
                results.append([accuracy, reservoir])
                #results.append(result)
                logging.info(accuracy)
            except Exception as e:
                logging.error(e)
                logging.error('Exception occured, Continuing anyways')

    logging.info(results)
    return results
Example #4
0
def create_dataset():
    dataset_type = default_input('Dataset [temporal_parity, temporal_density]',
                                 'temporal_parity')
    n_datasets = default_input('Datasets', 10)
    task_size = default_input('Dataset length', 200)
    window_size = default_input('Window size', 3)

    datasets = temporal.create_datasets(n_datasets,
                                        task_size=task_size,
                                        window_size=window_size,
                                        dataset_type=dataset_type)

    dataset_description = '[{}-{}-{}-{}]'.format(dataset_type, n_datasets,
                                                 task_size, window_size)

    return datasets, dataset_description
def create_dataset():
    dataset_type = default_input(
        'Dataset [temporal_parity, temporal_density]', 'temporal_parity')
    n_datasets = default_input('Datasets', 10)
    task_size = default_input('Dataset length', 200)
    window_size = default_input('Window size', 3)

    datasets = temporal.create_datasets(
        n_datasets,
        task_size=task_size,
        window_size=window_size,
        dataset_type=dataset_type)

    dataset_description = '[{}-{}-{}-{}]'.format(
        dataset_type, n_datasets, task_size, window_size)

    return datasets, dataset_description
def estimate_reservoir_distribution(n_samples, n_nodes, connectivity,
                                    input_connectivity_range, window_size):
    results = []
    datasets = create_datasets(
        20,
        task_size=200,
        window_size=window_size,
        dataset_type='temporal_parity')
    training_dataset, test_dataset = datasets[:-1], datasets[-1]

    for input_connectivity in input_connectivity_range:
        logging.info('Sampling N={} with L={}.'
                     .format(n_samples, input_connectivity))
        for sample in range(n_samples):
            try:
                reservoir = RBNNode(connectivity=connectivity,
                                    output_dim=n_nodes,
                                    input_connectivity=input_connectivity)
                readout = Oger.nodes.RidgeRegressionNode(
                    input_dim=reservoir.output_dim,
                    output_dim=1)

                flow = mdp.Flow([reservoir, readout], verbose=1)
                flow.train([None, training_dataset])

                accuracy = calculate_accuracy(flow, test_dataset)
                #cc = measure_computational_capability(reservoir, 100, window_size)
                #result = [input_connectivity, accuracy, cc]
                results.append([accuracy, reservoir])
                #results.append(result)
                logging.info(accuracy)
            except Exception as e:
                logging.error(e)
                logging.error('Exception occured, Continuing anyways')

    logging.info(results)
    return results
from tasks.temporal import create_datasets
from rbn.sklearn_rbn_node import RBNNode
from sklearn.linear_model import Ridge

datasets = create_datasets(10,
                           task_size=200,
                           window_size=3,
                           dataset_type='temporal_parity')

training_datasets, test_dataset = datasets[:-1], datasets[-1]
rbn_reservoir = RBNNode(connectivity=3,
                        input_connectivity=50,
                        n_nodes=100,
                        output_connectivity=0)
readout_layer = Ridge()

for td in training_datasets[:1]:
    #rbn_reservoir.reset_state()

    reservoir_input, expected_output = td

    states = rbn_reservoir.execute(reservoir_input)
    readout_layer.fit(states, expected_output)
    predictions = readout_layer.predict(states)

    for prediction in predictions:
        prediction[0] = 1 if prediction[0] > 0.5 else 0

    errors = sum(predictions != expected_output)
    accuracy = 1 - float(errors) / len(predictions)
from tasks.temporal import create_datasets
from rbn.sklearn_rbn_node import RBNNode
from sklearn.linear_model import Ridge

datasets = create_datasets(
    10,
    task_size=200,
    window_size=3,
    dataset_type='temporal_parity')

training_datasets, test_dataset = datasets[:-1], datasets[-1]
rbn_reservoir = RBNNode(connectivity=3,
                        input_connectivity=50,
                        n_nodes=100,
                        output_connectivity=0)
readout_layer = Ridge()

for td in training_datasets[:1]:
    rbn_reservoir.reset_state()

    reservoir_input, expected_output = td

    states = rbn_reservoir.execute(reservoir_input)
    readout_layer.fit(states, expected_output)
    predictions = readout_layer.predict(states)

    for prediction in predictions:
        prediction[0] = 1 if prediction[0] > 0.5 else 0

    errors = sum(predictions != expected_output)
    accuracy = 1 - float(errors) / len(predictions)