brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/data/freemanziemba2013/data_packaging/aperture_correct.py

@@ -0,0 +1,160 @@
+"""
+Method to correct images in the movshon stimulus set by adding a cosine aperture
+"""
+
+import argparse
+import logging
+import os
+import numpy as np
+import imageio
+from tqdm import tqdm
+import copy
+from pathlib import Path
+import pandas as pd
+import xarray as xr
+
+from brainio_collection import get_stimulus_set, get_assembly
+from brainio_base.stimuli import StimulusSet
+from brainio_collection.knownfile import KnownFile as kf
+from brainio_contrib.packaging import package_stimulus_set, package_data_assembly
+from brainio_collection import fetch
+
+logging.basicConfig(level=logging.DEBUG, filename=f"{__file__}.log", format='%(asctime)s - %(levelname)s - %(message)s')
+_logger = logging.getLogger(__name__)
+
+
+class ApplyCosineAperture:
+    def __init__(self, target_dir):
+        self._target_dir = target_dir
+
+        self.gray_c = 128
+        self.input_degrees = 4
+        self.aperture_degrees = 4
+        self.pos = np.array([0, 0])
+        self.output_degrees = 4
+        self.size_px = np.array([320, 320])
+
+        # Image size
+        px_deg = self.size_px[0] / self.input_degrees
+
+        self.size_px_out = (self.size_px * (self.output_degrees / self.input_degrees)).astype(int)
+        cnt_px = (self.pos * px_deg).astype(int)
+
+        size_px_disp = ((self.size_px_out - self.size_px) / 2).astype(int)
+
+        self.fill_ind = [[(size_px_disp[0] + cnt_px[0]), (size_px_disp[0] + cnt_px[0] + self.size_px[0])],
+                        [(size_px_disp[1] + cnt_px[1]), (size_px_disp[1] + cnt_px[1] + self.size_px[1])]]
+
+        # Image aperture
+        a = self.aperture_degrees * px_deg / 2
+        # Meshgrid with pixel coordinates
+        x = (np.arange(self.size_px_out[1]) - self.size_px_out[1] / 2)
+        y = (np.arange(self.size_px_out[0]) - self.size_px_out[0] / 2)
+        xv, yv = np.meshgrid(x, y)
+        # Raised cosine aperture
+        inner_mask = (xv - cnt_px[1]) ** 2 + (yv - cnt_px[0]) ** 2 < a ** 2
+        cos_mask = 1 / 2 * (1 + np.cos(np.sqrt((xv - cnt_px[1]) ** 2 + (yv - cnt_px[0]) ** 2) / a * np.pi))
+        cos_mask[np.logical_not(inner_mask)] = 0
+
+        self.cos_mask = cos_mask
+
+    def convert_image(self, image_path):
+
+        im = imageio.imread(image_path)
+        im = im - self.gray_c * np.ones(self.size_px)
+        im_template = np.zeros(self.size_px_out)
+
+        im_template[self.fill_ind[0][0]:self.fill_ind[0][1], self.fill_ind[1][0]:self.fill_ind[1][1]] = im
+        im_masked = (im_template * self.cos_mask) + self.gray_c * np.ones(self.size_px_out)
+
+        target_path = self._target_dir + os.sep + os.path.basename(image_path)
+
+        imageio.imwrite(target_path, np.uint8(im_masked))
+
+        return target_path
+
+
+# saves converted image in a new folder given by the target_dir
+# returns the converted StimulusSet with the new image_paths and new stimuli_id (with -aperture added in the end)
+def convert_stimuli(stimulus_set_existing, stimulus_set_name_new, image_dir_new):
+    Path(image_dir_new).mkdir(parents=True, exist_ok=True)
+
+    image_converter = ApplyCosineAperture(target_dir=image_dir_new)
+    converted_image_paths = {}
+    converted_image_ids = {}
+    for image_id in tqdm(stimulus_set_existing['image_id'], total=len(stimulus_set_existing), desc='apply cosine aperture'):
+        converted_image_path = image_converter.convert_image(image_path=stimulus_set_existing.get_image(image_id))
+        converted_image_id = kf(converted_image_path).sha1
+        converted_image_ids[image_id] = converted_image_id
+        converted_image_paths[converted_image_id] = converted_image_path
+        _logger.debug(f"{image_id} -> {converted_image_id}:  {converted_image_path}")
+
+    converted_stimuli = StimulusSet(stimulus_set_existing.copy(deep=True))
+    converted_stimuli["image_id_without_aperture"] = converted_stimuli["image_id"]
+    converted_stimuli["image_id"] = converted_stimuli["image_id"].map(converted_image_ids)
+    converted_stimuli["image_file_sha1"] = converted_stimuli["image_id"]
+
+    converted_stimuli.image_paths = converted_image_paths
+    converted_stimuli.name = stimulus_set_name_new
+    converted_stimuli.id_mapping = converted_image_ids
+
+    return converted_stimuli
+
+
+def update_assembly(assembly, mapping):
+    assembly["image_id"] = ("presentation", pd.Series(assembly["image_id"]).map(mapping))
+    return assembly
+
+
+def strip_for_proto(assembly, stimulus_set):
+    da = xr.DataArray(assembly).reset_index(assembly.indexes.keys())
+    image_level = [k for k, v in da.coords.variables.items() if v.dims == ("presentation",) and
+                   k in stimulus_set.columns and k != "image_id"]
+    stripped = da.reset_coords(image_level, drop=True)
+    for k in list(stripped.attrs):
+        del stripped.attrs[k]
+    return stripped
+
+
+def convert_assembly(data_assembly_existing, data_assembly_name_new, stimulus_set_new, mapping):
+    stripped = strip_for_proto(data_assembly_existing, stimulus_set_new)
+    updated = update_assembly(stripped, mapping)
+    updated.name = data_assembly_name_new
+    return updated
+
+
+# main function should be run two times, one for each stimulus set access='public' and access='target'
+def main(access):
+    local_data_path = fetch._local_data_path
+    stimulus_name_root = 'FreemanZiemba2013'
+    assembly_name_root = 'movshon.FreemanZiemba2013'
+    stimulus_set_name_existing = stimulus_name_root + "-" + access if access != "both" else stimulus_name_root
+    stimulus_set_name_new = stimulus_name_root + ".aperture-" + access if access != "both" else stimulus_name_root + ".aperture"
+    data_assembly_name_existing = assembly_name_root + "." + access if access != "both" else assembly_name_root
+    data_assembly_name_new = assembly_name_root + ".aperture." + access if access != "both" else assembly_name_root + ".aperture"
+    temp_dir = os.path.join(local_data_path, "temp_" + data_assembly_name_new.replace(".", "_"))
+
+    stimulus_set_existing = get_stimulus_set(stimulus_set_name_existing)
+    stimulus_set_new = convert_stimuli(stimulus_set_existing, stimulus_set_name_new, temp_dir)
+    mapping = stimulus_set_new.id_mapping
+    _logger.debug(f"Packaging stimuli: {stimulus_set_new.name}")
+    package_stimulus_set(stimulus_set_new, stimulus_set_name=stimulus_set_new.name,
+                         bucket_name="brainio-contrib")
+
+    data_assembly_existing = get_assembly(data_assembly_name_existing)
+    proto_data_assembly_new = convert_assembly(data_assembly_existing, data_assembly_name_new, stimulus_set_new, mapping)
+    _logger.debug(f"Packaging assembly: {data_assembly_name_new}")
+    package_data_assembly(proto_data_assembly_new, data_assembly_name_new, stimulus_set_name_new,
+                          bucket_name="brainio-contrib")
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Convert Movshon stimuli')
+    parser.add_argument('--access', dest='access', type=str,
+                      help='access', choices=["both", "public", "private"],
+                      default='both')
+
+    args = parser.parse_args()
+
+    main(access=args.access)
+

