def setup(testobj):
skip_if_not_available(modules=['nose2'])
# Not importing unicode_literal because it gives problems
# If needed, see https://dirkjan.ochtman.nl/writing/2014/07/06/
# single-source-python-23-doctests.html for a solution
testobj.globs['absolute_import'] = absolute_import
testobj.globs['print_function'] = print_function
def test_mnist():
skip_if_not_available(datasets=['mnist'])
mnist_train = MNIST('train', start=20000)
assert len(mnist_train.features) == 40000
assert len(mnist_train.targets) == 40000
assert mnist_train.num_examples == 40000
mnist_test = MNIST('test', sources=('targets', ))
assert len(mnist_test.targets) == 10000
assert mnist_test.num_examples == 10000
first_feature, first_target = mnist_train.get_data(request=[0])
assert first_feature.shape == (1, 784)
assert first_feature.dtype.kind == 'f'
assert first_target.shape == (1, 1)
assert first_target.dtype is numpy.dtype('uint8')
first_target, = mnist_test.get_data(request=[0, 1])
assert first_target.shape == (2, 1)
binary_mnist = MNIST('test', binary=True, sources=('features', ))
first_feature, = binary_mnist.get_data(request=[0])
assert first_feature.dtype.kind == 'b'
assert_raises(ValueError, MNIST, 'valid')
mnist_train = cPickle.loads(cPickle.dumps(mnist_train))
assert len(mnist_train.features) == 40000
mnist_test_unflattened = MNIST('test', flatten=False)
assert mnist_test_unflattened.features.shape == (10000, 28, 28)
def setup(testobj):
skip_if_not_available(modules=['nose2'])
# Not importing unicode_literal because it gives problems
# If needed, see https://dirkjan.ochtman.nl/writing/2014/07/06/
# single-source-python-23-doctests.html for a solution
testobj.globs['absolute_import'] = absolute_import
testobj.globs['print_function'] = print_function
def test_mnist():
skip_if_not_available(datasets=['mnist'])
mnist_train = MNIST('train', start=20000)
assert len(mnist_train.features) == 40000
assert len(mnist_train.targets) == 40000
assert mnist_train.num_examples == 40000
mnist_test = MNIST('test', sources=('targets',))
assert len(mnist_test.targets) == 10000
assert mnist_test.num_examples == 10000
first_feature, first_target = mnist_train.get_data(request=[0])
assert first_feature.shape == (1, 784)
assert first_feature.dtype.kind == 'f'
assert first_target.shape == (1, 1)
assert first_target.dtype is numpy.dtype('uint8')
first_target, = mnist_test.get_data(request=[0, 1])
assert first_target.shape == (2, 1)
binary_mnist = MNIST('test', binary=True, sources=('features',))
first_feature, = binary_mnist.get_data(request=[0])
assert first_feature.dtype.kind == 'b'
assert_raises(ValueError, MNIST, 'valid')
mnist_train = cPickle.loads(cPickle.dumps(mnist_train))
assert len(mnist_train.features) == 40000
mnist_test_unflattened = MNIST('test', flatten=False)
assert mnist_test_unflattened.features.shape == (10000, 28, 28)
def test_adult_test():
skip_if_not_available(datasets=['adult.hdf5'])
dataset = Adult(('test',), load_in_memory=False)
handle = dataset.open()
data, labels = dataset.get_data(handle, slice(0, 10))
assert data.shape == (10, 104)
assert labels.shape == (10, 1)
known = numpy.array(
[25., 38., 28., 44., 34., 63., 24., 55., 65., 36.])
assert_allclose(data[:, 0], known)
assert dataset.num_examples == 15060
dataset.close(handle)
dataset = Adult(('train',), load_in_memory=False)
handle = dataset.open()
data, labels = dataset.get_data(handle, slice(0, 10))
assert data.shape == (10, 104)
assert labels.shape == (10, 1)
known = numpy.array(
[39., 50., 38., 53., 28., 37., 49., 52., 31., 42.])
assert_allclose(data[:, 0], known)
assert dataset.num_examples == 30162
dataset.close(handle)
def test_in_memory():
skip_if_not_available(datasets=['mnist.hdf5'])
# Load MNIST and get two batches
mnist = MNIST('train', load_in_memory=True)
data_stream = DataStream(mnist,
iteration_scheme=SequentialScheme(
examples=mnist.num_examples, batch_size=256))
epoch = data_stream.get_epoch_iterator()
for i, (features, targets) in enumerate(epoch):
if i == 1:
break
handle = mnist.open()
known_features, _ = mnist.get_data(handle, slice(256, 512))
mnist.close(handle)
assert numpy.all(features == known_features)
# Pickle the epoch and make sure that the data wasn't dumped
with tempfile.NamedTemporaryFile(delete=False) as f:
filename = f.name
cPickle.dump(epoch, f)
assert os.path.getsize(filename) < 1024 * 1024 # Less than 1MB
# Reload the epoch and make sure that the state was maintained
del epoch
with open(filename, 'rb') as f:
epoch = cPickle.load(f)
features, targets = next(epoch)
handle = mnist.open()
known_features, _ = mnist.get_data(handle, slice(512, 768))
mnist.close(handle)
assert numpy.all(features == known_features)
def test_in_memory():
skip_if_not_available(datasets=['mnist'])
# Load MNIST and get two batches
mnist = MNIST('train')
data_stream = DataStream(mnist,
iteration_scheme=SequentialScheme(
num_examples=mnist.num_examples,
batch_size=256))
epoch = data_stream.get_epoch_iterator()
for i, (features, targets) in enumerate(epoch):
if i == 1:
break
assert numpy.all(features == mnist.features[256:512])
# Pickle the epoch and make sure that the data wasn't dumped
with tempfile.NamedTemporaryFile(delete=False) as f:
filename = f.name
pickle_dump(epoch, f)
assert os.path.getsize(filename) < 1024 * 1024 # Less than 1MB
# Reload the epoch and make sure that the state was maintained
del epoch
with open(filename, 'rb') as f:
epoch = cPickle.load(f)
features, targets = next(epoch)
assert numpy.all(features == mnist.features[512:768])
def test_in_memory():
skip_if_not_available(datasets=['mnist.hdf5'])
# Load MNIST and get two batches
mnist = MNIST(('train',), load_in_memory=True)
data_stream = DataStream(mnist, iteration_scheme=SequentialScheme(
examples=mnist.num_examples, batch_size=256))
epoch = data_stream.get_epoch_iterator()
for i, (features, targets) in enumerate(epoch):
if i == 1:
break
handle = mnist.open()
known_features, _ = mnist.get_data(handle, slice(256, 512))
mnist.close(handle)
assert numpy.all(features == known_features)
# Pickle the epoch and make sure that the data wasn't dumped
with tempfile.NamedTemporaryFile(delete=False) as f:
filename = f.name
cPickle.dump(epoch, f)
assert os.path.getsize(filename) < 1024 * 1024 # Less than 1MB
# Reload the epoch and make sure that the state was maintained
del epoch
with open(filename, 'rb') as f:
epoch = cPickle.load(f)
features, targets = next(epoch)
handle = mnist.open()
known_features, _ = mnist.get_data(handle, slice(512, 768))
mnist.close(handle)
assert numpy.all(features == known_features)
def test_read_devkit():
skip_if_not_available(datasets=[DEVKIT_ARCHIVE])
synsets, raw_valid_gt = read_devkit(find_in_data_path(DEVKIT_ARCHIVE))
# synset sanity tests appear in test_read_metadata_mat_file
assert raw_valid_gt.min() == 1
assert raw_valid_gt.max() == 1000
assert raw_valid_gt.dtype.kind == 'i'
assert raw_valid_gt.shape == (50000,)
def test_adult_axes():
skip_if_not_available(datasets=['adult.hdf5'])
dataset = Adult(('test', ), load_in_memory=False)
assert_equal(dataset.axis_labels['features'], ('batch', 'feature'))
dataset = Adult(('train', ), load_in_memory=False)
assert_equal(dataset.axis_labels['features'], ('batch', 'feature'))
def test_match_column_specs():
skip_if_not_available(modules=['pandas'])
experiments = some_experiments()
specs = ['0:col0', '*1']
df = plot.match_column_specs(experiments, specs)
assert isinstance(df, DataFrame)
assert list(df.columns) == ['0:col0', '0:col1', '1:col1']
def test_match_column_specs():
skip_if_not_available(modules=['pandas'])
experiments = some_experiments()
specs = ['0:col0', '*1']
df = plot.match_column_specs(experiments, specs)
assert isinstance(df, DataFrame)
assert list(df.columns) == ['0:col0', '0:col1', '1:col1']
def test_binarized_mnist_test():
skip_if_not_available(datasets=['binarized_mnist'])
mnist_test = BinarizedMNIST('test')
handle = mnist_test.open()
data = mnist_test.get_data(handle, slice(0, 10000))[0]
assert data.shape == (10000, 1, 28, 28)
assert mnist_test.num_examples == 10000
mnist_test.close(handle)
def test_binarized_mnist_no_split():
skip_if_not_available(datasets=['binarized_mnist'])
dataset = BinarizedMNIST()
handle = dataset.open()
data = dataset.get_data(handle, slice(0, 70000))[0]
assert data.shape == (70000, 1, 28, 28)
assert dataset.num_examples == 70000
dataset.close(handle)
def test_match_column_specs():
skip_if_not_available(modules=["pandas"])
experiments = some_experiments()
specs = ["0:col0", "*1"]
df = plot.match_column_specs(experiments, specs)
assert isinstance(df, DataFrame)
assert list(df.columns) == ["0:col0", "0:col1", "1:col1"]
assert list(df.index) == [0, 1, 2, 3]
def test_mnist():
skip_if_not_available(modules=['bokeh'])
with tempfile.NamedTemporaryFile() as f:
mnist_test(f.name, 1)
with open(f.name, "rb") as source:
main_loop = cPickle.load(source)
main_loop.find_extension("FinishAfter").set_conditions(
after_n_epochs=2)
main_loop.run()
assert main_loop.log.status.epochs_done == 2
def test_prepare_metadata():
skip_if_not_available(datasets=[DEVKIT_ARCHIVE, TEST_IMAGES_TAR])
devkit_path = find_in_data_path(DEVKIT_ARCHIVE)
n_train, v_gt, n_test, wnid_map = prepare_metadata(devkit_path)
assert n_train == 1281167
assert len(v_gt) == 50000
assert n_test == 100000
assert sorted(wnid_map.values()) == list(range(1000))
assert all(isinstance(k, six.string_types) and len(k) == 9
for k in wnid_map)
def test_adult_axes():
skip_if_not_available(datasets=['adult.hdf5'])
dataset = Adult(('test',), load_in_memory=False)
assert_equal(dataset.axis_labels['features'],
('batch', 'feature'))
dataset = Adult(('train',), load_in_memory=False)
assert_equal(dataset.axis_labels['features'],
('batch', 'feature'))
def test_mnist():
skip_if_not_available(modules=['bokeh'])
with tempfile.NamedTemporaryFile() as f:
mnist_test(f.name, 1, True)
with open(f.name, "rb") as source:
main_loop = cPickle.load(source)
main_loop.find_extension("FinishAfter").set_conditions(
after_n_epochs=2)
main_loop.run()
assert main_loop.log.status['epochs_done'] == 2
def test_reverse_words():
skip_if_not_available(modules=['bokeh'])
old_limit = blocks.config.recursion_limit
blocks.config.recursion_limit = 100000
with tempfile.NamedTemporaryFile() as f_save,\
tempfile.NamedTemporaryFile() as f_data:
with open(f_data.name, 'wt') as data:
for i in range(10):
print("A line.", file=data)
reverse_words_test("train", f_save.name, 1, [f_data.name])
blocks.config.recursion_limit = old_limit
def test_reverse_words():
skip_if_not_available(modules=['bokeh'])
old_limit = config.recursion_limit
config.recursion_limit = 100000
with tempfile.NamedTemporaryFile() as f_save,\
tempfile.NamedTemporaryFile() as f_data:
with open(f_data.name, 'wt') as data:
for i in range(10):
print("A line.", file=data)
reverse_words_test("train", f_save.name, 1, [f_data.name])
config.recursion_limit = old_limit
def test_binarized_mnist_train():
skip_if_not_available(datasets=['binarized_mnist.hdf5'])
dataset = BinarizedMNIST('train', load_in_memory=False)
handle = dataset.open()
data, = dataset.get_data(handle, slice(0, 10))
assert data.dtype == 'uint8'
assert data.shape == (10, 1, 28, 28)
assert hashlib.md5(data).hexdigest() == '0922fefc9a9d097e3b086b89107fafce'
assert dataset.num_examples == 50000
dataset.close(handle)
def test_binarized_mnist_valid():
skip_if_not_available(datasets=['binarized_mnist.hdf5'])
dataset = BinarizedMNIST('valid', load_in_memory=False)
handle = dataset.open()
data, = dataset.get_data(handle, slice(0, 10))
assert data.dtype == 'uint8'
assert data.shape == (10, 1, 28, 28)
assert hashlib.md5(data).hexdigest() == '65e8099613162b3110a7618037011617'
assert dataset.num_examples == 10000
dataset.close(handle)
def test_binarized_mnist_test():
skip_if_not_available(datasets=['binarized_mnist.hdf5'])
dataset = BinarizedMNIST('test', load_in_memory=False)
handle = dataset.open()
data, = dataset.get_data(handle, slice(0, 10))
assert data.dtype == 'uint8'
assert data.shape == (10, 1, 28, 28)
assert hashlib.md5(data).hexdigest() == '0fa539ed8cb008880a61be77f744f06a'
assert dataset.num_examples == 10000
dataset.close(handle)
def test_prepare_metadata():
skip_if_not_available(datasets=[DEVKIT_ARCHIVE, TEST_GROUNDTRUTH])
devkit_path = find_in_data_path(DEVKIT_ARCHIVE)
test_gt_path = find_in_data_path(TEST_GROUNDTRUTH)
n_train, v_gt, t_gt, wnid_map = prepare_metadata(devkit_path,
test_gt_path)
assert n_train == 1261406
assert len(v_gt) == 50000
assert len(t_gt) == 150000
assert sorted(wnid_map.values()) == list(range(1000))
assert all(isinstance(k, six.string_types) and len(k) == 9
for k in wnid_map)
def test_iris_all():
skip_if_not_available(datasets=['iris.hdf5'])
dataset = Iris(('all', ), load_in_memory=False)
handle = dataset.open()
data, labels = dataset.get_data(handle, slice(0, 10))
assert data.dtype == 'float32'
assert data.shape == (10, 4)
assert labels.shape == (10, 1)
known = numpy.array([5.1, 3.5, 1.4, 0.2])
assert_allclose(data[0], known)
assert labels[0][0] == 0
assert dataset.num_examples == 150
dataset.close(handle)
def test_iris_all():
skip_if_not_available(datasets=['iris.hdf5'])
dataset = Iris(('all',), load_in_memory=False)
handle = dataset.open()
data, labels = dataset.get_data(handle, slice(0, 10))
assert data.dtype == config.floatX
assert data.shape == (10, 4)
assert labels.shape == (10, 1)
known = numpy.array([5.1, 3.5, 1.4, 0.2])
assert_allclose(data[0], known)
assert labels[0][0] == 0
assert dataset.num_examples == 150
dataset.close(handle)
def test_read_metadata_mat_file():
skip_if_not_available(datasets=[DEVKIT_ARCHIVE])
with tarfile.open(find_in_data_path(DEVKIT_ARCHIVE)) as tar:
meta_mat = tar.extractfile(DEVKIT_META_PATH)
synsets = read_metadata_mat_file(meta_mat)
assert (synsets['ILSVRC2012_ID'] ==
numpy.arange(1, len(synsets) + 1)).all()
assert synsets['num_train_images'][1000:].sum() == 0
assert (synsets['num_train_images'][:1000] > 0).all()
assert synsets.ndim == 1
assert synsets['wordnet_height'].min() == 0
assert synsets['wordnet_height'].max() == 19
assert synsets['WNID'].dtype == numpy.dtype('S9')
assert (synsets['num_children'][:1000] == 0).all()
assert (synsets['children'][:1000] == -1).all()
def test_interpolate():
skip_if_not_available(modules=['pandas'])
""" Ensure tha DataFrame.interpolate(method='nearest') has the
desired properties.
It is used by blocks-plot and should:
* interpolate missing/NaN datapoints between valid ones
* not replace any NaN before/after the first/last finite datapoint
"""
y = [nan, nan, 2., 3., nan, 5, nan, nan]
df = DataFrame(y)
df_ = df.interpolate(method='nearest')[0]
assert all(isfinite(df_[2:6]))
assert all(~isfinite(df_[0:2]))
assert all(~isfinite(df_[6:8]))
def test_caltech101_silhouettes16():
skip_if_not_available(datasets=['caltech101_silhouettes16.hdf5'])
for which_set, size, num_examples in (
('train', 16, 4082), ('valid', 16, 2257), ('test', 16, 2302)):
ds = CalTech101Silhouettes(which_sets=[which_set], size=size,
load_in_memory=False)
assert ds.num_examples == num_examples
handle = ds.open()
features, targets = ds.get_data(handle, slice(0, 10))
assert features.shape == (10, 1, size, size)
assert targets.shape == (10, 1)
assert features.dtype == numpy.uint8
assert targets.dtype == numpy.uint8
def test_caltech101_silhouettes16():
skip_if_not_available(datasets=['caltech101_silhouettes16.hdf5'])
for which_set, size, num_examples in (('train', 16, 4082),
('valid', 16, 2257), ('test', 16,
2302)):
ds = CalTech101Silhouettes(which_sets=[which_set],
size=size,
load_in_memory=False)
assert ds.num_examples == num_examples
handle = ds.open()
features, targets = ds.get_data(handle, slice(0, 10))
assert features.shape == (10, 1, size, size)
assert targets.shape == (10, 1)
assert features.dtype == numpy.uint8
assert targets.dtype == numpy.uint8
def test_mnist_test():
skip_if_not_available(datasets=["mnist.hdf5"])
dataset = MNIST(("test",), load_in_memory=False)
handle = dataset.open()
data, labels = dataset.get_data(handle, slice(0, 10))
assert data.dtype == "uint8"
assert data.shape == (10, 1, 28, 28)
assert labels.shape == (10, 1)
known = numpy.array([0, 0, 0, 0, 0, 0, 84, 185, 159, 151, 60, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
assert_allclose(data[0][0][7], known)
assert labels[0][0] == 7
assert dataset.num_examples == 10000
dataset.close(handle)
stream = DataStream.default_stream(dataset, iteration_scheme=SequentialScheme(10, 10))
data = next(stream.get_epoch_iterator())[0]
assert data.min() >= 0.0 and data.max() <= 1.0
assert data.dtype == config.floatX
def test_mnist_train():
skip_if_not_available(datasets=['mnist.hdf5'])
dataset = MNIST('train', load_in_memory=False)
handle = dataset.open()
data, labels = dataset.get_data(handle, slice(0, 10))
assert data.dtype == 'uint8'
assert data.shape == (10, 1, 28, 28)
assert labels.shape == (10, 1)
known = numpy.array([0, 0, 0, 0, 0, 0, 0, 0, 30, 36, 94, 154, 170, 253,
253, 253, 253, 253, 225, 172, 253, 242, 195, 64, 0,
0, 0, 0])
assert_allclose(data[0][0][6], known)
assert labels[0][0] == 5
assert dataset.num_examples == 60000
dataset.close(handle)
stream = DataStream.default_stream(
dataset, iteration_scheme=SequentialScheme(10, 10))
data = next(stream.get_epoch_iterator())[0]
assert data.min() >= 0.0 and data.max() <= 1.0
assert data.dtype == config.floatX
def test_mnist():
skip_if_not_available(datasets=['binarized_mnist'])
mnist_train = BinarizedMNIST('train')
assert len(mnist_train.features) == 50000
assert mnist_train.num_examples == 50000
mnist_valid = BinarizedMNIST('valid')
assert len(mnist_valid.features) == 10000
assert mnist_valid.num_examples == 10000
mnist_test = BinarizedMNIST('test')
assert len(mnist_test.features) == 10000
assert mnist_test.num_examples == 10000
first_feature, = mnist_train.get_data(request=[0])
assert first_feature.shape == (1, 784)
assert first_feature.dtype.kind == 'f'
assert_raises(ValueError, BinarizedMNIST, 'dummy')
mnist_test = cPickle.loads(cPickle.dumps(mnist_test))
assert len(mnist_test.features) == 10000
mnist_test_unflattened = BinarizedMNIST('test', flatten=False)
assert mnist_test_unflattened.features.shape == (10000, 28, 28)
def test_in_memory():
skip_if_not_available(datasets=['mnist'])
# Load MNIST and get two batches
mnist = MNIST('train')
data_stream = DataStream(mnist, iteration_scheme=SequentialScheme(
num_examples=mnist.num_examples, batch_size=256))
epoch = data_stream.get_epoch_iterator()
for i, (features, targets) in enumerate(epoch):
if i == 1:
break
assert numpy.all(features == mnist.features[256:512])
# Pickle the epoch and make sure that the data wasn't dumped
with tempfile.NamedTemporaryFile(delete=False) as f:
filename = f.name
cPickle.dump(epoch, f)
assert os.path.getsize(filename) < 1024 * 1024 # Less than 1MB
# Reload the epoch and make sure that the state was maintained
del epoch
with open(filename, 'rb') as f:
epoch = cPickle.load(f)
features, targets = next(epoch)
assert numpy.all(features == mnist.features[512:768])
def test_adult_test():
skip_if_not_available(datasets=['adult.hdf5'])
dataset = Adult(('test', ), load_in_memory=False)
handle = dataset.open()
data, labels = dataset.get_data(handle, slice(0, 10))
assert data.shape == (10, 104)
assert labels.shape == (10, 1)
known = numpy.array([25., 38., 28., 44., 34., 63., 24., 55., 65., 36.])
assert_allclose(data[:, 0], known)
assert dataset.num_examples == 15060
dataset.close(handle)
dataset = Adult(('train', ), load_in_memory=False)
handle = dataset.open()
data, labels = dataset.get_data(handle, slice(0, 10))
assert data.shape == (10, 104)
assert labels.shape == (10, 1)
known = numpy.array([39., 50., 38., 53., 28., 37., 49., 52., 31., 42.])
assert_allclose(data[:, 0], known)
assert dataset.num_examples == 30162
dataset.close(handle)
def test_read_metadata_mat_file():
skip_if_not_available(datasets=[DEVKIT_ARCHIVE])
with tarfile.open(find_in_data_path(DEVKIT_ARCHIVE)) as tar:
meta_mat = tar.extractfile(DEVKIT_META_PATH)
synsets, cost_mat = read_metadata_mat_file(meta_mat)
assert (synsets['ILSVRC2010_ID'] ==
numpy.arange(1, len(synsets) + 1)).all()
assert synsets['num_train_images'][1000:].sum() == 0
assert (synsets['num_train_images'][:1000] > 0).all()
assert synsets.ndim == 1
assert synsets['wordnet_height'].min() == 0
assert synsets['wordnet_height'].max() == 19
assert synsets['WNID'].dtype == numpy.dtype('S9')
assert (synsets['num_children'][:1000] == 0).all()
assert (synsets['children'][:1000] == -1).all()
# Assert the basics about the cost matrix.
assert cost_mat.shape == (1000, 1000)
assert cost_mat.dtype == 'uint8'
assert cost_mat.min() == 0
assert cost_mat.max() == 18
assert (cost_mat == cost_mat.T).all()
# Assert that the diagonal is 0.
assert (cost_mat.flat[::1001] == 0).all()
def test_mnist_test():
skip_if_not_available(datasets=['mnist.hdf5'])
dataset = MNIST('test', load_in_memory=False)
handle = dataset.open()
data, labels = dataset.get_data(handle, slice(0, 10))
assert data.dtype == 'uint8'
assert data.shape == (10, 1, 28, 28)
assert labels.shape == (10, 1)
known = numpy.array([
0, 0, 0, 0, 0, 0, 84, 185, 159, 151, 60, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0
])
assert_allclose(data[0][0][7], known)
assert labels[0][0] == 7
assert dataset.num_examples == 10000
dataset.close(handle)
stream = DataStream.default_stream(dataset,
iteration_scheme=SequentialScheme(
10, 10))
data = next(stream.get_epoch_iterator())[0]
assert data.min() >= 0.0 and data.max() <= 1.0
assert data.dtype == config.floatX
def test_mnist():
skip_if_not_available(datasets=['mnist'])
mnist_train = MNIST('train', start=20000)
assert len(mnist_train.features) == 40000
assert len(mnist_train.targets) == 40000
assert mnist_train.num_examples == 40000
mnist_test = MNIST('test', sources=('targets', ))
assert len(mnist_test.features) == 10000
assert len(mnist_test.targets) == 10000
assert mnist_test.num_examples == 10000
first_feature, first_target = mnist_train.get_data(request=[0])
assert first_feature.shape == (1, 784)
assert first_feature.dtype is numpy.dtype(theano.config.floatX)
assert first_target.shape == (1, 1)
assert first_target.dtype is numpy.dtype('uint8')
first_target, = mnist_test.get_data(request=[0, 1])
assert first_target.shape == (2, 1)
binary_mnist = MNIST('test', binary=True, sources=('features', ))
first_feature, = binary_mnist.get_data(request=[0])
assert first_feature.dtype.kind == 'b'
assert_raises(ValueError, MNIST, 'valid')
def test_mnist_invalid_split():
skip_if_not_available(datasets=["mnist.hdf5"])
assert_raises(ValueError, MNIST, ("dummy",))
def test_mnist_axes():
skip_if_not_available(datasets=["mnist.hdf5"])
dataset = MNIST(("train",), load_in_memory=False)
assert_equal(dataset.axis_labels["features"], ("batch", "channel", "height", "width"))
def test_binarized_mnist_axes():
skip_if_not_available(datasets=['binarized_mnist.hdf5'])
dataset = BinarizedMNIST('train', load_in_memory=False)
assert_equal(dataset.axis_labels['features'],
('batch', 'channel', 'height', 'width'))
def test_iris_axes():
skip_if_not_available(datasets=['iris.hdf5'])
dataset = Iris(('all', ), load_in_memory=False)
assert_equal(dataset.axis_labels['features'], ('batch', 'feature'))
def test_iris_invalid_split():
skip_if_not_available(datasets=['iris.hdf5'])
assert_raises(ValueError, Iris, ('dummy', ))
def test_mnist_data_path():
skip_if_not_available(datasets=['mnist.hdf5'])
assert MNIST('train').data_path == os.path.join(config.data_path,
'mnist.hdf5')
def test_mnist_invalid_split():
skip_if_not_available(datasets=['mnist.hdf5'])
assert_raises(ValueError, MNIST, 'dummy')
def test_mnist_data_path():
skip_if_not_available(datasets=['mnist.hdf5'])
assert MNIST('train').data_path == os.path.join(config.data_path,
'mnist.hdf5')
def test_print_column_summary():
skip_if_not_available(modules=['pandas'])
experiments = some_experiments()
plot.print_column_summary(experiments)
def test_adult_invalid_split():
skip_if_not_available(datasets=['adult.hdf5'])
assert_raises(ValueError, Adult, ('dummy', ))
