This repository contains the version 1.0 of the COOS-7 dataset (to be presented as a poster at NeurIPS 2019; see preprint at https://arxiv.org/abs/1906.07282). COOS-7 contains 132,209 crops of mouse cells, stratified into a training dataset, and four test datasets representing increasing degrees of covariate shift from the training dataset. In the classification task associated with COOS-7, the aim is to build a classifier robust to covariate shifts typically seen in microscopy. Methods developers must train and optimize machine learning models using the training dataset exclusively, and evaluate performance on each of the four test datasets.

Each HDF5 file contains two main dictionaries: 'data' - contains all of the images in a four-dimensional array (images, channels, height, width) 'labels' - contains the labels for each image, in the same order as the images in 'data'

New in this version (1.1) - we have added four additional dictionaries containing metadata: 'plateIDs' - string indicating the plate the image originated from 'wellIDs' - string indicating the well the image originated from (first three numbers indicate row on plate, second three numbers indicate column on plate) 'dateIDs' - string indicating date the image was taken on (YYYYMMDD) 'microscopeIDs' - string indicating which microscope the image was taken on

The value for labels indicates the class of the image, which can be one of seven values: 0 - Endoplasmic Reticulum (ER) 1 - Inner Mitochondrial Membrane (IMM) 2 - Golgi 3 - Peroxisomes 4 - Early Endosome 5 - Cytosol 6 - Nuclear Envelope

The h5py package is required to read these files with Python.

We provide a Python script, unpackage_COOS.py, that will automatically save the archives as directories of tiff files, organized by class. The two channels for each image will be saved as separate images, with a suffix of "_protein.tif" and "_nucleus.tif", respectively.

To run the unpackaging script, issue the command line argument: python unpackage_COOS.py [path of HDF5 file] [path of directory to save images to] e.g. python unpackage_COOS.py ./COOS7_v1.0_training.hdf5 ./COOS7_v1.0_training_images/

Full information about the test sets and the images can be found at https://arxiv.org/abs/1906.07282.

The provided dataset comprises 43 instances of temporal bone volume CT scans. The scans were performed on human cadaveric specimen with a resulting isotropic voxel size of (99 \times 99 \times 99 \, \, \mathrm{\mu m}^3). Voxel-wise image labels of the fluid space of the bony labyrinth, subdivided in the three semantic classes cochlear volume, vestibular volume and semicircular canal volume are provided. In addition, each dataset contains JSON-like descriptor data defining the voxel coordinates of the anatomical landmarks: (1) apex of the cochlea, (2) oval window and (3) round window. The dataset can be used to train and evaluate algorithmic machine learning models for automated innear ear analysis in the context of the supervised learning paradigm.

Usage Notes

The datasets are formatted in the HDF5 format developed by the HDF5 Group. We utilized and thus recommend the usage of Python bindings pyHDF to handle the datasets.

The flat-panel volume CT raw data, labels and landmarks are saved in the HDF5-internal file structure using the respective group and datasets:

raw/raw-0 label/label-0 landmark/landmark-0 landmark/landmark-1 landmark/landmark-2

Array raw and label data can be read from the file by indexing into an opened h5py file handle, for example as numpy.ndarray. Further metadata is contained in the attribute dictionaries of the raw and label datasets.

Landmark coordinate data is available as an attribute dict and contains the coordinate system (LPS or RAS), IJK voxel coordinates and label information. The helicotrema or cochlea top is globally saved in landmark 0, the oval window in landmark 1 and the round window in landmark 2. Read as a Python dictionary, exemplary landmark information for a dataset may reads as follows:

{'coordsys': 'LPS', 'id': 1, 'ijk_position': array([181, 188, 100]), 'label': 'CochleaTop', 'orientation': array([-1., -0., -0., -0., -1., -0., 0., 0., 1.]), 'xyz_position': array([ 44.21109689, -139.38058589, -183.48249736])}

{'coordsys': 'LPS', 'id': 2, 'ijk_position': array([222, 182, 145]), 'label': 'OvalWindow', 'orientation': array([-1., -0., -0., -0., -1., -0., 0., 0., 1.]), 'xyz_position': array([ 48.27890112, -139.95991131, -179.04103763])}

{'coordsys': 'LPS', 'id': 3, 'ijk_position': array([223, 209, 147]), 'label': 'RoundWindow', 'orientation': array([-1., -0., -0., -0., -1., -0., 0., 0., 1.]), 'xyz_position': array([ 48.33120126, -137.27135678, -178.8665465 ])}

REASSEMBLE: A Multimodal Dataset for Contact-rich Robotic Assembly and Disassembly

📋 Introduction

Robotic manipulation remains a core challenge in robotics, particularly for contact-rich tasks such as industrial assembly and disassembly. Existing datasets have significantly advanced learning in manipulation but are primarily focused on simpler tasks like object rearrangement, falling short of capturing the complexity and physical dynamics involved in assembly and disassembly. To bridge this gap, we present REASSEMBLE (Robotic assEmbly disASSEMBLy datasEt), a new dataset designed specifically for contact-rich manipulation tasks. Built around the NIST Assembly Task Board 1 benchmark, REASSEMBLE includes four actions (pick, insert, remove, and place) involving 17 objects. The dataset contains 4,551 demonstrations, of which 4,035 were successful, spanning a total of 781 minutes. Our dataset features multi-modal sensor data including event cameras, force-torque sensors, microphones, and multi-view RGB cameras. This diverse dataset supports research in areas such as learning contact-rich manipulation, task condition identification, action segmentation, and more. We believe REASSEMBLE will be a valuable resource for advancing robotic manipulation in complex, real-world scenarios.

{"Hama1": [
    [x ,y, z],
    [qx, qy, qz, qw]
 ], 
 "Hama2": [
    [x ,y, z],
    [qx, qy, qz, qw]
 ], 
 "DAVIS346": [
    [x ,y, z],
    [qx, qy, qz, qw]
 ], 
 "NIST_Board1": [
    [x ,y, z],
    [qx, qy, qz, qw]
 ]
}

[x, y, z] represent the position of the object, and [qx, qy, qz, qw] represent its orientation as a quaternion.

The HDF5 (.h5) format organizes data into two main types of structures: datasets, which hold the actual data, and groups, which act like folders that can contain datasets or other groups. In the diagram below, groups are shown as folder icons, and datasets as file icons. The main group of the file directly contains the video, audio, and event data. To save memory, video and audio are stored as encoded byte strings, while event data is stored as arrays. The robot’s proprioceptive information is kept in the robot_state group as arrays. Because different sensors record data at different rates, the arrays vary in length (signified by the N_xxx variable in the data shapes). To align the sensory data, each sensor’s timestamps are stored separately in the timestamps group. Information about action segments is stored in the segments_info group. Each segment is saved as a subgroup, named according to its order in the demonstration, and includes a start timestamp, end timestamp, a success indicator, and a natural language description of the action. Within each segment, low-level skills are organized under a low_level subgroup, following the same structure as the high-level annotations.

📁

The splits folder contains two text files which list the h5 files used for the traning and validation splits.

📌 Important Resources

The project website contains more details about the REASSEMBLE dataset. The Code for loading and visualizing the data is avaibile on our github repository.

📄 Project website: https://tuwien-asl.github.io/REASSEMBLE_page/
💻 Code: https://github.com/TUWIEN-ASL/REASSEMBLE

Motivation

The goal of introducing the Rescaled CIFAR-10 dataset is to provide a dataset that contains scale variations (up to a factor of 4), to evaluate the ability of networks to generalise to scales not present in the training data.

The Rescaled CIFAR-10 dataset was introduced in the paper:

[1] A. Perzanowski and T. Lindeberg (2025) "Scale generalisation properties of extended scale-covariant and scale-invariant Gaussian derivative networks on image datasets with spatial scaling variations”, Journal of Mathematical Imaging and Vision, 67(29), https://doi.org/10.1007/s10851-025-01245-x.

with a pre-print available at arXiv:

[2] Perzanowski and Lindeberg (2024) "Scale generalisation properties of extended scale-covariant and scale-invariant Gaussian derivative networks on image datasets with spatial scaling variations”, arXiv preprint arXiv:2409.11140.

Importantly, the Rescaled CIFAR-10 dataset contains substantially more natural textures and patterns than the MNIST Large Scale dataset, introduced in:

[3] Y. Jansson and T. Lindeberg (2022) "Scale-invariant scale-channel networks: Deep networks that generalise to previously unseen scales", Journal of Mathematical Imaging and Vision, 64(5): 506-536, https://doi.org/10.1007/s10851-022-01082-2

and is therefore significantly more challenging.

Access and rights

The Rescaled CIFAR-10 dataset is provided on the condition that you provide proper citation for the original CIFAR-10 dataset:

[4] Krizhevsky, A. and Hinton, G. (2009). Learning multiple layers of features from tiny images. Tech. rep., University of Toronto.

and also for this new rescaled version, using the reference [1] above.

The data set is made available on request. If you would be interested in trying out this data set, please make a request in the system below, and we will grant you access as soon as possible.

The dataset

The Rescaled CIFAR-10 dataset is generated by rescaling 32×32 RGB images of animals and vehicles from the original CIFAR-10 dataset [4]. The scale variations are up to a factor of 4. In order to have all test images have the same resolution, mirror extension is used to extend the images to size 64x64. The imresize() function in Matlab was used for the rescaling, with default anti-aliasing turned on, and bicubic interpolation overshoot removed by clipping to the [0, 255] range. The details of how the dataset was created can be found in [1].

There are 10 distinct classes in the dataset: “airplane”, “automobile”, “bird”, “cat”, “deer”, “dog”, “frog”, “horse”, “ship” and “truck”. In the dataset, these are represented by integer labels in the range [0, 9].

The dataset is split into 40 000 training samples, 10 000 validation samples and 10 000 testing samples. The training dataset is generated using the initial 40 000 samples from the original CIFAR-10 training set. The validation dataset, on the other hand, is formed from the final 10 000 image batch of that same training set. For testing, all test datasets are built from the 10 000 images contained in the original CIFAR-10 test set.

The h5 files containing the dataset

The training dataset file (~5.9 GB) for scale 1, which also contains the corresponding validation and test data for the same scale, is:

cifar10_with_scale_variations_tr40000_vl10000_te10000_outsize64-64_scte1p000_scte1p000.h5

Additionally, for the Rescaled CIFAR-10 dataset, there are 9 datasets (~1 GB each) for testing scale generalisation at scales not present in the training set. Each of these datasets is rescaled using a different image scaling factor, 2^k/4, with k being integers in the range [-4, 4]:

cifar10_with_scale_variations_te10000_outsize64-64_scte0p500.h5
cifar10_with_scale_variations_te10000_outsize64-64_scte0p595.h5
cifar10_with_scale_variations_te10000_outsize64-64_scte0p707.h5
cifar10_with_scale_variations_te10000_outsize64-64_scte0p841.h5
cifar10_with_scale_variations_te10000_outsize64-64_scte1p000.h5
cifar10_with_scale_variations_te10000_outsize64-64_scte1p189.h5
cifar10_with_scale_variations_te10000_outsize64-64_scte1p414.h5
cifar10_with_scale_variations_te10000_outsize64-64_scte1p682.h5
cifar10_with_scale_variations_te10000_outsize64-64_scte2p000.h5

These dataset files were used for the experiments presented in Figures 9, 10, 15, 16, 20 and 24 in [1].

Instructions for loading the data set

The datasets are saved in HDF5 format, with the partitions in the respective h5 files named as
('/x_train', '/x_val', '/x_test', '/y_train', '/y_test', '/y_val'); which ones exist depends on which data split is used.

The training dataset can be loaded in Python as:

with h5py.File(`

x_train = np.array( f["/x_train"], dtype=np.float32)
x_val = np.array( f["/x_val"], dtype=np.float32)
x_test = np.array( f["/x_test"], dtype=np.float32)
y_train = np.array( f["/y_train"], dtype=np.int32)
y_val = np.array( f["/y_val"], dtype=np.int32)
y_test = np.array( f["/y_test"], dtype=np.int32)

We also need to permute the data, since Pytorch uses the format [num_samples, channels, width, height], while the data is saved as [num_samples, width, height, channels]:

x_train = np.transpose(x_train, (0, 3, 1, 2))
x_val = np.transpose(x_val, (0, 3, 1, 2))
x_test = np.transpose(x_test, (0, 3, 1, 2))

The test datasets can be loaded in Python as:

with h5py.File(`

x_test = np.array( f["/x_test"], dtype=np.float32)
y_test = np.array( f["/y_test"], dtype=np.int32)

The test datasets can be loaded in Matlab as:

x_test = h5read(`

The images are stored as [num_samples, x_dim, y_dim, channels] in HDF5 files. The pixel intensity values are not normalised, and are in a [0, 255] range.

Objective. To test the hypothesis that a multicenter-validated computer deep learning algorithm detects MRI-negative focal cortical dysplasia (FCD).

Methods. We used clinically acquired 3D T1-weighted and 3D FLAIR MRI of 148 patients (median age, 23 years [range, 2-55]; 47% female) with histologically verified FCD at nine centers to train a deep convolutional neural network (CNN) classifier. Images were initially deemed as MRI-negative in 51% of cases, in whom intracranial EEG determined the focus. For risk stratification, the CNN incorporated Bayesian uncertainty estimation as a measure of confidence. To evaluate performance, detection maps were compared to expert FCD manual labels. We also tested sensitivity in an independent cohort of 23 FCD cases (13±10 years). Applying the algorithm to 38 healthy and 63 temporal lobe epilepsy disease controls tested specificity.

Results. Overall sensitivity was 93% (137/148 FCD detected) using a leave-one-site-out cross-validation, with an a..., 1. Description of methods used for collection/generation of data [noel_deepFCD_patch_16x16x16.h5]: To create the HDF5 dataset, for each of the 148 FCD patients, we sampled at most 1,000 cortical patches (or # voxels in the lesion, whichever is lower) of size 16×16×16 within the lesion on pre-processed T1- and T2-weighted FLAIR MRI. The same number of cortical patches were sampled randomly outside the lesion. The resulting lesional and non-lesional patches were concatenated, shuffled (to add another layer of randomization), and saved along with their binary labels (as a compressed HDF5 dataset). Refer original publication and FCD_Detection_Neurology_Supplement.docx for more details

1. Methods for processing the data [noel_deepFCD_patch_16x16x16.h5]: MRI pre-processing involved linear registration to the MNI152 symmetric template, non-uniformity correction, intensity standardization with scaling of values between 0 and 100, and skull-stripping using an in-house deep learning method (..., FCD_Detection_Neurology_Supplement.docx contains:

   Table e-1. MRI acquisition parameters across sites

   Figure e-1. Hierarchical patch-based feature learning using CNN

   Additional Methods:

   Classifier design
   
   Source code and data availability
   

   Table e-2. Peak location of FCD lesions in MNI space

   Table e-3. Peak location of false positive clusters in MNI space

   eReferences

noel_deepFCD_patch_16x16x16.h5Â (size: 6.4GB) contains two variables (data and labels):

also available from:Â https://doi.org/10.5281/zenodo.3239446

    variables
    array shape
    description




    data
    {282736, 2, 16, 16, 16}
    The data variable contains a numpy array (numpy.float) with 2,82,736 multimodal (T1- and T2-weighted FLAIR) patches of size 16×16×16. See Source code and data availability section in Additional Methods (FCD_Detection_Neurology_Supplement.docx) for details


    labels
    {282736}

...

Motivation

The goal of introducing the Rescaled Fashion-MNIST dataset is to provide a dataset that contains scale variations (up to a factor of 4), to evaluate the ability of networks to generalise to scales not present in the training data.

The Rescaled Fashion-MNIST dataset was introduced in the paper:

[1] A. Perzanowski and T. Lindeberg (2025) "Scale generalisation properties of extended scale-covariant and scale-invariant Gaussian derivative networks on image datasets with spatial scaling variations”, Journal of Mathematical Imaging and Vision, 67(29), https://doi.org/10.1007/s10851-025-01245-x.

with a pre-print available at arXiv:

[2] Perzanowski and Lindeberg (2024) "Scale generalisation properties of extended scale-covariant and scale-invariant Gaussian derivative networks on image datasets with spatial scaling variations”, arXiv preprint arXiv:2409.11140.

Importantly, the Rescaled Fashion-MNIST dataset is more challenging than the MNIST Large Scale dataset, introduced in:

[3] Y. Jansson and T. Lindeberg (2022) "Scale-invariant scale-channel networks: Deep networks that generalise to previously unseen scales", Journal of Mathematical Imaging and Vision, 64(5): 506-536, https://doi.org/10.1007/s10851-022-01082-2.

Access and rights

The Rescaled Fashion-MNIST dataset is provided on the condition that you provide proper citation for the original Fashion-MNIST dataset:

[4] Xiao, H., Rasul, K., and Vollgraf, R. (2017) “Fashion-MNIST: A novel image dataset for benchmarking machine learning algorithms”, arXiv preprint arXiv:1708.07747

and also for this new rescaled version, using the reference [1] above.

The data set is made available on request. If you would be interested in trying out this data set, please make a request in the system below, and we will grant you access as soon as possible.

The dataset

The Rescaled FashionMNIST dataset is generated by rescaling 28×28 gray-scale images of clothes from the original FashionMNIST dataset [4]. The scale variations are up to a factor of 4, and the images are embedded within black images of size 72x72, with the object in the frame always centred. The imresize() function in Matlab was used for the rescaling, with default anti-aliasing turned on, and bicubic interpolation overshoot removed by clipping to the [0, 255] range. The details of how the dataset was created can be found in [1].

There are 10 different classes in the dataset: “T-shirt/top”, “trouser”, “pullover”, “dress”, “coat”, “sandal”, “shirt”, “sneaker”, “bag” and “ankle boot”. In the dataset, these are represented by integer labels in the range [0, 9].

The dataset is split into 50 000 training samples, 10 000 validation samples and 10 000 testing samples. The training dataset is generated using the initial 50 000 samples from the original Fashion-MNIST training set. The validation dataset, on the other hand, is formed from the final 10 000 images of that same training set. For testing, all test datasets are built from the 10 000 images contained in the original Fashion-MNIST test set.

The h5 files containing the dataset

The training dataset file (~2.9 GB) for scale 1, which also contains the corresponding validation and test data for the same scale, is:

fashionmnist_with_scale_variations_tr50000_vl10000_te10000_outsize72-72_scte1p000_scte1p000.h5

Additionally, for the Rescaled FashionMNIST dataset, there are 9 datasets (~415 MB each) for testing scale generalisation at scales not present in the training set. Each of these datasets is rescaled using a different image scaling factor, 2^k/4, with k being integers in the range [-4, 4]:

fashionmnist_with_scale_variations_te10000_outsize72-72_scte0p500.h5
fashionmnist_with_scale_variations_te10000_outsize72-72_scte0p595.h5
fashionmnist_with_scale_variations_te10000_outsize72-72_scte0p707.h5
fashionmnist_with_scale_variations_te10000_outsize72-72_scte0p841.h5
fashionmnist_with_scale_variations_te10000_outsize72-72_scte1p000.h5
fashionmnist_with_scale_variations_te10000_outsize72-72_scte1p189.h5
fashionmnist_with_scale_variations_te10000_outsize72-72_scte1p414.h5
fashionmnist_with_scale_variations_te10000_outsize72-72_scte1p682.h5
fashionmnist_with_scale_variations_te10000_outsize72-72_scte2p000.h5

These dataset files were used for the experiments presented in Figures 6, 7, 14, 16, 19 and 23 in [1].

Instructions for loading the data set

The datasets are saved in HDF5 format, with the partitions in the respective h5 files named as
('/x_train', '/x_val', '/x_test', '/y_train', '/y_test', '/y_val'); which ones exist depends on which data split is used.

The training dataset can be loaded in Python as:

with h5py.File(`

x_train = np.array( f["/x_train"], dtype=np.float32)
x_val = np.array( f["/x_val"], dtype=np.float32)
x_test = np.array( f["/x_test"], dtype=np.float32)
y_train = np.array( f["/y_train"], dtype=np.int32)
y_val = np.array( f["/y_val"], dtype=np.int32)
y_test = np.array( f["/y_test"], dtype=np.int32)

We also need to permute the data, since Pytorch uses the format [num_samples, channels, width, height], while the data is saved as [num_samples, width, height, channels]:

x_train = np.transpose(x_train, (0, 3, 1, 2))
x_val = np.transpose(x_val, (0, 3, 1, 2))
x_test = np.transpose(x_test, (0, 3, 1, 2))

The test datasets can be loaded in Python as:

with h5py.File(`

x_test = np.array( f["/x_test"], dtype=np.float32)
y_test = np.array( f["/y_test"], dtype=np.int32)

The test datasets can be loaded in Matlab as:

x_test = h5read(`

The images are stored as [num_samples, x_dim, y_dim, channels] in HDF5 files. The pixel intensity values are not normalised, and are in a [0, 255] range.

There is also a closely related Fashion-MNIST with translations dataset, which in addition to scaling variations also comprises spatial translations of the objects.

General information: This dataset contains measurements from the adaptive high-rise demonstrator building D1244, built in the scope of the CRC1244. This 36m high building is equipped with 24 hydraulic actuators providing the basis for its structural adaptation. Strain gauges, pressure sensors and position encoders are mounted throughout the building and used for state estimation and monitoring. Structure of the dataset: Each zip-file contains measurements of one day in the hdf5 format. The hdf5-files in each zip-file contain an array of 244 signals sampled over 10^6 time steps at approximately 200Hz. labels.csv contains auxiliary information on all measured signals, including the sensor type and the sensor's location in the building File contents: Each hdf5-file contains signals of the following types, arranged as stated in labels.csv: strain: strain (in mm/m) in columns and diagonal bracing elements, measured by strain gauges. pressure: pressure (in bar) in the piston side or the rod side chamber of a hydraulic actuator. For actuators in the diagonal bracing, the rod side chamber is permanently connected to the tank. posenc: displacement (in meters) of each actuator, measured by a position encoder. optic: optically measured displacement (in meters) of emitters attached to the building's facade. The building consists of four modules spanning three stories each, and all sensors within a module are connected to a control cabinet, from which all measurements are transmitted. The cameras of the optical measurement system are placed outside the building and transmit their data separately from the sensors within the building. Therefore, there are an additional two signals per module (or camera): timestamp: unix timestamp (seconds since 1st January 1970) of the control cabinet numvars: number of measured variables Missing measurements are marked as NaN. The optical measurement system is currently undergoing maintenance, which is why the corresponding signals are all NaN.

Companion dataset of the manuscript: Fu Li, Umberto Villa, Seonyeong Park, Mark A. Anastasio. Three-dimensional stochastic numerical breast phantoms for enabling virtual imaging trials of ultrasound computed tomography. Arxiv preprint 2106.02744 (2021) This dataset includes a collection of 52 two-dimensional slices of numerical breast phantoms (NBPs) and corresponding ultrasound computed tomography (USCT) simulated measurement data. The anatomical structures of these NBPs were obtained by use of tools from the Virtual Imaging Clinical Trial for Regulatory Evaluation (VICTRE) project. More details on the modification and extension of the VICTRE NBPs for use in USCT studies can be found in the accompanying paper. The NBPs included in this dataset are representative of four ACR BI-RADS breast composition types: A. The breast is almost entirely fatty B. There are scattered areas of fibroglandular density C. The breasts is heterogeneously dense D. The breast is extremely dense Each NBP contains 2D maps of tissue labels, speed of sound, acoustic attenuation, density. A low-resolution speed-of-sound map is also provided to reproduce the FWI reconstruction results presented in the accompanying paper. Corresponding USCT measurement data were simulated by modeling 2D wave propagation in lossy heterogeneous media using a time explicit pseudospectral wave propagation solver. The dataset consists of three folders: The 2d_slices folder contains the 52 slices extracted from 3D NBPs. The measurements folder contains simulated measurement data corresponding to each slice. The imaging_system folder contains information about the 2D imaging system (excitation source, transducer coordinates) In addition, the following helper Matlab scripts are included: read_data.m: Helper function to load and visualize the excitation source and transducer locations. read_waveform_data.m: Helper function to read the .h5 files containing the measurement data. Each slice is saved as a binary MATLAB file (.mat) and contains the following variables label: tissue label map with [2560,2560] pixels and 0.1mm pixel size. Tissue types are denoted using the following labels: water (0), fat (1), skin (2), glandular (29), ligament (88), lesion (200). sos: speed of sound map (mm/μs) with [2560,2560] pixels and 0.1 mm pixel size. Data is stored as data type float32. aa: acoustic attenuation map (Np/m/MHzy) with [2560,2560] pixels and 0.1mm pixel size. Data is stored as data type float32. density: density map (kg/mm3) with [2560,2560] pixels and 0.1 mm pixel size. Data is stored as data type float32. sos_ini: low resolution speed of sound map (mm/μs) with [1280,1280] pixels and 0.2mm pixel size. Data is stored as data type float32. This is the initial guess used in the speed of sound reconstructions in our paper. y: attenuation exponent used for simulation. seed: phantom id type: breast composition type (A-D) The simulated measurement data is saved in hdf5 format. Measurement data corresponding the i-th emitting transducer is stored with hdf5 key equal to the transducer index as a two-dimensional array of size [1024,4250]. Here, the rows represent the receiver index, and the columns the time sample. The sampling frequency is 25MHZ. Because of file size limitations, measurement data for each slice has been divided into 8 chunks, containing data from 128 receivers each. The imaging_system folder contains information regarding the 2D imaging system. source300.mat describes the time profile of the exitation pulse. It consists of 300 time samples at a sampling frequency of 25Mhz. locations1024.mat provide the xy coordinates (mm)of the location of each transducer Data type is float32. Array size is [2x1024]. Warning: This is a very large dataset (~1TB). Please check out our download script written in python.

A curated list of preprocessed & ready to use under a minute Human Activity Recognition datasets.

All the datasets are preprocessed in HDF5 format, created using the h5py python library. Scripts used for data preprocessing are provided as well (Load.ipynb and load_jordao.py)

Each HDF5 file contains at least the keys:

• x a single array of size [sample count, temporal length, sensor channel count], contains the actual sensor data. Metadata contains the names of individual sensor channel count. All samples are zero-padded for constant length in the file, original lengths before padding available under the meta keys.
• y a single array of size [sample count] with integer values for target classes (zero-based). Metadata contains the names of the target classes.
• meta contain various metadata, depends on the dataset (original length before padding, subject no., trial no., etc.)

Usage example

import h5py

with h5py.File(f'data/waveglove_multi.h5', 'r') as h5f:
   x = h5f['x']
   y = h5f['y']['class']
   print(f'WaveGlove-multi: {x.shape[0]} samples')
   print(f'Sensor channels: {h5f["x"].attrs["channels"]}')
   print(f'Target classes: {h5f["y"].attrs["labels"]}')
   first_sample = x[0]
# Output:   
# WaveGlove-multi: 10044 samples
# Sensor channels: ['acc1-x' 'acc1-y' 'acc1-z' 'gyro1-x' 'gyro1-y' 'gyro1-z' 'acc2-x'
# 'acc2-y' 'acc2-z' 'gyro2-x' 'gyro2-y' 'gyro2-z' 'acc3-x' 'acc3-y'
# 'acc3-z' 'gyro3-x' 'gyro3-y' 'gyro3-z' 'acc4-x' 'acc4-y' 'acc4-z'
# 'gyro4-x' 'gyro4-y' 'gyro4-z' 'acc5-x' 'acc5-y' 'acc5-z' 'gyro5-x'
# 'gyro5-y' 'gyro5-z']
# Target classes: ['null' 'hand swipe left' 'hand swipe right' 'pinch in' 'pinch out'
# 'thumb double tap' 'grab' 'ungrab' 'page flip' 'peace' 'metal']

Current list of datasets:

• WaveGlove-single (waveglove_single.h5)
• WaveGlove-multi (waveglove_multi.h5)
• uWave (uwave.h5)
• OPPORTUNITY (opportunity.h5)
• PAMAP2 (pamap2.h5)
• SKODA (skoda.h5)
• MHEALTH (non overlapping windows) (mhealth.h5)
• Six datasets with all four predefined train/test folds
  as preprocessed by Jordao et al. originally in WearableSensorData
  (FNOW, LOSO, LOTO and SNOW prefixed .h5 files)

A dataset of 12-lead ECGs with annotations. The dataset contains 345 779 exams from 233 770 patients. It was obtained through stratified sampling from the CODE dataset ( 15% of the patients). The data was collected by the Telehealth Network of Minas Gerais in the period between 2010 and 2016.

This repository contains the files `exams.csv` and the files `exams_part{i}.zip` for i = 0, 1, 2, ... 17.

• "exams.csv": is a comma-separated values (csv) file containing the columns
  • "exam_id": id used for identifying the exam;
  • "age": patient age in years at the moment of the exam;
  • "is_male": true if the patient is male;
  • "nn_predicted_age": age predicted by a neural network to the patient. As described in the paper "Deep neural network estimated electrocardiographic-age as a mortality predictor" bellow.
  • "1dAVb": Whether or not the patient has 1st degree AV block;
  • "RBBB": Whether or not the patient has right bundle branch block;
  • "LBBB": Whether or not the patient has left bundle branch block;
  • "SB": Whether or not the patient has sinus bradycardia;
  • "AF": Whether or not the patient has atrial fibrillation;
  • "ST": Whether or not the patient has sinus tachycardia;
  • "patient_id": id used for identifying the patient;
  • "normal_ecg": True if automatic annotation system say it is a normal ECG;
  • "death": true if the patient dies in the follow-up time. This data is available only in the first exam of the patient. Other exams will have this as an empty field;
  • "timey": if the patient dies it is the time to the death of the patient. If not, it is the follow-up time. This data is available only in the first exam of the patient. Other exams will have this as an empty field;
  • "trace_file": identify in which hdf5 file the file corresponding to this patient is located.
• "exams_part{i}.hdf5": The HDF5 file containing two datasets named `tracings` and other named `exam_id`. The `exam_id` is a tensor of dimension `(N,)` containing the exam id (the same as in the csv file) and the dataset `tracings` is a `(N, 4096, 12)` tensor containing the ECG tracings in the same order. The first dimension corresponds to the different exams; the second dimension corresponds to the 4096 signal samples; the third dimension to the 12 different leads of the ECG exams in the following order: `{DI, DII, DIII, AVR, AVL, AVF, V1, V2, V3, V4, V5, V6}`. The signals are sampled at 400 Hz. Some signals originally have a duration of 10 seconds (10 * 400 = 4000 samples) and others of 7 seconds (7 * 400 = 2800 samples). In order to make them all have the same size (4096 samples), we fill them with zeros on both sizes. For instance, for a 7 seconds ECG signal with 2800 samples we include 648 samples at the beginning and 648 samples at the end, yielding 4096 samples that are then saved in the hdf5 dataset.

  In python, one can read this file using h5py.
  ```python
  import h5py

  f = h5py.File(path_to_file, 'r')
  # Get ids
  traces_ids = np.array(self.f['id_exam'])
  x = f['signal']
  ```
  The `signal` dataset is too large to fit in memory, so don't convert it to a numpy array all at once.
  It is possible to access a chunk of it using: ``x[start:end, :, :]``.

The CODE dataset was collected by the Telehealth Network of Minas Gerais (TNMG) in the period between 2010 and 2016. TNMG is a public telehealth system assisting 811 out of the 853 municipalities in the state of Minas Gerais, Brazil. The dataset is described

Ribeiro, Antônio H., Manoel Horta Ribeiro, Gabriela M. M. Paixão, Derick M. Oliveira, Paulo R. Gomes, Jéssica A. Canazart, Milton P. S. Ferreira, et al. “Automatic Diagnosis of the 12-Lead ECG Using a Deep Neural Network.” Nature Communications 11, no. 1 (2020): 1760. https://doi.org/10.1038/s41467-020-15432-4

The CODE 15% dataset is obtained from stratified sampling from the CODE dataset. This subset of the code dataset is described in and used for assessing model performance:
"Deep neural network estimated electrocardiographic-age as a mortality predictor"
Emilly M Lima, Antônio H Ribeiro, Gabriela MM Paixão, Manoel Horta Ribeiro, Marcelo M Pinto Filho, Paulo R Gomes, Derick M Oliveira, Ester C Sabino, Bruce B Duncan, Luana Giatti, Sandhi M Barreto, Wagner Meira Jr, Thomas B Schön, Antonio Luiz P Ribeiro. MedRXiv (2021) https://www.doi.org/10.1101/2021.02.19.21251232

The companion code for reproducing the experiments in the two papers described above can be found, respectively, in:
- https://github.com/antonior92/automatic-ecg-diagnosis; and in,
- https://github.com/antonior92/ecg-age-prediction.

Note about authorship: Antônio H. Ribeiro, Emilly M. Lima and Gabriela M.M. Paixão contributed equally to this work.

Using this dataset

This dataset is available for re-distribution and re-use (see license) under the following citation:

Mieites Alonso, V., Anichini, G., Qi, J., O'Neill, K., Conde, O. M., & Elson, D. (2024). PoLambRimetry dataset: Multispectral Mueller matrices of lamb brain [Data set]. Zenodo. https://doi.org/10.5281/zenodo.11127947

Dataset description

This dataset contains Multispectral Mueller matrices of lamb brain. A total of six fresh brain specimens were imaged, mainly in lateral and medial views, but also in sections. The wavelengths used are 450, 500, 550, 590, 650, and 680 nm. The dataset was generated using Python and contains a total of twenty matrices, following this folder structure:

Specimen (1 to 6)

View: right or left hemispheres; cerebellum hemispheres; medial or lateral view; sections; frontal basal ganglia (bg) sections; pineal region; brain stem sections.

Data in hdf5 (data.h5) format filled with Python objects

M: Mueller matrix. Dimensions: (6, 4, 4, 604, 642) corresponding to (wavelength, matrix row, matrix column, pixels row, pixels column). Python's numpy.array followed filled with numpy.float64.

ref_img: Reference grayscale image (at 450 nm). Dimensions: (604, 642) corresponding to (pixels row, pixels column). Python's numpy.array followed filled with numpy.float64.

roi: Region of interest. Its values are 1 inside the sample and 0 in the background. Dimensions: (604, 642) corresponding to (pixels row, pixels column). Python's numpy.array followed filled with numpy.int32.

labels: Labelled areas. There are 14 different white matter and gray matter structures. Dimensions: (604, 642) corresponding to (pixels row, pixels column).

wvls: Wavelengths in descending order. Dimensions: (6) corresponding to (wavelengths).

Figure representing the data inside data.h5 (data.png).

labels.csv: CSV file containing the legend for the labels. WM and GM stand for white matter and gray matter, respectivelly.

This dataset was used in a manuscript currently under peer review (May 2024). Upon publication, the embargo will be removed and we will update the information to provide a more detailed presentation of the dataset.