brainscore_vision/data/freemanziemba2013/data_packaging/data_packaging.py

@@ -0,0 +1,57 @@
+import numpy as np
+from numpy.random.mtrand import RandomState
+from sklearn.model_selection import StratifiedShuffleSplit
+
+from brainio_collection.fetch import fetch_assembly, get_assembly
+from brainio_contrib.packaging import package_data_assembly, package_stimulus_set
+
+
+def adapt_stimulus_set(assembly, name_suffix):
+    stimulus_set_name = f"{assembly.stimulus_set.name}-{name_suffix}"
+    assembly.attrs['stimulus_set'] = assembly.stimulus_set[
+        assembly.stimulus_set['image_id'].isin(assembly['image_id'].values)]
+    assembly.stimulus_set.name = stimulus_set_name
+    assembly.attrs['stimulus_set_name'] = stimulus_set_name
+
+
+def load_assembly(assembly_name):
+    assembly = get_assembly(assembly_name)
+
+    if not hasattr(assembly.stimulus_set, 'name'):
+        assembly.stimulus_set.name = assembly.stimulus_set_name
+
+    stimulus_set_degrees = {'hvm': 8, 'FreemanZiemba2013': 4}
+    if assembly.stimulus_set.name in stimulus_set_degrees:
+        assembly.stimulus_set['degrees'] = stimulus_set_degrees[assembly.stimulus_set.name]
+    return assembly
+
+
+def package_Movshon_datasets(name):
+    assembly = load_assembly(name)
+    assembly.load()
+    base_assembly = assembly
+    _, unique_indices = np.unique(base_assembly['image_id'].values, return_index=True)
+    unique_indices = np.sort(unique_indices)  # preserve order
+    image_ids = base_assembly['image_id'].values[unique_indices]
+    stratification_values = base_assembly['texture_type'].values[unique_indices]
+    rng = RandomState(seed=12)
+    splitter = StratifiedShuffleSplit(n_splits=1, train_size=.3, test_size=None, random_state=rng)
+    split = next(splitter.split(np.zeros(len(image_ids)), stratification_values))
+    access_indices = {assembly_type: image_indices
+                      for assembly_type, image_indices in zip(['public', 'private'], split)}
+    for access in ['public', 'private']:
+        indices = access_indices[access]
+        subset_image_ids = image_ids[indices]
+        assembly = base_assembly[
+            {'presentation': [image_id in subset_image_ids for image_id in base_assembly['image_id'].values]}]
+        adapt_stimulus_set(assembly, access)
+        package_stimulus_set(assembly.attrs['stimulus_set'], stimulus_set_name=assembly.attrs['stimulus_set_name'])
+        del assembly.attrs['stimulus_set']
+        package_data_assembly(assembly, f"{name}.{access}", stimulus_set_name=assembly.attrs['stimulus_set_name'])
+
+    # not really sure if this is necessary
+    return assembly
+
+
+if __name__ == '__main__':
+    package_Movshon_datasets(name='movshon.FreemanZiemba2013')

