{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Make a dataset from custom data formats\n", "If your data is readable by the GUI, you only need to convert annotations. You can then load both into the GUI and export to data and annotations for DAS.\n", "\n", "Three alternatives:\n", "\n", "### 1. Export your data as wav/npz and csv to a folder and make a dataset with the GUI\n", "`data` folder with `*.wav` or `npz` files files with the recording and matching `*_annotations.csv` files with the annotations (see format details [here]](/technical/data_formats))- recordings and annotations will be matched according to the file base name:\n", "```shell\n", "data\\\n", " file01.wav\n", " file01_annotations.csv\n", " another_file.wav\n", " another_file_annotations.csv\n", " yaf.wav\n", " yaf_annotations.csv\n", "```\n", "\n", "Simplest way - no need of having to deal with specific of the data structure required by DAS for training - simply hit _DAS/Make dataset for training_ and select the folder.\n", "\n", "### 2. Use notebook with custom loaders to directly read recordings and annotations\n", "Intermediate simplicity and flexibility) Folder with the data and annotations in a custom format - provide custom functions for loading audio data and annotations. This is illustrated in the next section.\n", "\n", "### 3. DIY dataset\n", "Complex, maximally flexible) Bring your own mappable (for experts): Generate the data structure yourself. The description of the [dataset structure](/technical/data_formats) has information on how to do that." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Use notebook with custom loaders to directly read recordings and annotations\n", "This notebook creates an annotated data set for training das from lists of filenames for the song recordings and associated annotations.\n", "\n", "This may look a bit complicated at first sight but only requires you to change two things in the next two cells:\n", "\n", "1. The functions for loading the data (song recordings) and the annotations need to be adapted to work with your data.\n", "2. Two lists with the names of data files (consumed by `load_data`) and the associated annotation files (consumed by `load_annotation`) need to be created.\n", "\n", "The notebook works with a small toy data set (with song recordings from the data provided with [Stern (2014)](https://www.janelia.org/lab/stern-lab/tools-reagents-data)) and with annotations produced by [Murthylab_FlySongSegmenter](https://github.com/murthylab/MurthyLab_FlySongSegmenter).\n", "\n", "__Note:__ For this tutorial to work, you first need to download some data and example models (266MB) from [here](https://www.dropbox.com/sh/wnj3389k8ei8i1c/AACy7apWxW87IS_fBjI8-7WDa?dl=0) and put the four folders in the `tutorials` folder.\n", "\n", "## Internals\n", "The dataset is created in two steps. \n", "\n", "First, the data and annotations for different recordings are combined in a large matrix. This works even with large datasets that don't fit in memory thanks to [zarr](https://zarr.readthedocs.io/en/stable/tutorial.html#storage-alternatives), which provides an interface for on-disk arrays. The annotations are converted from lists of event times to one-hot-encoded probability vectors, (0 for no event, 1 for a specified short duration (default is $\\pm$30 samples) surrounding the event).\n", "\n", "Second, the zarr dataset is converted to a directory hierarchy of numpy files (npy) using `das.npy_dir_save`. Numpy files allow extremely fast memory mapping, providing faster out-of-memory access than zarr during training. \n", "\n", "Code below closely follows the code used in the GUI - see the [source](https://github.com/janclemenslab/xarray-behave/blob/master/src/xarray_behave/gui/DAS.py) code." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import zarr\n", "import logging\n", "import das.npy_dir\n", "import das.make_dataset\n", "import das.annot\n", "from glob import glob\n", "import matplotlib.pyplot as plt\n", "import h5py\n", "import pandas as pd\n", "from typing import Tuple, Optional\n", "\n", "plt.style.use('ncb.mplstyle')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define custom audio and annotation loaders\n", "\n", "If your recordings and annotations are not in the format expected by the standard loaders used above (`scipy.io.wavefile.read` for the recordings, `pd.read_csv` with name/start_seconds/stop_seconds for annotations), or if it's hard to convert your data into these standard formats, you can provide your own loaders as long as they conform to the following interface:\n", "\n", "- _data loaders_: `samplerate, data = data_loader(filename)`, accepts a single string argument - the path to the data file and returns two things: the samplerate of the data and a numpy array with the recording data [time, channels]. Note: `scipy.io.wavefile.read` returns `[time,]` arrays - you need to add a new axis to make it 2d!\n", "- _annotation loaders_: `df = annotation_loader(filename)`, accepts a single string argument with the file path and returns a pandas DataFrame with these three columns: `name`, `start_seconds`, `stop_seconds` (see 1).\n", "\n", "Below, we read example data produced in matlab (D. Stern). The recording was exported and saved as a matlab struct - the audio data is found in `data`, the samplerate is not saved with the data. The annotations were produced by the [Murthylab_FlySongSegmenter](https://github.com/murthylab/MurthyLab_FlySongSegmenter) and the pulse times (in samples) and a mask indicating for each sample in the recording whether it was occupied by noise (0), a pulse train (1), or sine song (2) were exported saved as a struct - `annotations.mask`, `annotations.pulsesamples`.\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "tags": [] }, "outputs": [], "source": [ "\n", "def data_loader(filename: str, dataset: Optional[str] = None) -> Tuple[float, np.ndarray]:\n", " with h5py.File(filename, mode='r') as f: \n", " data = f['data'][:]\n", " samplerate = 10_000\n", " return samplerate, data\n", "\n", "def annotation_loader(filename: str) -> pd.DataFrame:\n", " samplerate = 10_000\n", " with h5py.File(filename, 'r') as f:\n", " # fss saves mask with sine=1, pulsetrains=2\n", " sine = (f['annotations']['mask'][0, :] == 2).astype(np.float)\n", " sine_onsets = np.where(np.diff(sine) == 1)[0] / samplerate\n", " sine_offsets = np.where(np.diff(sine) == -1)[0] / samplerate\n", " \n", " # fss saves pulse times in samples\n", " pulse_times = f['annotations']['pulsesamples'][0] / samplerate\n", "\n", " # make lists:\n", " names = []\n", " start_seconds = []\n", " stop_seconds = []\n", "\n", " for pulse_time in pulse_times:\n", " names.append('pulse')\n", " start_seconds.append(float(pulse_time))\n", " stop_seconds.append(float(pulse_time))\n", "\n", " for sine_onset, sine_offset in zip(sine_onsets, sine_offsets): \n", " names.append('sine')\n", " start_seconds.append(float(sine_onset))\n", " stop_seconds.append(float(sine_offset))\n", "\n", " event_times = das.annot.Events.from_lists(names, start_seconds, stop_seconds)\n", " df = event_times.to_df()\n", " return df\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Lists the names of data and annotation files\n", "Lists of `data_files` and associated `annotation_files` are consumed by `load_data` and `load_annotation`, respectively." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "data \"../data/PS_20130625155828_ch7_recording.mat\" with annotations in \"../data/PS_20130625155828_ch7_song.mat\".\n", "data \"../data/PS_20130625111709_ch10_recording.mat\" with annotations in \"../data/PS_20130625111709_ch10_song.mat\".\n", "data \"../data/PS_20130628144304_ch15_recording.mat\" with annotations in \"../data/PS_20130628144304_ch15_song.mat\".\n", "data \"../data/PS_20130625155828_ch11_recording.mat\" with annotations in \"../data/PS_20130625155828_ch11_song.mat\".\n" ] } ], "source": [ "# data_dir = '/Users/clemens10/Dropbox/code.py/DAS/tutorials/dat.mat/'\n", "data_dir = '../data/'\n", "files_data = glob(data_dir + '*_recording.mat') # list all data files\n", "files_annotation = [file.replace('_recording.mat', '_song.mat') for file in files_data] # generate the names of associated annotation files\n", "[print(f'data \"{d}\" with annotations in \"{a}\".') for d, a in zip(files_data, files_annotation)];" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Test loaders" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Audio data with samplerate 10000, shape (4100001, 1), and data type float32\n", "Annotations\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
namestart_secondsstop_seconds
0sine5.15395.3898
1sine127.9297128.8389
2sine171.8631172.0899
3sine178.0876178.2290
4sine181.9101182.4161
............
1956pulse404.4817404.4817
1957pulse404.5128404.5128
1958pulse404.5440404.5440
1959pulse404.5751404.5751
1960pulse404.6469404.6469
\n", "

1961 rows × 3 columns

\n", "
" ], "text/plain": [ " name start_seconds stop_seconds\n", "0 sine 5.1539 5.3898\n", "1 sine 127.9297 128.8389\n", "2 sine 171.8631 172.0899\n", "3 sine 178.0876 178.2290\n", "4 sine 181.9101 182.4161\n", "... ... ... ...\n", "1956 pulse 404.4817 404.4817\n", "1957 pulse 404.5128 404.5128\n", "1958 pulse 404.5440 404.5440\n", "1959 pulse 404.5751 404.5751\n", "1960 pulse 404.6469 404.6469\n", "\n", "[1961 rows x 3 columns]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "samplerate, data = data_loader(files_data[0])\n", "print(f\"Audio data with samplerate {samplerate}, shape {data.shape}, and data type {data.dtype}\")\n", "print('Annotations')\n", "df = annotation_loader(files_annotation[0])\n", "df" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "for file_data in files_data:\n", " samplerate, data = data_loader(file_data)\n", " with h5py.File(file_data + '.h5', 'w') as f:\n", " f['data'] = data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Parse annotation files to identify song types\n", "This will collect all unique values in `names` of the annotation files and infer their categories based on the equality of start_seconds and stop_seconds. Skip this step and define `class_names` and `class_categories` manually if you know the song types and their categories." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "../data/PS_20130625155828_ch7_song.mat\n", "../data/PS_20130625111709_ch10_song.mat\n", "../data/PS_20130628144304_ch15_song.mat\n", "../data/PS_20130625155828_ch11_song.mat\n", "found pulse of type event\n", "found sine of type segment\n" ] } ], "source": [ "# go through all annotation files and collect info on classes\n", "class_names = []\n", "class_categories = []\n", "for file_annotation in files_annotation:\n", " print(file_annotation)\n", " df = annotation_loader(file_annotation)\n", " event_times = das.annot.Events.from_df(df)\n", " class_names.extend(event_times.names)\n", " class_categories.extend(event_times.categories.values())\n", "\n", "class_names, first_indices = np.unique(class_names, return_index=True)\n", "class_categories = list(np.array(class_categories)[first_indices])\n", "class_names = list(class_names)\n", "\n", "for class_name, class_category in zip(class_names, class_categories):\n", " print(f'found {class_name} of type {class_category}')\n", "\n", "# Need to add a \"noise\" song type for when there is no song\n", "class_names.insert(0, 'noise')\n", "class_categories.insert(0, 'segment')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Split files into train/val/test sets\n", "Split the list of recordings into train/val/test files:\n", "- `train` is used for optimizing the parameters during model fitting\n", "- `val` is used during training to track model performance and save the current best model based on the performance on the validation data\n", "- `test` is used to evaluate the best model after training is done and fine tune inference" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Indices of test file(s): [3] \n", "indices of validation file(s): [2] \n", "indices of train files: [0 1]\n" ] } ], "source": [ "np.random.seed(1) # seed random number generator for reproducible splits\n", "test_idx, val_idx, train_idx = np.split(np.random.permutation(len(files_data)), (1, 2)) # this will split the recordings into one for testing, one for validation, and the remained for training \n", "print('Indices of test file(s):', test_idx, '\\nindices of validation file(s):', val_idx, '\\nindices of train files:', train_idx)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Initialize the data structure (store)\n", "The store will hold the audio data and the annotations in a format ready for training (see [here](/technical/data_formats) for details). The store also contains metadata which is important for training and inference:\n", "- samplerates of the data in Hz\n", "- description of the different classes (names, types (segment or events)) - largely used to post-process the output of the network after inference (e.g. detect event times from the probabilities produced by the network).\n", "\n", "We use zarr as a data structure because it provides in-memory as well as out-of-memory arrays with the same, dict-like interface (similar to h5py).\n", "\n", "Choose the zarr `store_type` based on the total size of your dataset:\n", "- If it fits in memory, use a `DictStore`, which will place the data and annotation arrays in memory. \n", "- For \"big data\", use a `DirectoryStore`, this will place the arrays in chunked files in a directory.\n", "\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "samplerate = 10_000 # this is the sample rate of your data and the pulse times\n", "store = das.make_dataset.init_store(\n", " nb_channels=1, # number of channels/microphones in the recording\n", " nb_classes=len(class_names), # number of classes to predict - [noise, pulse]\n", " make_single_class_datasets=True, # also make y_pulse and y_sine\n", " samplerate=samplerate, # make sure audio data and the annotations are all on the same sampling rate\n", " class_names=class_names,\n", " class_types=class_categories,\n", " store_type=zarr.DictStore, # use DirectoryStore for big data \n", " store_name='intermediate.zarr', # only used with DirectoryStore - this is the path to the directory created\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Load the individual data files\n" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Assembling data set:\n", " ../data/PS_20130625155828_ch7_recording.mat -> train set\n", " ../data/PS_20130625111709_ch10_recording.mat -> train set\n", " ../data/PS_20130628144304_ch15_recording.mat -> val set\n", " ../data/PS_20130625155828_ch11_recording.mat -> test set\n", "Got (8090002, 1), (4150001, 1), (4000001, 1) train/test/val samples.\n" ] } ], "source": [ "print(f\"Assembling data set:\")\n", "for idx, (data_file, annotation_file) in enumerate(zip(files_data, files_annotation)):\n", " # Determine whether file is test/val/train\n", " if idx in test_idx:\n", " target = 'test'\n", " elif idx in val_idx:\n", " target = 'val'\n", " elif idx in train_idx:\n", " target = 'train'\n", " else:\n", " continue\n", "\n", " print(f\" {data_file} -> {target} set\")\n", " fs, x = data_loader(data_file)\n", " nb_samples = x.shape[0]\n", "\n", " # load annotations\n", " df = annotation_loader(annotation_file)\n", " df = df.dropna()\n", "\n", " # make initial annotation matrix\n", " y = das.make_dataset.make_annotation_matrix(df, nb_samples, fs, class_names)\n", " \n", " # blur events\n", " for class_index, class_category in enumerate(class_categories):\n", " if class_category == 'event':\n", " y[:, class_index] = das.make_dataset.blur_events(y[:, class_index],\n", " event_std_seconds=.0016,\n", " samplerate=samplerate)\n", " \n", " # Append the recording (x) and the prediction target (y) to the data set\n", " store[target]['x'].append(x)\n", " store[target]['y'].append(das.make_dataset.normalize_probabilities(y))\n", "\n", " # Make prediction targets for individual song types\n", " for cnt, class_name in enumerate(class_names[1:]):\n", " store[target][f'y_{class_name}'].append(das.make_dataset.normalize_probabilities(y[:, [0, cnt+1]]))\n", "\n", "print(f\"Got {store['train']['x'].shape}, {store['val']['x'].shape}, {store['test']['x'].shape} train/test/val samples.\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Inspect the dataset\n", "Plot x/y values from the dataset to make sure everything is well aligned." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "class_names = store.attrs['class_names']\n", "for t0 in [45_000]: #range(0, 500_000, 10_000):\n", " t1 = t0 + 10_000\n", " plt.gcf().set_size_inches(20, 6)\n", " T = np.arange(t0, t1) / store.attrs['samplerate_x_Hz']\n", " plt.subplot(211)\n", " plt.plot(T, store['train']['x'][t0:t1], 'k')\n", " plt.xticks([])\n", " plt.ylabel('microphone voltage')\n", " plt.xlim(min(T), max(T)) \n", "\n", " plt.subplot(413)\n", " plt.imshow(store['train']['y'][t0:t1, :].astype(np.float).T, cmap='Greys')\n", " plt.yticks(range(len(class_names)), labels=class_names)\n", " plt.xticks([])\n", "\n", " plt.subplot(414) \n", " plt.plot(T, store['train']['y'][t0:t1, 1:])\n", " plt.xlabel('time [seconds]')\n", " plt.xlim(min(T), max(T))\n", " plt.legend(class_names[1:])\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Save as npy_dir\n", "Once all data and annotation files have been appended to the store, save the data as an `npy_dir` store - a directory hierarchy that replicates the nested dictionary structure of the zarr store. For instance, the data set at `root['train']['x']` (the audio data for training) will be stored as `store_name/train/x.npy`. We use these npy files rather than the zarr store because access is faster. Saving is done by `das.npy_dir_save`. The directory structure is mapped back to a nested dictionary via `das.npy_dir.load`. If you used the `DirectoryStore` during assembly, you can delete the `*.zarr` directory after that final step." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# Save the zarr store as a hierarchy of npy files\n", "store_folder = 'tutorial_dataset.npy'\n", "logging.info(f' Saving to {store_folder}.')\n", "das.npy_dir.save(store_folder, store)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can now train using the [GUI](/tutorials_gui/train), or a [script](/tutorials/train), or the [command line](/tutorials/train)." ] } ], "metadata": { "file_extension": ".py", "kernel_info": { "name": "python3" }, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.11" }, "mimetype": "text/x-python", "name": "python", "npconvert_exporter": "python", "nteract": { "version": "0.15.0" }, "pygments_lexer": "ipython3", "version": 3 }, "nbformat": 4, "nbformat_minor": 4 }