diff --git a/marimbabot_audio/script/2023-10-16-15-20-18.bag b/marimbabot_audio/script/2023-10-16-15-20-18.bag new file mode 100644 index 00000000..64e1f9a8 Binary files /dev/null and b/marimbabot_audio/script/2023-10-16-15-20-18.bag differ diff --git a/marimbabot_audio/script/MIR_eval.ipynb b/marimbabot_audio/script/MIR_eval.ipynb new file mode 100644 index 00000000..01228e5e --- /dev/null +++ b/marimbabot_audio/script/MIR_eval.ipynb @@ -0,0 +1,641 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import struct\n", + "from functools import reduce\n", + "from dtw import *\n", + "import crepe\n", + "import rosbag\n", + "import librosa\n", + "import numpy as np\n", + "import pretty_midi\n", + "import rospy" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [], + "source": [ + "def hz_to_note(hz):\n", + "\treturn pretty_midi.note_number_to_name(pretty_midi.hz_to_note_number(hz))\n", + "\n", + "def note_to_pm_id(note_name):\n", + "\treturn pretty_midi.note_name_to_number(note_name)\n", + "\n", + "def pm_id_to_note(pm_id):\n", + "\treturn pretty_midi.note_number_to_name(pm_id)\n", + "\n", + "def note_to_hz(note):\n", + "\treturn pretty_midi.note_number_to_hz(pretty_midi.note_name_to_number(note))" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [], + "source": [ + "class OnsetDetection:\n", + "\tdef __init__(self):\n", + "\t\tself.first_input = True\n", + "\t\tself.notes = []\n", + "\t\t# other parameters\n", + "\t\tself.last_seq_id = 0\n", + "\n", + "\t\tself.init_instrument_config()\n", + "\t\tself.init_audio_config()\n", + "\t\tself.init_detection_config()\n", + "\n", + "\t\t# the buffer to read audio raw data from ros topic\n", + "\t\tself.buffer = np.array([0.0] * self.sr, dtype=float)\n", + "\n", + "\tdef init_instrument_config(self):\n", + "\t\t\"\"\"\n", + "\t\t\tThe configuration of the instrument.\n", + "\n", + "\t\t\tAnd some examples of the configuration of different instruments:\n", + "\t\t\t# harp\n", + "\t\t\tself.fmin_note = \"C4\"\n", + "\t\t\tself.fmax_note = \"C6\"\n", + "\t\t\tself.semitones = 62\n", + "\n", + "\t\t\t# guzheng\n", + "\t\t\tself.fmin_note = \"C2\"\n", + "\t\t\tself.fmax_note = \"C8\"\n", + "\t\t\tself.semitones = 84\n", + "\t\t\"\"\"\n", + "\n", + "\t\t# marimba\n", + "\t\tself.fmin_note = \"C4\" # C4 pm_id=60\n", + "\t\tself.fmin_note_id = note_to_pm_id(self.fmin_note)\n", + "\t\tself.fmax_note = \"C7\" # C7 pm_id=96\n", + "\t\tself.fmax_note_id = note_to_pm_id(self.fmax_note)\n", + "\t\tself.semitones = 36 + 24 # 60 36 for 4-6 octives, 24 for overtones for two octives\n", + "\n", + "\t\t# convert the western notation to the corresponding frequency\n", + "\t\tself.fmin = note_to_hz(self.fmin_note)\n", + "\t\tself.fmax = note_to_hz(self.fmax_note)\n", + "\t\trospy.logdebug(\"Instrument configuration initialized.\")\n", + "\n", + "\tdef init_audio_config(self):\n", + "\t\t\"\"\"\n", + "\t\t\tThe configuration of the audio signal\n", + "\t\t\"\"\"\n", + "\t\tself.sr = 44100\n", + "\t\tself.hop_length = 512 # each hop equal to one pixel in spectrum\n", + "\t\tself.pixels_per_sec = self.sr / self.hop_length # careful, it is float for further precise calculation.\n", + "\t\trospy.logdebug(f\"Audio configuration initialized.\")\n", + "\n", + "\tdef init_detection_config(self):\n", + "\t\t\"\"\"\n", + "\t\t\tconfidence threshold for note classification(crepe)\n", + "\t\t\"\"\"\n", + "\t\t# For onset detection\n", + "\t\tself.window_t = 1\n", + "\t\tself.window_overlap_t = 0.5\n", + "\t\tself.window_num = int(self.sr * self.window_t)\n", + "\t\tself.window_overlap_num = int(self.sr * self.window_overlap_t)\n", + "\t\tself.confidence_threshold = 0.7\n", + "\t\tself.amplitude_ref = 10.0\n", + "\t\tself.windows_for_classification = 0.1 # using 0.1 sec data after onset time for note classification\n", + "\t\t# preload model to not block the callback on first message\n", + "\t\t# capacities: 'tiny', 'small', 'medium', 'large', 'full'\n", + "\t\tself.crepe_model = \"full\" # choose the crepe model type for music note classification\n", + "\t\trospy.logdebug(f\"Loading crepe {self.crepe_model}-model...\")\n", + "\t\tcrepe.core.build_and_load_model(self.crepe_model)\n", + "\t\trospy.logdebug(f\"Crepe {self.crepe_model}-model loaded.\")\n", + "\t\trospy.logdebug(\"Detection configuration initialized.\")\n", + "\t\tself.delta = 1.5\n", + "\n", + "\tdef reset(self):\n", + "\t\t# audio buffer\n", + "\t\tself.buffer_time = None\n", + "\t\tself.buffer = np.array([], dtype=float)\n", + "\n", + "\tdef process_ros_bag(self, path_bag):\n", + "\t\tbag = rosbag.Bag(path_bag, 'r')\n", + "\t\tfor topic, msg, t in bag.read_messages(topics=['/audio_node/audio_stamped']):\n", + "\t\t\t# the way to decode the data from ros topic\n", + "\t\t\tmsg_data = np.array(struct.unpack(f\"{int(len(msg.audio.data) / 2)}h\", bytes(msg.audio.data)), dtype=float)\n", + "\t\t\tself.buffer = np.concatenate([\n", + "\t\t\t\tself.buffer,\n", + "\t\t\t\tmsg_data\n", + "\t\t\t])\n", + "\t\t\t# make sure buffer is full, which is 1 sec new data and 1 sec old data. aka. 1 sec per update of cqt.\n", + "\t\t\t# aggregate buffer until window+2*overlaps are full, like [0.5 Sec Overlap | 1 Sec window | 0.5 Sec Overlap]\n", + "\t\t\tif self.buffer.shape[0] >= self.window_num + 2 * self.window_overlap_num:\n", + "\t\t\t\tself.audio_process()\n", + "\t\t\t\tself.buffer = self.buffer[self.window_num:]\n", + "\t\tbag.close()\n", + "\t\treturn self.notes\n", + "\n", + "\n", + "\t# the most important function for signal processing logic\n", + "\t# 0.5+ sec delay for detection, detect for each 1 sec.\n", + "\tdef audio_process(self):\n", + "\t\tonsets_cqt_time_list = self.onset_detection()\n", + "\t\t# filter out the onset in the overlap windows, to keep the long tail inside\n", + "\t\t# the whole windows include 0.5 sec overlap at both end, the target windows is only 1 sec at the middle.\n", + "\t\tdef in_window(o):\n", + "\t\t\t# only detect the onset inside the target windows, to make sure the long tail can be included.\n", + "\t\t\treturn (o >= self.window_overlap_t and o < self.window_overlap_t + self.window_t)\n", + "\n", + "\t\tonsets_in_windows = [o for o in onsets_cqt_time_list if in_window(o)]\n", + "\n", + "\t\t# since the onset are extracted, then we need to pass them through the classification model to get note label.\n", + "\t\twinners_raw_idx = []\n", + "\t\twinner_onsets = []\n", + "\t\tdurations = []\n", + "\t\tdefault_duration = 0.5\n", + "\t\t# publish events and plot visualization\n", + "\t\tfor onset in onsets_in_windows:\n", + "\t\t\tfundamental_frequency, confidence, winner_raw_idx, winner_pm_idx = self.onset_classification(onset)\n", + "\t\t\tif winner_raw_idx is not None:\n", + "\t\t\t\t# find the y-position of onset in spectrum\n", + "\t\t\t\twinners_raw_idx.append(winner_raw_idx) # ys\n", + "\t\t\t\twinner_onsets.append(onset) # xs\n", + "\t\t\t\tdurations.append(default_duration)\n", + "\n", + "\t\t\t\tnote = hz_to_note(fundamental_frequency)\n", + "\t\t\t\tself.notes.append(note)\n", + "\t\t\t\trospy.logdebug(\n", + "\t\t\t\t\tf\"Onset detection\"\n", + "\t\t\t\t\tf\"[note:{note}, \"\n", + "\t\t\t\t\tf\"confidence:{confidence:.4f}]\"\n", + "\t\t\t\t)\n", + "\n", + "\tdef onset_detection(self,pre_max=5,post_max=2,pre_avg=5,post_avg=2,wait=10):\n", + "\t\t\"\"\"\n", + "\t\t\tconstant q transform with 60 half-tones from C4,\n", + "\t\t\tin theory we only need notes from C4-C7, but in practice tuning\n", + "\t\t\tis often too low and harmonics are needed above C6,\n", + "\t\t\ttherefore we use 60 semitones include 2 octaves overtone.\n", + "\t\t\"\"\"\n", + "\t\tcqt = self.cqt() # cqt ndarrary (60,173)\n", + "\t\tonset_env_cqt = librosa.onset.onset_strength(sr=self.sr, S=librosa.amplitude_to_db(cqt, ref=self.amplitude_ref))\n", + "\t\t# detect when the onset(peak) happened within 2 sec cqt with shape (60,173)\n", + "\t\t'''\n", + "\t\tA sample n is selected as an peak if the corresponding x[n] fulfills the following three conditions:\n", + "\t\t\t- x[n] == max(x[n - pre_max:n + post_max]) # the maximum in the neighborhood\n", + "\t\t\t- x[n] >= mean(x[n - pre_avg:n + post_avg]) + delta # the value is above local mean\n", + "\t\t\t- n - previous_n > wait # enforce a distance of at least wait samples\n", + "\t\t'''\n", + "\t\tonsets_cqt_time_list = librosa.onset.onset_detect(\n", + "\t\t\ty=self.buffer,\n", + "\t\t\tsr=self.sr,\n", + "\t\t\thop_length=self.hop_length,\n", + "\t\t\tonset_envelope=onset_env_cqt,\n", + "\t\t\tunits=\"time\",\n", + "\t\t\tbacktrack=False,\n", + "\t\t\tnormalize=False,\n", + "\t\t\tpre_max=pre_max, # number of samples before n over which max is computed\n", + "\t\t\tpost_max=post_max, # number of samples after n over which max is computed\n", + "\t\t\tpre_avg=pre_avg, # number of samples before n over which mean is computed\n", + "\t\t\tpost_avg=post_avg, # number of samples after n over which mean is computed\n", + "\t\t\tdelta=self.delta, # threshold offset for mean\n", + "\t\t\twait=wait, # number of samples to wait after picking a peak\n", + "\t\t)\n", + "\t\treturn onsets_cqt_time_list\n", + "\n", + "\tdef setup_parms(self, amplitude_ref, delta):\n", + "\t\tself.amplitude_ref = amplitude_ref\n", + "\t\tself.delta = delta\n", + "\n", + "\tdef onset_classification(self, onset):\n", + "\t\t\"\"\"\n", + "\t\t\tinput: onset, a float value from 0 to 1, denote the percentage position of 1 sec\n", + "\t\t\toutput:\n", + "\t\t\t\t- winner_freq: the freq of the winner signal\n", + "\t\t\t\t- max(buckets[winner]): the confidence\n", + "\t\t\t\t- winner_idx_in_spec: the idx in spec along y-axis\n", + "\t\t\t\t- winner_pm_idx: the note id in the pretty_midi\n", + "\t\t\"\"\"\n", + "\t\t# using 0.1 sec windows data for classification\n", + "\t\tprediction_averaging_window = (\n", + "\t\t\t\tself.windows_for_classification * self.sr\n", + "\t\t)\n", + "\t\t# extract the data from onset time until 0.1 sec later\n", + "\t\texcerpt = self.buffer[int(onset * self.sr):int(onset * self.sr + prediction_averaging_window)]\n", + "\t\t# neuron nets for onset classification\n", + "\t\ttime, freq, confidence, _ = crepe.predict(\n", + "\t\t\texcerpt,\n", + "\t\t\tself.sr,\n", + "\t\t\tviterbi=True,\n", + "\t\t\tmodel_capacity=self.crepe_model,\n", + "\t\t\tverbose=0\n", + "\t\t)\n", + "\n", + "\t\t# filter out the onset, which confidence lower that threshold and note beyond range(C4-C7)\n", + "\t\tconfidence_mask = confidence > self.confidence_threshold\n", + "\t\tfreq_mask = (freq >= self.fmin) & (freq <= self.fmax)\n", + "\t\tmask = confidence_mask & freq_mask\n", + "\t\tfiltered_freq = freq[mask]\n", + "\t\tfiltered_confidence = confidence[mask]\n", + "\n", + "\t\tif len(filtered_freq) > 0:\n", + "\t\t\tbuckets = {}\n", + "\t\t\tfor f, c in zip(filtered_freq, filtered_confidence):\n", + "\t\t\t\tnote = hz_to_note(f)\n", + "\t\t\t\tbuckets[note] = buckets.get(note, []) + [c]\n", + "\n", + "\t\t\tdef add_confidence(note):\n", + "\t\t\t\treturn reduce(lambda x, y: x + y, buckets.get(note))\n", + "\n", + "\t\t\twinner = max(buckets, key=lambda a: add_confidence(a))\n", + "\t\t\twinner_freq = note_to_hz(winner)\n", + "\t\t\twinner_pm_idx = note_to_pm_id(winner)\n", + "\t\t\twinner_raw_idx_in_spec = note_to_pm_id(winner) - self.fmin_note_id\n", + "\t\t\tconfidence = max(buckets[winner])\n", + "\t\t\treturn winner_freq, confidence, winner_raw_idx_in_spec, winner_pm_idx\n", + "\t\telse:\n", + "\t\t\treturn 0.0, 0.0, None, None\n", + "\n", + "\tdef cqt(self):\n", + "\t\t\"\"\"\n", + "\t\t\tThe function for constant Q transform\n", + "\t\t\tinput: self.buffer\n", + "\t\t\toutput: ndarrary with shape (60,173) by default\n", + "\t\t\"\"\"\n", + "\t\tcqt = np.abs(\n", + "\t\t\tlibrosa.cqt(\n", + "\t\t\t\ty=self.buffer,\n", + "\t\t\t\tsr=self.sr,\n", + "\t\t\t\thop_length=self.hop_length,\n", + "\t\t\t\tfmin=self.fmin,\n", + "\t\t\t\tn_bins=self.semitones,\n", + "\t\t\t)\n", + "\t\t)\n", + "\t\treturn cqt" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [], + "source": [ + "gt = ['C4', 'C#4', 'D4', 'D#4', 'E4', 'F4', 'F#4', 'G4', 'G#4', 'A4','A#4', 'B4',\n", + " 'C5', 'C#5', 'D5', 'D#5', 'E5', 'F5', 'F#5', 'G5', 'G#5', 'A5', 'A#5', 'B5',\n", + " 'C6', 'C#6', 'D6', 'D#6', 'E6', 'F6', 'F#6', 'G6', 'G#6', 'A6', 'A#6', 'B6',\n", + " ]" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 7, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-10-17 12:46:25.126703: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-10-17 12:46:26.519213: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "2023-10-17 12:46:29.442739: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-10-17 12:46:29.518020: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1960] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n", + "Skipping registering GPU devices...\n" + ] + } + ], + "source": [ + "detector = OnsetDetection()\n", + "bag_path = \"./2023-10-16-15-20-18.bag\"\n", + "deltas = [0.3,0.5,0.7,1.0,1.5,2.0,2.5,3,3.5,4]\n", + "amplitude_refs = [0,5,10,15,20,25,30,35,40,45]\n" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 8, + "outputs": [], + "source": [ + "def precise(pr,gt):\n", + " pr = np.asarray(pr)\n", + " gt = np.asarray(gt)\n", + " hitted = np.intersect1d(pr,gt).shape[0]\n", + "\n", + " return hitted/max(pr.shape[0],gt.shape[0])" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/wang/workspace/marimbabot_ws/env_this/lib/python3.8/site-packages/setuptools_scm/_integration/setuptools.py:30: RuntimeWarning: \n", + "ERROR: setuptools==44.0.0 is used in combination with setuptools_scm>=8.x\n", + "\n", + "Your build configuration is incomplete and previously worked by accident!\n", + "setuptools_scm requires setuptools>=61\n", + "\n", + "Suggested workaround if applicable:\n", + " - migrating from the deprecated setup_requires mechanism to pep517/518\n", + " and using a pyproject.toml to declare build dependencies\n", + " which are reliably pre-installed before running the build tools\n", + "\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta:0.3, ampref:0: precise:0.4\n", + "delta:0.3, ampref:5: precise:0.4186046511627907\n", + "delta:0.3, ampref:10: precise:0.3763440860215054\n", + "delta:0.3, ampref:15: precise:0.37894736842105264\n", + "delta:0.3, ampref:20: precise:0.3956043956043956\n", + "delta:0.3, ampref:25: precise:0.4\n", + "delta:0.3, ampref:30: precise:0.39325842696629215\n", + "delta:0.3, ampref:35: precise:0.4044943820224719\n", + "delta:0.3, ampref:40: precise:0.4090909090909091\n", + "delta:0.3, ampref:45: precise:0.375\n", + "delta:0.5, ampref:0: precise:0.43373493975903615\n", + "delta:0.5, ampref:5: precise:0.4\n", + "delta:0.5, ampref:10: precise:0.42857142857142855\n", + "delta:0.5, ampref:15: precise:0.38461538461538464\n", + "delta:0.5, ampref:20: precise:0.4235294117647059\n", + "delta:0.5, ampref:25: precise:0.42857142857142855\n", + "delta:0.5, ampref:30: precise:0.4\n", + "delta:0.5, ampref:35: precise:0.41379310344827586\n", + "delta:0.5, ampref:40: precise:0.3870967741935484\n", + "delta:0.5, ampref:45: precise:0.41379310344827586\n", + "delta:0.7, ampref:0: precise:0.5\n", + "delta:0.7, ampref:5: precise:0.4430379746835443\n", + "delta:0.7, ampref:10: precise:0.4675324675324675\n", + "delta:0.7, ampref:15: precise:0.46153846153846156\n", + "delta:0.7, ampref:20: precise:0.43209876543209874\n", + "delta:0.7, ampref:25: precise:0.45\n", + "delta:0.7, ampref:30: precise:0.43902439024390244\n", + "delta:0.7, ampref:35: precise:0.43373493975903615\n", + "delta:0.7, ampref:40: precise:0.45\n", + "delta:0.7, ampref:45: precise:0.4069767441860465\n", + "delta:1.0, ampref:0: precise:0.48\n", + "delta:1.0, ampref:5: precise:0.5833333333333334\n", + "delta:1.0, ampref:10: precise:0.5070422535211268\n", + "delta:1.0, ampref:15: precise:0.5384615384615384\n", + "delta:1.0, ampref:20: precise:0.4794520547945205\n", + "delta:1.0, ampref:25: precise:0.4857142857142857\n", + "delta:1.0, ampref:30: precise:0.5396825396825397\n", + "delta:1.0, ampref:35: precise:0.5625\n", + "delta:1.0, ampref:40: precise:0.5645161290322581\n", + "delta:1.0, ampref:45: precise:0.5538461538461539\n", + "delta:1.5, ampref:0: precise:0.7608695652173914\n", + "delta:1.5, ampref:5: precise:0.7659574468085106\n", + "delta:1.5, ampref:10: precise:0.813953488372093\n", + "delta:1.5, ampref:15: precise:0.75\n", + "delta:1.5, ampref:20: precise:0.7446808510638298\n", + "delta:1.5, ampref:25: precise:0.782608695652174\n", + "delta:1.5, ampref:30: precise:0.7555555555555555\n", + "delta:1.5, ampref:35: precise:0.8181818181818182\n", + "delta:1.5, ampref:40: precise:0.8181818181818182\n", + "delta:1.5, ampref:45: precise:0.8095238095238095\n", + "delta:2.0, ampref:0: precise:0.9473684210526315\n", + "delta:2.0, ampref:5: precise:0.9230769230769231\n", + "delta:2.0, ampref:10: precise:1.0\n", + "delta:2.0, ampref:15: precise:0.9473684210526315\n", + "delta:2.0, ampref:20: precise:1.0\n", + "delta:2.0, ampref:25: precise:0.9473684210526315\n", + "delta:2.0, ampref:30: precise:0.972972972972973\n", + "delta:2.0, ampref:35: precise:0.9459459459459459\n", + "delta:2.0, ampref:40: precise:0.9459459459459459\n", + "delta:2.0, ampref:45: precise:0.972972972972973\n", + "delta:2.5, ampref:0: precise:0.972972972972973\n", + "delta:2.5, ampref:5: precise:1.0\n", + "delta:2.5, ampref:10: precise:1.0\n", + "delta:2.5, ampref:15: precise:1.0\n", + "delta:2.5, ampref:20: precise:1.0\n", + "delta:2.5, ampref:25: precise:1.0\n", + "delta:2.5, ampref:30: precise:1.0\n", + "delta:2.5, ampref:35: precise:1.0\n", + "delta:2.5, ampref:40: precise:1.0\n", + "delta:2.5, ampref:45: precise:0.972972972972973\n", + "delta:3, ampref:0: precise:0.9722222222222222\n", + "delta:3, ampref:5: precise:1.0\n", + "delta:3, ampref:10: precise:0.9722222222222222\n", + "delta:3, ampref:15: precise:1.0\n", + "delta:3, ampref:20: precise:1.0\n", + "delta:3, ampref:25: precise:1.0\n", + "delta:3, ampref:30: precise:1.0\n", + "delta:3, ampref:35: precise:1.0\n", + "delta:3, ampref:40: precise:1.0\n", + "delta:3, ampref:45: precise:0.9722222222222222\n", + "delta:3.5, ampref:0: precise:1.0\n", + "delta:3.5, ampref:5: precise:1.0\n", + "delta:3.5, ampref:10: precise:1.0\n", + "delta:3.5, ampref:15: precise:1.0\n", + "delta:3.5, ampref:20: precise:1.0\n", + "delta:3.5, ampref:25: precise:1.0\n", + "delta:3.5, ampref:30: precise:1.0\n", + "delta:3.5, ampref:35: precise:1.0\n", + "delta:3.5, ampref:40: precise:1.0\n", + "delta:3.5, ampref:45: precise:1.0\n", + "delta:4, ampref:0: precise:1.0\n", + "delta:4, ampref:5: precise:1.0\n", + "delta:4, ampref:10: precise:0.9722222222222222\n", + "delta:4, ampref:15: precise:1.0\n", + "delta:4, ampref:20: precise:1.0\n", + "delta:4, ampref:25: precise:1.0\n", + "delta:4, ampref:30: precise:1.0\n", + "delta:4, ampref:35: precise:1.0\n", + "delta:4, ampref:40: precise:1.0\n", + "delta:4, ampref:45: precise:1.0\n" + ] + } + ], + "source": [ + "scores_2d = []\n", + "for delta in deltas:\n", + " score_1d = []\n", + " for amplitude_ref in amplitude_refs:\n", + " detector.setup_parms(amplitude_ref=amplitude_ref,delta=delta)\n", + " pr = detector.process_ros_bag(bag_path)\n", + " detector.notes = []\n", + " score = precise(pr,gt)\n", + " print(f\"delta:{delta}, ampref:{amplitude_ref}: precise:{score}\")\n", + " score_1d.append(score)\n", + " scores_2d.append(score_1d)\n" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 11, + "outputs": [], + "source": [ + "scores_2d = np.asarray(scores_2d)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 23, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.asarray(deltas)\n", + "y = np.mean(scores_2d,axis=1)\n", + "plt.figure(figsize=(6,4))\n", + "plt.plot(x,y,'-')\n", + "plt.grid()\n", + "plt.ylabel(\"precision\")\n", + "plt.xlabel(\"delta: local mean threshold\")\n", + "plt.savefig(\"./delta.pdf\", format=\"pdf\", bbox_inches=\"tight\")\n", + "plt.show()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 24, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.asarray(amplitude_refs)\n", + "y = np.mean(scores_2d,axis=0)\n", + "plt.figure(figsize=(6,4))\n", + "plt.plot(x,y,'-')\n", + "plt.ylabel(\"precision\")\n", + "plt.xlabel(\"amplitude reference\")\n", + "plt.grid()\n", + "plt.savefig(\"./amp_ref.pdf\", format=\"pdf\", bbox_inches=\"tight\")\n", + "plt.show()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 13, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + } + ], + "metadata": { + "kernelspec": { + "name": "marimbabot", + "language": "python", + "display_name": "marimbabot_env" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file