brainscore_vision/data/freemanziemba2013/data_packaging/movshon.py

@@ -0,0 +1,202 @@
+import os
+import re
+import zipfile
+from glob import glob
+
+import brainscore_vision
+import h5py
+import numpy as np
+import pandas as pd
+import xarray as xr
+
+from brainscore_vision.knownfile import KnownFile as kf
+from brainscore_vision.lookup import pwdb
+from brainscore_vision.assemblies import AssemblyModel, AssemblyStoreMap, AssemblyStoreModel
+from brainscore_vision.stimuli import ImageModel, AttributeModel, ImageMetaModel, StimulusSetModel, ImageStoreModel, \
+    StimulusSetImageMap, ImageStoreMap
+
+# from FreemanZiemba2013_V1V2data_readme.m
+textureNumOrder = [327, 336, 393, 402, 13, 18, 23, 30, 38, 48, 52, 56, 60, 71, 99]
+
+
+def load_stimuli(stimuli_directory):
+    stimuli = []
+    for image_file_path in glob(f"{stimuli_directory}/*.png"):
+        image_file_name = os.path.basename(image_file_path)
+        fields = fields_from_image_name(image_file_name)
+        im_kf = kf(image_file_path)
+        extra_fields = {
+            'image_file_path': image_file_path,
+            'image_file_name': image_file_name,
+            "image_file_sha1": im_kf.sha1,
+            "image_id": im_kf.sha1,
+            "image_store_path": "movshon_stimuli/" + image_file_name
+        }
+        stimuli.append({**fields, **extra_fields})
+
+
+    stimuli = pd.DataFrame(stimuli)
+    assert len(stimuli) == 15 * 2 * 15
+    assert len(np.unique(stimuli['texture_family'])) == 15
+    assert len(np.unique(stimuli['texture_type'])) == 2
+    assert len(np.unique(stimuli['sample'])) == 15
+    assert len(np.unique(stimuli["image_id"])) == len(stimuli)
+
+    return stimuli
+
+
+def load_responses(response_file, stimuli_directory):
+    # from the readme.m: data is in the form:
+    # (texFamily) x (texType) x (sample) x (rep) x (timeBin) x (cellNum)
+    # (15)        x (2)       x (15)     x (20)  x (300)     x (102+)
+    # in python, ordering is inverted:
+    # (cellNum) x (timeBin) x (rep) x (sample) x (texType) x (texFamily)
+    # (102+)    x (300)     x (20)  x (15)     x (2)       x (15)
+    responses = h5py.File(response_file, 'r')
+    v1, v2 = responses['v1'], responses['v2']
+    assert v1.shape[1:] == v2.shape[1:]  # same except cells
+    responses = np.concatenate([v1, v2])
+
+    assembly = xr.DataArray(responses,
+                            coords={
+                                'neuroid_id': ("neuroid", list(range(1, responses.shape[0] + 1))),
+                                'region': ('neuroid', ['V1'] * v1.shape[0] + ['V2'] * v2.shape[0]),
+                                'time_bin_start': ("time_bin", list(range(responses.shape[1]))),  # each bin is 1 ms
+                                'time_bin_end': ("time_bin", list(range(1, responses.shape[1] + 1))),
+                                'repetition': list(range(responses.shape[2])),
+                                'sample': list(range(1, responses.shape[3] + 1)),
+                                'texture_type': ["noise", "texture"],
+                                'texture_family': textureNumOrder
+                            },
+                            dims=['neuroid', 'time_bin', 'repetition', 'sample', 'texture_type', 'texture_family'])
+
+    assembly = assembly.stack(presentation=['texture_type', 'texture_family', 'sample', 'repetition'])
+
+    image_fields = zip(*[assembly[k].values for k in ['texture_type', 'texture_family', 'sample']])
+    image_names = [image_name_from_fields(im[0], "320x320", im[1], im[2]) for im in image_fields]
+    assembly["image_file_name"] = ("presentation", image_names)
+
+    kfs = {}
+    sha1s = []
+    for image_name in image_names:
+        if image_name in kfs:
+            im_kf = kfs[image_name]
+        else:
+            im_kf = kf(os.path.join(stimuli_directory, image_name))
+            kfs[image_name] = im_kf
+        sha1s.append(im_kf.sha1)
+    assembly["image_id"] = ("presentation", sha1s)
+
+    return brainscore_vision.assemblies.NeuronRecordingAssembly(assembly)
+
+
+def write_netcdf(assembly, target_netcdf_file):
+    assembly.reset_index(assembly.indexes.keys(), inplace=True)
+    result = assembly.drop(["image_file_name", "texture_type", "texture_family", "sample"])
+    result.reset_index(result.indexes.keys(), inplace=True)
+    result.to_netcdf(target_netcdf_file)
+
+
+def create_image_zip(stimuli, target_zip_path):
+    os.makedirs(os.path.dirname(target_zip_path), exist_ok=True)
+    with zipfile.ZipFile(target_zip_path, 'w') as target_zip:
+        for image in stimuli.itertuples():
+            target_zip.write(image.image_file_path, arcname=image.image_store_path)
+    zip_kf = kf(target_zip_path)
+    return zip_kf.sha1
+
+
+def add_image_lookup(stimuli, target_zip_path, zip_sha1, stimulus_set_name, image_store_unique_name, bucket_name):
+    pwdb.connect(reuse_if_open=True)
+    zip_file_name = os.path.basename(target_zip_path)
+
+    stim_set_model, created = StimulusSetModel.get_or_create(name=stimulus_set_name)
+    image_store, created = ImageStoreModel.get_or_create(location_type="S3", store_type="zip",
+                                                         location=f"https://{bucket_name}.s3.amazonaws.com/{zip_file_name}",
+                                                         unique_name=image_store_unique_name,
+                                                         sha1=zip_sha1)
+    eav_image_file_sha1, created = AttributeModel.get_or_create(name="image_file_sha1", type="str")
+    eav_image_file_name, created = AttributeModel.get_or_create(name="image_file_name", type="str")
+    eav_image_texture_type, created = AttributeModel.get_or_create(name="texture_type", type="str")
+    eav_image_texture_family, created = AttributeModel.get_or_create(name="texture_family", type="int")
+    eav_image_sample, created = AttributeModel.get_or_create(name="sample", type="int")
+    eav_image_resolution, created = AttributeModel.get_or_create(name="resolution", type="str")
+
+    for image in stimuli.itertuples():
+        pw_image, created = ImageModel.get_or_create(image_id=image.image_id)
+        pw_stimulus_set_image_map, created = StimulusSetImageMap.get_or_create(stimulus_set=stim_set_model, image=pw_image)
+        pw_image_image_store_map, created = ImageStoreMap.get_or_create(image=pw_image, image_store=image_store,
+                                                                        path=image.image_store_path)
+        ImageMetaModel.get_or_create(image=pw_image, attribute=eav_image_file_sha1, value=str(image.image_file_sha1))
+        ImageMetaModel.get_or_create(image=pw_image, attribute=eav_image_file_name, value=str(image.image_file_name))
+        ImageMetaModel.get_or_create(image=pw_image, attribute=eav_image_texture_type, value=str(image.texture_type))
+        ImageMetaModel.get_or_create(image=pw_image, attribute=eav_image_texture_family, value=str(image.texture_family))
+        ImageMetaModel.get_or_create(image=pw_image, attribute=eav_image_sample, value=str(image.sample))
+        ImageMetaModel.get_or_create(image=pw_image, attribute=eav_image_resolution, value=str(image.resolution))
+
+    return stim_set_model
+
+
+def add_assembly_lookup(assembly_name, stim_set_model, bucket_name, target_netcdf_file, assembly_store_unique_name):
+    kf_netcdf = kf(target_netcdf_file)
+    assy, created = AssemblyModel.get_or_create(name=assembly_name, assembly_class="NeuronRecordingAssembly",
+                                                stimulus_set=stim_set_model)
+    store, created = AssemblyStoreModel.get_or_create(assembly_type="netCDF",
+                                                      location_type="S3",
+                                                      location=f"https://{bucket_name}.s3.amazonaws.com/{assembly_name}.nc",
+                                                      unique_name=assembly_store_unique_name,
+                                                      sha1=kf_netcdf.sha1)
+    assy_store_map, created = AssemblyStoreMap.get_or_create(assembly_model=assy, assembly_store_model=store, role=assembly_name)
+
+
+def image_name_from_fields(texture_type, resolution, texture_family, sample):
+    mapping = {"noise": "noise", "texture": "tex"}
+    return f"{mapping[texture_type]}-{resolution}-im{int(texture_family)}-smp{int(sample)}.png"
+
+
+def fields_from_image_name(image_name):
+    # sample image file name: noise-320x320-im13-smp8
+    integer_fields = ['family', 'sample']
+    mapping = {"noise": "noise", "tex": "texture"}
+    pattern = "^(?P<texture_type>[^-]+)-(?P<resolution>[^-]+)-im(?P<texture_family>[0-9]*)-smp(?P<sample>[0-9]+)\.png$"
+    match = re.match(pattern, image_name)
+    assert match
+    fields = match.groupdict()
+    fields = {field: value if field not in integer_fields else int(value) for field, value in fields.items()}
+    fields = {field: value if field != "texture_type" else mapping[value] for field, value in fields.items()}
+    return fields
+
+
+def main():
+    data_path = os.path.join(os.path.dirname(__file__), 'FreemanZiemba2013')
+    stimuli_directory = os.path.join(data_path, 'stim')
+    response_file = os.path.join(data_path, 'data', 'FreemanZiemba2013_V1V2data.mat')
+    output_path = os.path.join(data_path, 'out')
+    stimulus_set_name = "FreemanZiemba2013"
+    bucket_name = "brain-score-movshon"
+    image_store_unique_name = "image_movshon_stimuli"
+    target_zip_path = os.path.join(output_path, image_store_unique_name + ".zip")
+    assembly_name = stimulus_set_name
+    assembly_store_unique_name = "assy_movshon_FreemanZiemba2013"
+    target_netcdf_file = os.path.join(output_path, assembly_name + ".nc")
+
+    stimuli = load_stimuli(stimuli_directory)
+    assembly = load_responses(response_file, stimuli_directory)
+
+    nonzero = np.count_nonzero(assembly)
+    assert nonzero > 0
+
+    all_ids = lambda assembly, stimuli, i: assembly.sel(image_file_name=stimuli["image_file_name"][i])["image_id"]
+    all_match = lambda assembly, stimuli, i: all(all_ids(assembly, stimuli, i) == stimuli["image_id"][i])
+    assert all([all_match(assembly, stimuli, i) for i in range(len(stimuli))])
+
+    zip_sha1 = create_image_zip(stimuli, target_zip_path)
+    stim_set_model = add_image_lookup(stimuli, target_zip_path, zip_sha1, stimulus_set_name, image_store_unique_name, bucket_name)
+    write_netcdf(assembly, target_netcdf_file)
+    add_assembly_lookup(assembly_name, stim_set_model, bucket_name, target_netcdf_file, assembly_store_unique_name)
+
+    return (assembly, stimuli)
+
+
+if __name__ == '__main__':
+    main()

brainscore_vision/data/freemanziemba2013/test.py

@@ -0,0 +1,97 @@
+from pathlib import Path
+
+import numpy as np
+import pytest
+from PIL import Image
+from pytest import approx
+
+from brainscore_vision import load_dataset
+from brainscore_vision.benchmark_helpers import check_standard_format
+from brainscore_vision.benchmarks.freemanziemba2013.benchmarks.benchmark import load_assembly
+
+
+@pytest.mark.parametrize('assembly_identifier', [
+    pytest.param('FreemanZiemba2013', marks=[pytest.mark.private_access, pytest.mark.memory_intense]),
+    pytest.param('FreemanZiemba2013.public', marks=[pytest.mark.memory_intense]),
+    pytest.param('FreemanZiemba2013.private', marks=[pytest.mark.private_access, pytest.mark.memory_intense]),
+])
+def test_existence(assembly_identifier):
+    assert load_dataset(assembly_identifier) is not None
+
+
+@pytest.mark.memory_intense
+@pytest.mark.private_access
+class TestAssembly:
+    def test_V1(self):
+        assembly = load_assembly(region='V1', average_repetitions=True)
+        check_standard_format(assembly)
+        assert assembly.attrs['stimulus_set_identifier'] == 'FreemanZiemba2013.aperture-private'
+        assert set(assembly['region'].values) == {'V1'}
+        assert len(assembly['presentation']) == 315
+        assert len(assembly['neuroid']) == 102
+
+    def test_V2(self):
+        assembly = load_assembly(region='V2', average_repetitions=True)
+        check_standard_format(assembly)
+        assert assembly.attrs['stimulus_set_identifier'] == 'FreemanZiemba2013.aperture-private'
+        assert set(assembly['region'].values) == {'V2'}
+        assert len(assembly['presentation']) == 315
+        assert len(assembly['neuroid']) == 103
+
+
+class TestFreemanZiemba:
+    @pytest.mark.parametrize('identifier', [
+        pytest.param('FreemanZiemba2013.public', marks=[]),
+        pytest.param('FreemanZiemba2013.private', marks=[pytest.mark.private_access]),
+    ])
+    def test_v1_v2_alignment(self, identifier):
+        assembly = load_dataset(identifier)
+        v1 = assembly[{'neuroid': [region == 'V1' for region in assembly['region'].values]}]
+        v2 = assembly[{'neuroid': [region == 'V2' for region in assembly['region'].values]}]
+        assert len(v1['presentation']) == len(v2['presentation'])
+        assert set(v1['stimulus_id'].values) == set(v2['stimulus_id'].values)
+
+    @pytest.mark.parametrize('identifier', [
+        pytest.param('FreemanZiemba2013.public', marks=[]),
+        pytest.param('FreemanZiemba2013.private', marks=[pytest.mark.private_access]),
+    ])
+    def test_num_neurons(self, identifier):
+        assembly = load_dataset(identifier)
+        assert len(assembly['neuroid']) == 205
+        v1 = assembly[{'neuroid': [region == 'V1' for region in assembly['region'].values]}]
+        assert len(v1['neuroid']) == 102
+        v2 = assembly[{'neuroid': [region == 'V2' for region in assembly['region'].values]}]
+        assert len(v2['neuroid']) == 103
+
+    @pytest.mark.parametrize('identifier', [
+        pytest.param('FreemanZiemba2013.public', marks=[]),
+        pytest.param('FreemanZiemba2013.private', marks=[pytest.mark.private_access]),
+    ])
+    def test_nonzero(self, identifier):
+        assembly = load_dataset(identifier)
+        nonzero = np.count_nonzero(assembly)
+        assert nonzero > 0
+
+    @pytest.mark.parametrize('identifier, image_id, expected_amount_gray, ratio_gray', [
+        pytest.param('FreemanZiemba2013.public', '21041db1f26c142812a66277c2957fb3e2070916',
+                     31756, .3101171875, marks=[]),
+        pytest.param('FreemanZiemba2013.private', 'bfd26c127f8ba028cc95cdc95f00c45c8884b365',
+                     31585, .308447265625, marks=[pytest.mark.private_access]),
+    ])
+    def test_aperture(self, identifier, image_id, expected_amount_gray, ratio_gray):
+        """ test a random image for the correct amount of gray pixels """
+        assembly = load_dataset(identifier)
+        stimulus_set = assembly.stimulus_set
+        image_path = Path(stimulus_set.get_stimulus(image_id))
+        assert image_path.is_file()
+        # count number of gray pixels in image
+        image = Image.open(image_path)
+        image = np.array(image)
+        amount_gray = 0
+        for index in np.ndindex(image.shape[:2]):
+            color = image[index]
+            gray = [128, 128, 128]
+            if (color == gray).all():
+                amount_gray += 1
+        assert amount_gray / image.size == approx(ratio_gray, abs=.0001)
+        assert amount_gray == expected_amount_gray