Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,45 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/asap_annotations.json filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Balakirev/Islamey/Gorucan03.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Balakirev/Islamey/Verbaite04.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Beethoven/Piano_Sonatas/21-1_no_repeat/Dulu01.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Beethoven/Piano_Sonatas/21-1_no_repeat/MorozovS01.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Beethoven/Piano_Sonatas/21-1_no_repeat/Seo01.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Beethoven/Piano_Sonatas/21-1_no_repeat/Sychev01.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Beethoven/Piano_Sonatas/23-1/Ladid01.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Beethoven/Piano_Sonatas/23-1/Na01.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Beethoven/Piano_Sonatas/29-3/ChowK04.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Chopin/Ballades/4/Lim03.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Chopin/Ballades/4/ZhangX02.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Ballade_2/Sham05.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Mephisto_Waltz/Duepree10.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Mephisto_Waltz/Giltburg03.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Mephisto_Waltz/JIA08.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Mephisto_Waltz/Tysman07M.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Mephisto_Waltz/WangV03.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Sonata/Dulu07M.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Sonata/Dvorkine03.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Sonata/Gasanov06M.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Sonata/GiacomelliN11M.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Sonata/Huang01.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Sonata/midi_score.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Sonata/Yeletskiy05M.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Liszt/Sonata/Zuber07M.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Schubert/Impromptu_op142/1/Kleisen02.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Schubert/Impromptu_op142/1/Lisiecki10M.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Schubert/Impromptu_op142/3/Cui04.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Schubert/Impromptu_op142/3/Lin05.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Schubert/Impromptu_op142/3/Tuncali02.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Schubert/Wanderer_fantasie/Kolessova02.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Schubert/Wanderer_fantasie/Larionova05M.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Schubert/Wanderer_fantasie/midi_score.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Schubert/Wanderer_fantasie/SunY10M.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Schumann/Toccata_repeat/WangY07M.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Schumann/Toccata_repeat/Zhdanov06.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Scriabin/Sonatas/5/FaB05M.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Scriabin/Sonatas/5/Na03.mid filter=lfs diff=lfs merge=lfs -text
+asap-dataset-master/Scriabin/Sonatas/5/Yeletskiy02.mid filter=lfs diff=lfs merge=lfs -text
+data/output.txt filter=lfs diff=lfs merge=lfs -text
+data/train.txt filter=lfs diff=lfs merge=lfs -text

LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2023] [John Thickstun]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,3 +1,106 @@
----
-license: mit
----
+# Anticipatory Music Transformer
+
+Implementation of the methods described in [Anticipatory Music Transformer](https://arxiv.org/abs/2306.08620).
+
+by [__John Thickstun__](https://johnthickstun.com/), [__David Hall__](http://dlwh.org/), [__Chris Donahue__](https://chrisdonahue.com/), and [__Percy Liang__](https://cs.stanford.edu/~pliang/).
+
+-------------------------------------------------------------------------------------
+
+This repository provides the code for creating anticipatory training datasets, and for sampling from models trained with anticipation. It does _not_ contain code for training these models: you may use the preprocessed datasets constructed here as input to your favorite codebase for training autoregressive transformer models. We used the [Levanter](https://github.com/stanford-crfm/levanter) codebase to train models, and include instructions [here](train) for training an Anticipatory Music Transformer with Levanter.
+
+For additional detail about this work, see the [paper](https://arxiv.org/abs/2306.08620). You may also be interested in this [blog post](https://crfm.stanford.edu/2023/06/16/anticipatory-music-transformer.html).
+
+Pretrained models are hosted by the Center for Research on Foundation Models (CRFM) on the [HuggingFace Hub](https://huggingface.co/stanford-crfm). 
+
+This project is licensed under the terms of the Apache License, Version 2.0.
+
+Begin by installing the anticipation package (from the root of this repository).
+
+```
+pip install .
+```
+
+## Software Dependencies
+
+Run the following command to install dependencies.
+
+```
+pip install -r requirements.txt
+```
+
+## Generating Music with an Anticipatory Music Transformer
+
+See the [Colab](https://colab.research.google.com/drive/1HCQDtGFwROpHRqcmZbV0byqbxDb74YGu?usp=sharing) notebook for interactive examples of music generation using the Anticipatory Music Transformer.
+
+Load a pretrained model using the HuggingFace Transformers package, e.g.:
+
+```
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained('stanford-crfm/music-medium-800k').cuda()
+```
+
+Sample from this model using the custom `generate` function implementated by the anticipation package. You can convert generated event tokens to midi using the `events_to_midi` function:
+
+```
+from anticipation.sample import generate
+from anticipation.convert import events_to_midi
+
+length = 10 # time in seconds
+events = generate(model, start_time=0, end_time=length, top_p=.98)
+mid = events_to_midi(events)
+mid.save('generated.mid')
+```
+
+Load your own MIDI and tokenize it using the `midi_to_events` function.
+
+```
+from anticipation.convert import midi_to_events
+
+events = midi_to_events('examples/strawberry.mid')
+```
+
+To isolate a segment of a longer stream of events, use the `ops` library to clip the stream and translate the clipped segment to time zero. To isolate a melodic line, use `extract_instruments`:
+
+```
+from anticipation import ops
+from anticipation.tokenize import extract_instruments
+
+events = ops.clip(events, 41, 41+20)
+events = ops.translate(events, -ops.min_time(events, seconds=False))
+
+events, melody = extract_instruments(events, [53])
+```
+
+To generate an accompaniment to an isolated melody, call the `generate` function using the melody as control inputs. Recombine the generated accompaniment with the melody controls using `ops.combine`:
+
+```
+history = ops.clip(events, 0, 5, clip_duration=False)
+accompaniment = generate(model, 5, 20, inputs=history, controls=melody, top_p=.98)
+completed_events = ops.combine(accompaniment, melody)
+mid = events_to_midi(completed_events)
+mid.save('generated.mid')
+```
+
+See the [Colab](https://colab.research.google.com/drive/1HCQDtGFwROpHRqcmZbV0byqbxDb74YGu?usp=sharing) notebook for additional examples of infilling control using the Anticipatory Music Transformer.
+
+## Training an Anticipatory Music Transformer
+
+See the [train](train) directory for instructions on preprocessing the Lakh MIDI dataset and using [Levanter](https://github.com/stanford-crfm/levanter) to train an Anticipatory Music Transformer.
+
+## Reproducing the Human Evaluation Procedure
+
+See the [humaneval](humaneval) directory for instructions on reproducing data used for the human evaluation results reported in the paper.
+
+-------------------------------------------------------------------------------------
+
+To reference this work, please cite
+
+```bib
+@article{thickstun2023anticipatory,
+  title={Anticipatory Music Transformer},
+  author={Thickstun, John and Hall, David and Donahue, Chris and Liang, Percy},
+  journal={arXiv preprint arXiv:2306.08620},
+  year={2023}
+}
+```

alignment.py

@@ -0,0 +1,235 @@
+import numpy as np
+import scipy.interpolate
+from anticipation.convert import midi_to_events
+from anticipation.config import *
+from anticipation.vocab import *
+from itertools import combinations
+
+def load_annotation_file(file_path):
+    annotations = []
+    
+    with open(file_path, 'r') as f:
+        for line in f:
+            parts = line.strip().split('\t')
+            if len(parts) >= 3:
+                timestamp = float(parts[0])
+                annotation = parts[2]
+                annotations.append((timestamp, annotation))
+    
+    return annotations
+
+def compare_annotations(file1_path, file2_path, interpolate=True):
+    """
+    Creates a mapping between downbeat and beat times in two annotation files.
+    Inputs are timestamps in the first file, outputs are timestamps in the second file
+    """
+
+    annotations1 = load_annotation_file(file1_path)
+    annotations2 = load_annotation_file(file2_path)
+
+    min_length = min(len(annotations1), len(annotations2))
+    if len(annotations1) != len(annotations2):
+        shorter_file = file1_path if len(annotations1) == min_length else file2_path
+        print(f'Number of annotations in {file1_path} and {file2_path} do not match.')
+        print(f"Proceeding with the first {min_length} annotations from {shorter_file}.")
+
+    
+    data = []
+
+    for i in range(min_length):   
+        data.append((annotations1[i][0], annotations2[i][0]))
+
+    x,y = list(zip(*data))
+
+    if interpolate:
+        map = scipy.interpolate.interp1d(x, y)
+        
+        return map
+
+    else:
+        return x,y
+    
+def power_set(lst, min_length=2, max_length=6):
+    result = []
+    # Only iterate from min_length to max_length (inclusive)
+    for i in range(min_length, min(max_length + 1, len(lst) + 1)):
+        result.extend(combinations(lst, i))
+    return result
+    
+def align_tokens(file1, file2, file3, file4, skip_Nones=True):
+    # turn midi into events, without quantizing so we can get 16 digits of precision in arrival time
+    perf = midi_to_events(file1, quantize=False)
+    score = midi_to_events(file2, quantize=False)
+
+    p_beats, s_beats = compare_annotations(file3,file4,interpolate=False)
+    s_beats = np.array(s_beats)
+    p_beats = np.array(p_beats)
+    map = compare_annotations(file3, file4)
+
+    # create tuples, scaling arrival time back to seconds, which is the unit the annotation mapping uses
+    p_tuples = [[perf[3*i]/TIME_RESOLUTION, perf[3*i+1] - DUR_OFFSET, perf[3*i+2] - NOTE_OFFSET] for i in range(int(len(perf)/3))]
+    s_tuples = [[score[3*i]/TIME_RESOLUTION, score[3*i+1] - DUR_OFFSET, score[3*i+2] - NOTE_OFFSET] for i in range(int(len(score)/3))]
+    p_times = [tup[0] for tup in p_tuples]
+    s_times = [tup[0] for tup in s_tuples]
+
+    tol = 1e-4
+
+    # match score notes with corresponding beats in annotation file
+    s_tuples_b = []
+    assigned = []
+
+    for tup in s_tuples:
+        mask = np.abs(tup[0] - s_beats) <= tol
+        if sum(mask):
+            beat = list(np.where(mask)[0])[0]
+            s_tuples_b.append((tup[0], tup[1], tup[2], beat))
+            assigned.append(beat)        
+        else:
+            s_tuples_b.append(tup)
+
+    for i in range(len(s_beats)):
+        if i not in assigned:
+            print(f'could not find notes in score associated with beat {i}')
+
+    # match perf notes with corresponding beats in annotation file
+    p_tuples_b = []
+    assigned = []
+
+    for tup in p_tuples:
+        mask = np.abs(tup[0] - p_beats) <= tol
+        if sum(mask):
+            beat = list(np.where(mask)[0])[0]
+            p_tuples_b.append((tup[0], tup[1], tup[2], beat))
+            assigned.append(beat)
+        else:
+            p_tuples_b.append(tup)
+
+    for j in [i for i in range(len(p_beats)) if i not in assigned]:
+        beat = p_beats[j]
+
+        candidates = [tup[0] for tup in p_tuples_b if len(tup)==3 and abs(tup[0]-beat)<=0.5]
+
+        success = False
+        for subset in power_set(candidates):
+            if np.abs(np.average(subset) - beat) <= tol:
+                for time in subset:
+                    k = p_times.index(time)
+                    p_tuples_b[k] = (p_tuples_b[k][0], p_tuples_b[k][1], p_tuples_b[k][2], j)
+                success = True
+                # print(f'at beat {j} succeeded in finding notes at times {subset} with average time {np.average(subset)} close to {beat}')
+                break
+        if not success:
+            print(f'could not find notes in perf associated with beat {j}')
+
+    # match score and perf notes that occurred on the same beats, then between 
+    # (almost all correctly) matched beats, we want to use the map to match off-beat notes
+    # outside of the mapping range and domain, just match notes with the same pitch
+    matched_tuples = []
+
+    s_tuples_b_copy = s_tuples_b.copy()
+
+    p_min = map.x.min()
+    p_max = map.x.max()
+    s_min = map.y.min()
+    s_max = map.y.max()
+
+    for i, p_tuple in enumerate(p_tuples_b):
+        for j, s_tuple in enumerate(s_tuples_b_copy):
+
+            p_time, p_note = p_tuple[0], p_tuple[2]
+            s_time, s_note = s_tuple[0], s_tuple[2] 
+
+            k = s_tuples_b.index(s_tuple)
+
+            if len(p_tuple) == 4 and len(s_tuple) == 4 and p_tuple[2:] == s_tuple[2:]:
+                matched_tuples.append([p_tuple,i,s_tuple,k])
+                s_tuples_b_copy.remove(s_tuple)
+            elif len(p_tuple) == 3 and len(s_tuple) == 3 and p_time < p_min and s_time < s_min and p_note == s_note:
+                matched_tuples.append([p_tuple,i,s_tuple,k])
+                s_tuples_b_copy.remove(s_tuple)
+            elif len(p_tuple) == 3 and len(s_tuple) == 3 and p_time > p_max and s_time > s_max and p_note == s_note:
+                matched_tuples.append([p_tuple,i,s_tuple,k])
+                s_tuples_b_copy.remove(s_tuple)
+            elif len(p_tuple) == 3 and len(s_tuple) == 3 and p_min <= p_time <= p_max and s_min <= s_time <= s_max and \
+                np.abs(map(p_time) - s_time) < .1 and p_note == s_note:
+                matched_tuples.append([p_tuple,i,s_tuple,k])
+                s_tuples_b_copy.remove(s_tuple)
+        if p_tuple not in [l[0] for l in matched_tuples] and not skip_Nones:
+            matched_tuples.append([p_tuple,i,[None,None,None],None])
+
+    # revert back to token format and remove beat indices
+    for i, l in enumerate(matched_tuples):
+        # performance tokens should have control offset
+        l[0] = [round(l[0][0]*TIME_RESOLUTION), l[0][1]+DUR_OFFSET, l[0][2]+NOTE_OFFSET]
+        l[0] = [CONTROL_OFFSET + t for t in l[0]]
+
+        if l[2][0] != None:
+            l[2] = [round(l[2][0]*TIME_RESOLUTION), l[2][1]+DUR_OFFSET, l[2][2]+NOTE_OFFSET]
+        matched_tuples[i] = l
+
+    return matched_tuples
+
+def align_tokens2(file1, file2, file3, file4, skip_Nones=True, thres=0.1):
+    # turn midi into events, without quantizing so we can get 16 digits of precision in arrival time
+    perf = midi_to_events(file1, quantize=False)
+    score = midi_to_events(file2, quantize=False)
+
+    p_beats, s_beats = compare_annotations(file3,file4,interpolate=False)
+    s_beats = np.array(s_beats)
+    p_beats = np.array(p_beats)
+    map = compare_annotations(file3, file4)
+
+    # create tuples, scaling arrival time back to seconds, which is the unit the annotation mapping uses
+    p_tuples = [[perf[3*i]/TIME_RESOLUTION, perf[3*i+1] - DUR_OFFSET, perf[3*i+2] - NOTE_OFFSET] for i in range(int(len(perf)/3))]
+    s_tuples = [[score[3*i]/TIME_RESOLUTION, score[3*i+1] - DUR_OFFSET, score[3*i+2] - NOTE_OFFSET] for i in range(int(len(score)/3))]
+
+    matched_tuples = []
+
+    s_tuples_copy = s_tuples.copy()
+
+    p_min = map.x.min()
+    p_max = map.x.max()
+
+    for i, p_tuple in enumerate(p_tuples):
+        best_dist = np.inf
+        best_match = [None, None, None]
+        best_index = None
+
+        p_time, p_note = p_tuple[0], p_tuple[2]
+
+        if p_min <= p_time <= p_max:
+
+            for j, s_tuple in enumerate(s_tuples_copy):
+
+                s_time, s_note = s_tuple[0], s_tuple[2] 
+
+                k = s_tuples.index(s_tuple)
+
+                dist = np.abs(map(p_time) - s_time)
+
+                if p_note != s_note:
+                    continue # not a match (wrong pitch)
+
+                if dist <= thres and dist <= best_dist: # found a possible match
+                    best_dist = dist
+                    best_match = s_tuple
+                    best_index = k
+
+        if best_index is not None:
+            matched_tuples.append([p_tuple,i,best_match,best_index])
+            s_tuples_copy.remove(best_match)
+        elif not skip_Nones:
+            matched_tuples.append([p_tuple,i,best_match,best_index])
+
+
+    # revert back to token format and remove beat indices
+    for i, l in enumerate(matched_tuples):
+        # performance tokens should have control offset
+        l[0] = [round(l[0][0]*TIME_RESOLUTION), l[0][1]+DUR_OFFSET, l[0][2]+NOTE_OFFSET]
+        l[0] = [CONTROL_OFFSET + t for t in l[0]]
+
+        if l[2][0] != None:
+            l[2] = [round(l[2][0]*TIME_RESOLUTION), l[2][1]+DUR_OFFSET, l[2][2]+NOTE_OFFSET]
+        matched_tuples[i] = l
+
+    return matched_tuples

anticipation/__init__.py

@@ -0,0 +1,9 @@
+""" Infrastructure for constructing anticipatory infilling models.
+
+This model provides infrastructure to preprocess Midi music datasets
+for training anticipatory music infilling models. For more context, see:
+
+    Anticipatory Music Transformer
+    John Thickstun, David Hall, Chris Donahue, Percy Liang
+    Preprint Report, 2023
+"""

anticipation/config.py

@@ -0,0 +1,60 @@
+"""
+Global configuration for anticipatory infilling models.
+"""
+
+# model hyper-parameters
+
+CONTEXT_SIZE = 1024                # model context
+EVENT_SIZE = 3                     # each event/control is encoded as 3 tokens
+M = 341                            # model context (1024 = 1 + EVENT_SIZE*M)
+DELTA = 5                          # anticipation time in seconds
+
+assert CONTEXT_SIZE == 1+EVENT_SIZE*M
+
+# vocabulary constants
+
+MAX_TIME_IN_SECONDS = 100          # exclude very long training sequences
+MAX_DURATION_IN_SECONDS = 10       # maximum duration of a note
+TIME_RESOLUTION = 100              # 10ms time resolution = 100 bins/second
+
+MAX_PITCH = 128                    # 128 MIDI pitches
+MAX_INSTR = 129                    # 129 MIDI instruments (128 + drums)
+MAX_NOTE = MAX_PITCH*MAX_INSTR     # note = pitch x instrument
+
+MAX_INTERARRIVAL_IN_SECONDS = 10   # maximum interarrival time (for MIDI-like encoding)
+
+# preprocessing settings
+
+PREPROC_WORKERS = 16
+
+COMPOUND_SIZE = 5                  # event size in the intermediate compound tokenization
+MAX_TRACK_INSTR = 16               # exclude tracks with large numbers of instruments
+MAX_TRACK_TIME_IN_SECONDS = 3600   # exclude very long tracks (longer than 1 hour)
+MIN_TRACK_TIME_IN_SECONDS = 10     # exclude very short tracks (less than 10 seconds)
+MIN_TRACK_EVENTS = 100             # exclude very short tracks (less than 100 events)
+
+# LakhMIDI dataset splits
+
+LAKH_SPLITS = ['0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f']
+LAKH_VALID = ['e']
+LAKH_TEST = ['f']
+
+# derived quantities
+
+MAX_TIME = TIME_RESOLUTION*MAX_TIME_IN_SECONDS
+MAX_DUR = TIME_RESOLUTION*MAX_DURATION_IN_SECONDS
+
+MAX_INTERARRIVAL = TIME_RESOLUTION*MAX_INTERARRIVAL_IN_SECONDS
+
+
+if __name__ == '__main__':
+    print('Model constants:')
+    print(f'  -> anticipation interval: {DELTA}s')
+    print('Vocabulary constants:')
+    print(f'  -> maximum time of a sequence: {MAX_TIME_IN_SECONDS}s')
+    print(f'  -> maximum duration of a note: {MAX_DURATION_IN_SECONDS}s')
+    print(f'  -> time resolution: {TIME_RESOLUTION}bins/s ({1000//TIME_RESOLUTION}ms)')
+    print(f'  -> maximum interarrival-time (MIDI-like encoding): {MAX_INTERARRIVAL_IN_SECONDS}s')
+    print('Preprocessing constants:')
+    print(f'  -> maximum time of a track: {MAX_TRACK_TIME_IN_SECONDS}s')
+    print(f'  -> minimum events in a track: {MIN_TRACK_EVENTS}s')

anticipation/convert.py

@@ -0,0 +1,359 @@
+"""
+Utilities for converting to and from Midi data and encoded/tokenized data.
+"""
+
+from collections import defaultdict
+
+import mido
+import numpy as np
+
+from anticipation.config import *
+from anticipation.vocab import *
+from anticipation.ops import unpad
+
+
+def midi_to_interarrival(midifile, debug=False, stats=False):
+    midi = mido.MidiFile(midifile)
+
+    tokens = []
+    dt = 0
+
+    instruments = defaultdict(int) # default to code 0 = piano
+    tempo = 500000 # default tempo: 500000 microseconds per beat
+    truncations = 0
+    for message in midi:
+        dt += message.time
+
+        # sanity check: negative time?
+        if message.time < 0:
+            raise ValueError
+
+        if message.type == 'program_change':
+            instruments[message.channel] = message.program
+        elif message.type in ['note_on', 'note_off']:
+            delta_ticks = min(round(TIME_RESOLUTION*dt), MAX_INTERARRIVAL-1)
+            if delta_ticks != round(TIME_RESOLUTION*dt):
+                truncations += 1
+
+            if delta_ticks > 0: # if time elapsed since last token
+                tokens.append(MIDI_TIME_OFFSET + delta_ticks) # add a time step event
+
+            # special case: channel 9 is drums!
+            inst = 128 if message.channel == 9 else instruments[message.channel]
+            offset = MIDI_START_OFFSET if message.type == 'note_on' and message.velocity > 0 else MIDI_END_OFFSET
+            tokens.append(offset + (2**7)*inst + message.note)
+            dt = 0
+        elif message.type == 'set_tempo':
+            tempo = message.tempo
+        elif message.type == 'time_signature':
+            pass # we use real time
+        elif message.type in ['aftertouch', 'polytouch', 'pitchwheel', 'sequencer_specific']:
+            pass # we don't attempt to model these
+        elif message.type == 'control_change':
+            pass # this includes pedal and per-track volume: ignore for now
+        elif message.type in ['track_name', 'text', 'end_of_track', 'lyrics', 'key_signature',
+                              'copyright', 'marker', 'instrument_name', 'cue_marker',
+                              'device_name', 'sequence_number']:
+            pass # possibly useful metadata but ignore for now
+        elif message.type == 'channel_prefix':
+            pass # relatively common, but can we ignore this?
+        elif message.type in ['midi_port', 'smpte_offset', 'sysex']:
+            pass # I have no idea what this is
+        else:
+            if debug:
+                print('UNHANDLED MESSAGE', message.type, message)
+
+    if stats:
+        return tokens, truncations
+
+    return tokens
+
+
+def interarrival_to_midi(tokens, debug=False):
+    mid = mido.MidiFile()
+    mid.ticks_per_beat = TIME_RESOLUTION // 2 # 2 beats/second at quarter=120
+
+    track_idx = {} # maps instrument to (track number, current time)
+    time_in_ticks = 0
+    num_tracks = 0
+    for token in tokens:
+        if token == MIDI_SEPARATOR:
+            continue
+
+        if token < MIDI_START_OFFSET:
+            time_in_ticks += token - MIDI_TIME_OFFSET
+        elif token < MIDI_END_OFFSET:
+            token -= MIDI_START_OFFSET
+            instrument = token // 2**7
+            pitch = token - (2**7)*instrument
+
+            try:
+                track, previous_time, idx = track_idx[instrument]
+            except KeyError:
+                idx = num_tracks
+                previous_time = 0
+                track = mido.MidiTrack()
+                mid.tracks.append(track)
+                if instrument == 128: # drums always go on channel 9
+                    idx = 9
+                    message = mido.Message('program_change', channel=idx, program=0)
+                else:
+                    message = mido.Message('program_change', channel=idx, program=instrument)
+                track.append(message)
+                num_tracks += 1
+                if num_tracks == 9:
+                    num_tracks += 1 # skip the drums track
+
+            track.append(mido.Message('note_on', note=pitch, channel=idx, velocity=96, time=time_in_ticks-previous_time))
+            track_idx[instrument] = (track, time_in_ticks, idx)
+        else:
+            token -= MIDI_END_OFFSET
+            instrument = token // 2**7
+            pitch = token - (2**7)*instrument
+
+            try:
+                track, previous_time, idx = track_idx[instrument]
+            except KeyError:
+                # shouldn't happen because we should have a corresponding onset
+                if debug:
+                    print('IGNORING bad offset')
+
+                continue
+
+            track.append(mido.Message('note_off', note=pitch, channel=idx, time=time_in_ticks-previous_time))
+            track_idx[instrument] = (track, time_in_ticks, idx)
+
+    return mid
+
+
+def midi_to_compound(midifile, debug=False, quantize=True):
+    """
+    Converts midi file to a compound tokenization that stores each note as
+    a 5-tuple of (time, duration, note, instrument, velocity).
+
+    Note that mido measures the time of a midi message in seconds, which we multiply by 
+    TIME_RESOLUTION = 10ms to get a time in 10ms ticks.
+    """
+    # robustly detect string-like paths (including numpy.str_)
+    if isinstance(midifile, (str, np.generic)):
+        midi = mido.MidiFile(str(midifile))
+    else:
+        midi = midifile
+
+    tokens = []
+    note_idx = 0
+    open_notes = defaultdict(list)
+
+    time = 0
+    instruments = defaultdict(int) # default to code 0 = piano
+    tempo = 500000 # default tempo: 500000 microseconds per beat
+    for message in midi:
+        time += message.time
+
+        # sanity check: negative time?
+        if message.time < 0:
+            raise ValueError
+
+        if message.type == 'program_change':
+            instruments[message.channel] = message.program
+        elif message.type in ['note_on', 'note_off']:
+            # special case: channel 9 is drums!
+            instr = 128 if message.channel == 9 else instruments[message.channel]
+
+            if message.type == 'note_on' and message.velocity > 0: # onset
+                # time quantization
+                if quantize:
+                    time_in_ticks = round(TIME_RESOLUTION*time) # with rounding
+                else:
+                    time_in_ticks = TIME_RESOLUTION*time # without rounding
+
+                # Our compound word is: (time, duration, note, instr, velocity)
+                tokens.append(time_in_ticks) # 5ms resolution
+                tokens.append(-1) # placeholder (we'll fill this in later)
+                tokens.append(message.note)
+                tokens.append(instr)
+                tokens.append(message.velocity)
+
+                open_notes[(instr,message.note,message.channel)].append((note_idx, time))
+                note_idx += 1
+            else: # offset
+                try:
+                    open_idx, onset_time = open_notes[(instr,message.note,message.channel)].pop(0)
+                except IndexError:
+                    if debug:
+                        print('WARNING: ignoring bad offset')
+                else:
+                    duration_ticks = round(TIME_RESOLUTION*(time-onset_time))
+                    tokens[5*open_idx + 1] = duration_ticks
+                    #del open_notes[(instr,message.note,message.channel)]
+        elif message.type == 'set_tempo':
+            tempo = message.tempo
+        elif message.type == 'time_signature':
+            pass # we use real time
+        elif message.type in ['aftertouch', 'polytouch', 'pitchwheel', 'sequencer_specific']:
+            pass # we don't attempt to model these
+        elif message.type == 'control_change':
+            pass # this includes pedal and per-track volume: ignore for now
+        elif message.type in ['track_name', 'text', 'end_of_track', 'lyrics', 'key_signature',
+                              'copyright', 'marker', 'instrument_name', 'cue_marker',
+                              'device_name', 'sequence_number']:
+            pass # possibly useful metadata but ignore for now
+        elif message.type == 'channel_prefix':
+            pass # relatively common, but can we ignore this?
+        elif message.type in ['midi_port', 'smpte_offset', 'sysex']:
+            pass # I have no idea what this is
+        else:
+            if debug:
+                print('UNHANDLED MESSAGE', message.type, message)
+
+    unclosed_count = 0
+    for _,v in open_notes.items():
+        unclosed_count += len(v)
+
+    if debug and unclosed_count > 0:
+        print(f'WARNING: {unclosed_count} unclosed notes')
+        print('  ', midifile)
+
+    return tokens
+
+
+def compound_to_midi(tokens, debug=False):
+    mid = mido.MidiFile()
+    mid.ticks_per_beat = TIME_RESOLUTION // 2 # 2 beats/second at quarter=120
+
+    it = iter(tokens)
+    time_index = defaultdict(list)
+    for _, (time_in_ticks,duration,note,instrument,velocity) in enumerate(zip(it,it,it,it,it)):
+        time_index[(time_in_ticks,0)].append((note, instrument, velocity)) # 0 = onset
+        time_index[(time_in_ticks+duration,1)].append((note, instrument, velocity)) # 1 = offset
+
+    track_idx = {} # maps instrument to (track number, current time)
+    num_tracks = 0
+    for time_in_ticks, event_type in sorted(time_index.keys()):
+        for (note, instrument, velocity) in time_index[(time_in_ticks, event_type)]:
+            if event_type == 0: # onset
+                try:
+                    track, previous_time, idx = track_idx[instrument]
+                except KeyError:
+                    idx = num_tracks
+                    previous_time = 0
+                    track = mido.MidiTrack()
+                    mid.tracks.append(track)
+                    if instrument == 128: # drums always go on channel 9
+                        idx = 9
+                        message = mido.Message('program_change', channel=idx, program=0)
+                    else:
+                        message = mido.Message('program_change', channel=idx, program=instrument)
+                    track.append(message)
+                    num_tracks += 1
+                    if num_tracks == 9:
+                        num_tracks += 1 # skip the drums track
+
+                track.append(mido.Message(
+                    'note_on', note=note, channel=idx, velocity=velocity,
+                    time=time_in_ticks-previous_time))
+                track_idx[instrument] = (track, time_in_ticks, idx)
+            else: # offset
+                try:
+                    track, previous_time, idx = track_idx[instrument]
+                except KeyError:
+                    # shouldn't happen because we should have a corresponding onset
+                    if debug:
+                        print('IGNORING bad offset')
+
+                    continue
+
+                track.append(mido.Message(
+                    'note_off', note=note, channel=idx,
+                    time=time_in_ticks-previous_time))
+                track_idx[instrument] = (track, time_in_ticks, idx)
+
+    return mid
+
+
+def compound_to_events(tokens, stats=False):
+    """
+    Converts a compound tokenization to a sequence of events according to Definition 2.2
+    in the anticipation paper, removing velocity and instrument and combining note as a pitch
+    and instrument.
+    """
+    assert len(tokens) % 5 == 0
+    tokens = tokens.copy()
+
+    # remove velocities
+    del tokens[4::5]
+
+    # combine (note, instrument)
+    assert all(-1 <= tok < 2**7 for tok in tokens[2::4])
+    assert all(-1 <= tok < 129 for tok in tokens[3::4])
+    tokens[2::4] = [SEPARATOR if note == -1 else MAX_PITCH*instr + note
+                    for note, instr in zip(tokens[2::4],tokens[3::4])]
+    tokens[2::4] = [NOTE_OFFSET + tok for tok in tokens[2::4]]
+    del tokens[3::4]
+
+    # max duration cutoff and set unknown durations to 250ms
+    truncations = sum([1 for tok in tokens[1::3] if tok >= MAX_DUR]) # number of note durations exceeding 10s
+    tokens[1::3] = [TIME_RESOLUTION//4 if tok == -1 else min(tok, MAX_DUR-1)
+                    for tok in tokens[1::3]]
+    tokens[1::3] = [DUR_OFFSET + tok for tok in tokens[1::3]]
+
+    assert min(tokens[0::3]) >= 0
+    tokens[0::3] = [TIME_OFFSET + tok for tok in tokens[0::3]]
+
+    assert len(tokens) % 3 == 0
+
+    if stats:
+        return tokens, truncations
+
+    return tokens
+
+
+def events_to_compound(tokens, debug=False):
+    tokens = unpad(tokens)
+
+    # move all tokens to zero-offset for synthesis
+    tokens = [tok - CONTROL_OFFSET if tok >= CONTROL_OFFSET and tok != SEPARATOR else tok
+              for tok in tokens]
+
+    # remove type offsets
+    tokens[0::3] = [tok - TIME_OFFSET if tok != SEPARATOR else tok for tok in tokens[0::3]]
+    tokens[1::3] = [tok - DUR_OFFSET if tok != SEPARATOR else tok for tok in tokens[1::3]]
+    tokens[2::3] = [tok - NOTE_OFFSET if tok != SEPARATOR else tok for tok in tokens[2::3]]
+
+    offset = 0 # add max time from previous track for synthesis
+    track_max = 0 # keep track of max time in track
+    for j, (time,dur,note) in enumerate(zip(tokens[0::3],tokens[1::3],tokens[2::3])):
+        if note == SEPARATOR:
+            offset += track_max
+            track_max = 0
+            if debug:
+                print('Sequence Boundary')
+        else:
+            track_max = max(track_max, time+dur)
+            tokens[3*j] += offset
+
+    # strip sequence separators
+    assert len([tok for tok in tokens if tok == SEPARATOR]) % 3 == 0
+    tokens = [tok for tok in tokens if tok != SEPARATOR]
+
+    assert len(tokens) % 3 == 0
+    out = 5*(len(tokens)//3)*[0]
+    out[0::5] = tokens[0::3]
+    out[1::5] = tokens[1::3]
+    out[2::5] = [tok - (2**7)*(tok//2**7) for tok in tokens[2::3]]
+    out[3::5] = [tok//2**7 for tok in tokens[2::3]]
+    out[4::5] = (len(tokens)//3)*[72] # default velocity
+
+    assert max(out[1::5]) < MAX_DUR
+    assert max(out[2::5]) < MAX_PITCH
+    assert max(out[3::5]) < MAX_INSTR
+    assert all(tok >= 0 for tok in out)
+
+    return out
+
+
+def events_to_midi(tokens, debug=False):
+    return compound_to_midi(events_to_compound(tokens, debug=debug), debug=debug)
+
+def midi_to_events(midifile, debug=False, quantize=True):
+    return compound_to_events(midi_to_compound(midifile, debug=debug, quantize=quantize))

anticipation/ops.py

@@ -0,0 +1,333 @@
+"""
+Utilities for operating on encoded Midi sequences.
+"""
+
+from collections import defaultdict
+
+from anticipation.config import *
+from anticipation.vocab import *
+
+
+def print_tokens(tokens):
+    print('---------------------')
+    for j, (tm, dur, note) in enumerate(zip(tokens[0::3],tokens[1::3],tokens[2::3])):
+        if note == SEPARATOR:
+            assert tm == SEPARATOR and dur == SEPARATOR
+            print(j, 'SEPARATOR')
+            continue
+
+        if note == REST:
+            assert tm < CONTROL_OFFSET
+            assert dur == DUR_OFFSET+0
+            print(j, tm, 'REST')
+            continue
+
+        if note < CONTROL_OFFSET:
+            tm = tm - TIME_OFFSET
+            dur = dur - DUR_OFFSET
+            note = note - NOTE_OFFSET
+            instr = note//2**7
+            pitch = note - (2**7)*instr
+            print(j, tm, dur, instr, pitch)
+        else:
+            tm = tm - ATIME_OFFSET
+            dur = dur - ADUR_OFFSET
+            note = note - ANOTE_OFFSET
+            instr = note//2**7
+            pitch = note - (2**7)*instr
+            print(j, tm, dur, instr, pitch, '(A)')
+
+
+def clip(tokens, start, end, clip_duration=True, seconds=True):
+    if seconds:
+        start = int(TIME_RESOLUTION*start)
+        end = int(TIME_RESOLUTION*end)
+
+    new_tokens = []
+    for (time, dur, note) in zip(tokens[0::3],tokens[1::3],tokens[2::3]):
+        if note < CONTROL_OFFSET:
+            this_time = time - TIME_OFFSET
+            this_dur = dur - DUR_OFFSET
+        else:
+            this_time = time - ATIME_OFFSET
+            this_dur = dur - ADUR_OFFSET
+
+        if this_time < start or end < this_time:
+            continue
+
+        # truncate extended notes
+        if clip_duration and end < this_time + this_dur:
+            dur -= this_time + this_dur - end
+
+        new_tokens.extend([time, dur, note])
+
+    return new_tokens
+
+
+def mask(tokens, start, end):
+    new_tokens = []
+    for (time, dur, note) in zip(tokens[0::3],tokens[1::3],tokens[2::3]):
+        if note < CONTROL_OFFSET:
+            this_time = (time - TIME_OFFSET)/float(TIME_RESOLUTION)
+        else:
+            this_time = (time - ATIME_OFFSET)/float(TIME_RESOLUTION)
+
+        if start < this_time < end:
+            continue
+
+        new_tokens.extend([time, dur, note])
+
+    return new_tokens
+
+
+def delete(tokens, criterion):
+    new_tokens = []
+    for token in zip(tokens[0::3],tokens[1::3],tokens[2::3]):
+        if criterion(token):
+            continue
+
+        new_tokens.extend(token)
+
+    return new_tokens
+
+
+def sort(tokens):
+    """ sort sequence of events or controls (but not both) """
+
+    times = tokens[0::3]
+    indices = sorted(range(len(times)), key=times.__getitem__)
+
+    sorted_tokens = []
+    for idx in indices:
+        sorted_tokens.extend(tokens[3*idx:3*(idx+1)])
+
+    return sorted_tokens
+
+
+def split(tokens):
+    """ split a sequence into events and controls """
+
+    events = []
+    controls = []
+    for (time, dur, note) in zip(tokens[0::3],tokens[1::3],tokens[2::3]):
+        if note < CONTROL_OFFSET:
+            events.extend([time, dur, note])
+        else:
+            controls.extend([time, dur, note])
+
+    return events, controls
+
+
+def pad(tokens, end_time=None, density=TIME_RESOLUTION):
+    """
+    Pads tokens up to end_time (if given) with REST (a special token value defined in vocab.py) 
+    up to a desired density. see Definition 3.5 and Example 3.6 in the paper.
+    """
+    end_time = TIME_OFFSET+(end_time if end_time else max_time(tokens, seconds=False))
+    new_tokens = []
+    previous_time = TIME_OFFSET+0
+    for (time, dur, note) in zip(tokens[0::3],tokens[1::3],tokens[2::3]):
+        # must pad before separation, anticipation
+        assert note < CONTROL_OFFSET
+
+        # insert pad tokens to ensure the desired density
+        while time > previous_time + density:
+            new_tokens.extend([previous_time+density, DUR_OFFSET+0, REST])
+            previous_time += density
+
+        new_tokens.extend([time, dur, note])
+        previous_time = time
+
+    while end_time > previous_time + density:
+        new_tokens.extend([previous_time+density, DUR_OFFSET+0, REST])
+        previous_time += density
+
+    return new_tokens
+
+
+def unpad(tokens):
+    new_tokens = []
+    for (time, dur, note) in zip(tokens[0::3],tokens[1::3],tokens[2::3]):
+        if note == REST: continue
+
+        new_tokens.extend([time, dur, note])
+
+    return new_tokens
+
+
+def anticipate(events, controls, delta=DELTA*TIME_RESOLUTION):
+    """
+    Interleave a sequence of events with anticipated controls.
+
+    Inputs:
+      events   : a sequence of events
+      controls : a sequence of time-localized controls
+      delta    : the anticipation interval
+    
+    Returns:
+      tokens   : interleaved events and anticipated controls
+      controls : unconsumed controls (control time > max_time(events) + delta)
+    """
+
+    if len(controls) == 0:
+        return events, controls
+
+    tokens = []
+    event_time = 0
+    control_time = controls[0] - ATIME_OFFSET
+    for time, dur, note in zip(events[0::3],events[1::3],events[2::3]):
+        while event_time >= control_time - delta:
+            tokens.extend(controls[0:3])
+            controls = controls[3:] # consume this control
+            control_time = controls[0] - ATIME_OFFSET if len(controls) > 0 else float('inf')
+
+        assert note < CONTROL_OFFSET
+        event_time = time - TIME_OFFSET
+        tokens.extend([time, dur, note])
+
+    return tokens, controls
+
+
+def anticipate2(events, controls, map, delta=DELTA*TIME_RESOLUTION):
+    """
+    Interleave a sequence of events with anticipated controls, where controls represent
+    the performance of a piece and events represent the score, and map is a mapping from 
+    score beats and downbeats to performance beats and downbeats.
+
+    Note that ATIME_OFFSET, CONTROL_OFFSET, TIME_OFFSET offset the arrival times of 
+    controls and events to differentiate between them. But they are subtracted to retrieve
+    the actual time of the event or control.
+
+    Also, our map interpolates from the first to last beats in the score/performance, so we need
+    to throw away tokens that are not in the domain and range of the map.
+    """
+
+    if len(controls) == 0:
+        return events, controls
+
+    domain_min = map.x.min()
+    domain_max = map.x.max()
+    range_min = map.y.min()
+    range_max = map.y.max()
+
+    filtered_events = [t for t in list(zip(events[0::3], events[1::3], events[2::3])) \
+                       if domain_min <= t[0]/TIME_RESOLUTION <= domain_max]
+    
+    filtered_controls = [t for t in list(zip(controls[0::3], controls[1::3], controls[2::3])) \
+                       if range_min <= (t[0]-CONTROL_OFFSET)/TIME_RESOLUTION <= range_max]
+    
+    tokens = []
+    control_time = filtered_controls[0][0] - ATIME_OFFSET
+
+    for time, dur, note in filtered_events:
+        while map(time / TIME_RESOLUTION)*TIME_RESOLUTION >= control_time - delta:
+            tokens.extend(filtered_controls[0])
+            filtered_controls = filtered_controls[1:] # consume this control
+            control_time = filtered_controls[0][0] - ATIME_OFFSET if len(filtered_controls) > 0 else float('inf')
+
+        assert note < CONTROL_OFFSET
+        tokens.extend([time, dur, note])
+
+    controls = [item for tup in filtered_controls for item in tup]
+    return tokens, controls
+
+
+def sparsity(tokens):
+    max_dt = 0
+    previous_time = TIME_OFFSET+0
+    for (time, dur, note) in zip(tokens[0::3],tokens[1::3],tokens[2::3]):
+        if note == SEPARATOR: continue
+        assert note < CONTROL_OFFSET # don't operate on interleaved sequences
+
+        max_dt = max(max_dt, time - previous_time)
+        previous_time = time
+
+    return max_dt
+
+
+def min_time(tokens, seconds=True, instr=None):
+    mt = None
+    for time, dur, note in zip(tokens[0::3],tokens[1::3],tokens[2::3]):
+        # stop calculating at sequence separator
+        if note == SEPARATOR: break
+
+        if note < CONTROL_OFFSET:
+            time -= TIME_OFFSET
+            note -= NOTE_OFFSET
+        else:
+            time -= ATIME_OFFSET
+            note -= ANOTE_OFFSET
+
+        # min time of a particular instrument
+        if instr is not None and instr != note//2**7:
+            continue
+
+        mt = time if mt is None else min(mt, time)
+
+    if mt is None: mt = 0
+    return mt/float(TIME_RESOLUTION) if seconds else mt
+
+
+def max_time(tokens, seconds=True, instr=None):
+    mt = 0
+    for time, dur, note in zip(tokens[0::3],tokens[1::3],tokens[2::3]):
+        # keep checking for max_time, even if it appears after a separator
+        # (this is important because we use this check for vocab overflow in tokenization)
+        if note == SEPARATOR: continue
+
+        if note < CONTROL_OFFSET:
+            time -= TIME_OFFSET
+            note -= NOTE_OFFSET
+        else:
+            time -= ATIME_OFFSET
+            note -= ANOTE_OFFSET
+
+        # max time of a particular instrument
+        if instr is not None and instr != note//2**7:
+            continue
+
+        mt = max(mt, time)
+
+    return mt/float(TIME_RESOLUTION) if seconds else mt
+
+
+def get_instruments(tokens):
+    instruments = defaultdict(int)
+    for time, dur, note in zip(tokens[0::3],tokens[1::3],tokens[2::3]):
+        if note >= SPECIAL_OFFSET: continue
+
+        if note < CONTROL_OFFSET:
+            note -= NOTE_OFFSET
+        else:
+            note -= ANOTE_OFFSET
+
+        instr = note//2**7
+        instruments[instr] += 1
+
+    return instruments
+
+
+def translate(tokens, dt, seconds=False):
+    if seconds:
+        dt = int(TIME_RESOLUTION*dt)
+
+    new_tokens = []
+    for (time, dur, note) in zip(tokens[0::3],tokens[1::3],tokens[2::3]):
+        # stop translating after EOT
+        if note == SEPARATOR:
+            new_tokens.extend([time, dur, note])
+            dt = 0
+            continue
+
+        if note < CONTROL_OFFSET:
+            this_time = time - TIME_OFFSET
+        else:
+            this_time = time - ATIME_OFFSET
+
+        assert 0 <= this_time + dt
+        new_tokens.extend([time+dt, dur, note])
+
+    return new_tokens
+
+def combine(events, controls):
+    return sort(events + [token - CONTROL_OFFSET for token in controls])

anticipation/sample.py

@@ -0,0 +1,406 @@
+"""
+API functions for sampling from anticipatory infilling models.
+"""
+
+import math
+
+import torch
+import torch.nn.functional as F
+
+from tqdm import tqdm
+
+from anticipation import ops
+from anticipation.config import *
+from anticipation.vocab import *
+
+
+def safe_logits(logits, idx):
+    logits[CONTROL_OFFSET:SPECIAL_OFFSET] = -float('inf') # don't generate controls
+    logits[SPECIAL_OFFSET:] = -float('inf')               # don't generate special tokens
+
+    # don't generate stuff in the wrong time slot
+    if idx % 3 == 0:
+        logits[DUR_OFFSET:DUR_OFFSET+MAX_DUR] = -float('inf')
+        logits[NOTE_OFFSET:NOTE_OFFSET+MAX_NOTE] = -float('inf')
+    elif idx % 3 == 1:
+        logits[TIME_OFFSET:TIME_OFFSET+MAX_TIME] = -float('inf')
+        logits[NOTE_OFFSET:NOTE_OFFSET+MAX_NOTE] = -float('inf')
+    elif idx % 3 == 2:
+        logits[TIME_OFFSET:TIME_OFFSET+MAX_TIME] = -float('inf')
+        logits[DUR_OFFSET:DUR_OFFSET+MAX_DUR] = -float('inf')
+
+    return logits
+
+
+def nucleus(logits, top_p):
+    # from HF implementation
+    if top_p < 1.0:
+        sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+        cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
+
+        # Remove tokens with cumulative probability above the threshold (token with 0 are kept)
+        sorted_indices_to_remove = cumulative_probs > top_p
+
+        # Shift the indices to the right to keep also the first token above the threshold
+        sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
+        sorted_indices_to_remove[..., 0] = 0
+
+        # scatter sorted tensors to original indexing
+        indices_to_remove = sorted_indices_to_remove.scatter(0, sorted_indices, sorted_indices_to_remove)
+        logits[indices_to_remove] = -float("inf")
+
+    return logits
+
+
+def future_logits(logits, curtime):
+    """ don't sample events in the past """
+    if curtime > 0:
+        logits[TIME_OFFSET:TIME_OFFSET+curtime] = -float('inf')
+
+    return logits
+
+
+def instr_logits(logits, full_history):
+    """ don't sample more than 16 instruments """
+    instrs = ops.get_instruments(full_history)
+    if len(instrs) < 15: # 16 - 1 to account for the reserved drum track
+        return logits
+
+    for instr in range(MAX_INSTR):
+        if instr not in instrs:
+            logits[NOTE_OFFSET+instr*MAX_PITCH:NOTE_OFFSET+(instr+1)*MAX_PITCH] = -float('inf')
+
+    return logits
+
+
+def add_token(model, z, tokens, top_p, current_time, debug=False):
+    assert len(tokens) % 3 == 0
+
+    history = tokens.copy()
+    lookback = max(len(tokens) - 1017, 0)
+    history = history[lookback:] # Markov window
+    offset = ops.min_time(history, seconds=False)
+    history[::3] = [tok - offset for tok in history[::3]] # relativize time in the history buffer
+
+    new_token = []
+    with torch.no_grad():
+        for i in range(3):
+            input_tokens = torch.tensor(z + history + new_token).unsqueeze(0).to(model.device)
+            logits = model(input_tokens).logits[0,-1]
+
+            idx = input_tokens.shape[1]-1
+            logits = safe_logits(logits, idx)
+            if i == 0:
+                logits = future_logits(logits, current_time - offset)
+            elif i == 2:
+                logits = instr_logits(logits, tokens)
+            logits = nucleus(logits, top_p)
+
+            probs = F.softmax(logits, dim=-1)
+            token = torch.multinomial(probs, 1)
+            new_token.append(int(token))
+
+    new_token[0] += offset # revert to full sequence timing
+    if debug:
+        print(f'  OFFSET = {offset}, LEN = {len(history)}, TIME = {tokens[::3][-5:]}')
+
+    return new_token
+
+
+def generate(model, start_time, end_time, inputs=None, controls=None, top_p=1.0, debug=False, delta=DELTA*TIME_RESOLUTION):
+    if inputs is None:
+        inputs = []
+
+    if controls is None:
+        controls = []
+
+    start_time = int(TIME_RESOLUTION*start_time)
+    end_time = int(TIME_RESOLUTION*end_time)
+
+    # prompt is events up to start_time
+    prompt = ops.pad(ops.clip(inputs, 0, start_time, clip_duration=False, seconds=False), start_time)
+
+    # treat events beyond start_time as controls
+    future = ops.clip(inputs, start_time+1, ops.max_time(inputs, seconds=False), clip_duration=False, seconds=False)
+    if debug:
+        print('Future')
+        ops.print_tokens(future)
+
+    # clip controls that preceed the sequence
+    controls = ops.clip(controls, DELTA, ops.max_time(controls, seconds=False), clip_duration=False, seconds=False)
+
+    if debug:
+        print('Controls')
+        ops.print_tokens(controls)
+
+    z = [ANTICIPATE] if len(controls) > 0 or len(future) > 0 else [AUTOREGRESS]
+    if debug:
+        print('AR Mode' if z[0] == AUTOREGRESS else 'AAR Mode')
+
+    # interleave the controls with the events
+    tokens, controls = ops.anticipate(prompt, ops.sort(controls + [CONTROL_OFFSET+token for token in future]))
+
+    if debug:
+        print('Prompt')
+        ops.print_tokens(tokens)
+
+    current_time = ops.max_time(prompt, seconds=False)
+    if debug:
+        print('Current time:', current_time)
+
+    with tqdm(range(end_time-start_time)) as progress:
+        if controls:
+            atime, adur, anote = controls[0:3]
+            anticipated_tokens = controls[3:]
+            anticipated_time = atime - ATIME_OFFSET
+        else:
+            # nothing to anticipate
+            anticipated_time = math.inf
+
+        while True:
+            while current_time >= anticipated_time - delta:
+                tokens.extend([atime, adur, anote])
+                if debug:
+                    note = anote - ANOTE_OFFSET
+                    instr = note//2**7
+                    print('A', atime - ATIME_OFFSET, adur - ADUR_OFFSET, instr, note - (2**7)*instr)
+
+                if len(anticipated_tokens) > 0:
+                    atime, adur, anote = anticipated_tokens[0:3]
+                    anticipated_tokens = anticipated_tokens[3:]
+                    anticipated_time = atime - ATIME_OFFSET
+                else:
+                    # nothing more to anticipate
+                    anticipated_time = math.inf
+
+            new_token = add_token(model, z, tokens, top_p, max(start_time,current_time))
+            new_time = new_token[0] - TIME_OFFSET
+            if new_time >= end_time:
+                break
+
+            if debug:
+                new_note = new_token[2] - NOTE_OFFSET
+                new_instr = new_note//2**7
+                new_pitch = new_note - (2**7)*new_instr
+                print('C', new_time, new_token[1] - DUR_OFFSET, new_instr, new_pitch)
+
+            tokens.extend(new_token)
+            dt = new_time - current_time
+            assert dt >= 0
+            current_time = new_time
+            progress.update(dt)
+
+    events, _ = ops.split(tokens)
+    return ops.sort(ops.unpad(events) + future)
+
+
+def generate_ar(model, start_time, end_time, inputs=None, controls=None, top_p=1.0, debug=False, delta=DELTA*TIME_RESOLUTION):
+    if inputs is None:
+        inputs = []
+
+    if controls is None:
+        controls = []
+    else:
+        # treat controls as ordinary tokens
+        controls = [token-CONTROL_OFFSET for token in controls]
+
+    start_time = int(TIME_RESOLUTION*start_time)
+    end_time = int(TIME_RESOLUTION*end_time)
+
+    inputs = ops.sort(inputs + controls)
+
+    # prompt is events up to start_time
+    prompt = ops.pad(ops.clip(inputs, 0, start_time, clip_duration=False, seconds=False), start_time)
+    if debug:
+        print('Prompt')
+        ops.print_tokens(prompt)
+
+    # treat events beyond start_time as controls
+    controls = ops.clip(inputs, start_time+1, ops.max_time(inputs, seconds=False), clip_duration=False, seconds=False)
+    if debug:
+        print('Future')
+        ops.print_tokens(controls)
+
+    z = [AUTOREGRESS]
+    if debug:
+        print('AR Mode')
+
+    current_time = ops.max_time(prompt, seconds=False)
+    if debug:
+        print('Current time:', current_time)
+
+    tokens = prompt
+    with tqdm(range(end_time-start_time)) as progress:
+        if controls:
+            atime, adur, anote = controls[0:3]
+            anticipated_tokens = controls[3:]
+            anticipated_time = atime - TIME_OFFSET
+        else:
+            # nothing to anticipate
+            anticipated_time = math.inf
+
+        while True:
+            new_token = add_token(model, z, tokens, top_p, max(start_time,current_time))
+            new_time = new_token[0] - TIME_OFFSET
+            if new_time >= end_time:
+                break
+
+            dt = new_time - current_time
+            assert dt >= 0
+            current_time = new_time
+
+            # backfill anything that should have come before the new token
+            while current_time >= anticipated_time:
+                tokens.extend([atime, adur, anote])
+                if debug:
+                    note = anote - NOTE_OFFSET
+                    instr = note//2**7
+                    print('A', atime - TIME_OFFSET, adur - DUR_OFFSET, instr, note - (2**7)*instr)
+
+                if len(anticipated_tokens) > 0:
+                    atime, adur, anote = anticipated_tokens[0:3]
+                    anticipated_tokens = anticipated_tokens[3:]
+                    anticipated_time = atime - TIME_OFFSET
+                else:
+                    # nothing more to anticipate
+                    anticipated_time = math.inf
+
+            if debug:
+                new_note = new_token[2] - NOTE_OFFSET
+                new_instr = new_note//2**7
+                new_pitch = new_note - (2**7)*new_instr
+                print('C', new_time, new_token[1] - DUR_OFFSET, new_instr, new_pitch)
+
+            tokens.extend(new_token)
+            progress.update(dt)
+
+    if anticipated_time != math.inf:
+        tokens.extend([atime, adur, anote])
+
+    return ops.sort(ops.unpad(tokens) + controls)
+
+def generate2(model, start_time, end_time, inputs=None, controls=None, map=None, top_p=1.0, debug=False, delta=DELTA*TIME_RESOLUTION):
+    """
+    Note that in this generate function (and the original one) the controls should already be offset by CONTROL_OFFSET.
+    Otherwise anticipate functions will not work correctly.
+
+    This function is just for testing; in reality we wouldn't be able to generate with a map.
+    """
+    if inputs is None:
+        inputs = []
+
+    if controls is None:
+        controls = []
+
+    start_time = int(TIME_RESOLUTION*start_time)
+    end_time = int(TIME_RESOLUTION*end_time)
+
+    # prompt is events up to start_time
+    prompt = ops.pad(ops.clip(inputs, 0, start_time, clip_duration=False, seconds=False), start_time)
+
+    # treat events beyond start_time as controls
+    future = ops.clip(inputs, start_time+1, ops.max_time(inputs, seconds=False), clip_duration=False, seconds=False)
+    if debug:
+        print('Future')
+        ops.print_tokens(future)
+
+    # clip controls that preceed the sequence
+    # start controls at anticipated time delta so that control_time - delta is non-negative
+    controls = ops.clip(controls, DELTA, ops.max_time(controls, seconds=False), clip_duration=False, seconds=False)
+
+    if debug:
+        print('Controls')
+        ops.print_tokens(controls)
+
+    z = [ANTICIPATE] if len(controls) > 0 or len(future) > 0 else [AUTOREGRESS]
+    if debug:
+        print('AR Mode' if z[0] == AUTOREGRESS else 'AAR Mode')
+
+    # interleave the controls with the events
+    # this shouldn't do anything if I'm only passing in controls; prompt is empty
+    # so tokens remains empty, controls remains the same
+    tokens, controls = ops.anticipate2(prompt, ops.sort(controls + [CONTROL_OFFSET+token for token in future]), map)
+
+    if debug:
+        print('Prompt')
+        ops.print_tokens(tokens)
+
+    current_time = ops.max_time(prompt, seconds=False) # should be 0 if prompt is empty
+    if debug:
+        print('Current time:', current_time)
+
+
+
+
+    # make sure the event time begins inside the domain of the map
+    domain_min = map.x.min()
+    domain_max = map.x.max()
+    range_min = map.y.min()
+    range_max = map.y.max()
+
+    if current_time/TIME_RESOLUTION < domain_min:
+        current_time = domain_min*TIME_RESOLUTION
+    
+    if start_time/TIME_RESOLUTION < domain_min:
+        start_time = int(domain_min*TIME_RESOLUTION)
+
+    if end_time/TIME_RESOLUTION > domain_max:
+        end_time = int(domain_max*TIME_RESOLUTION)
+
+    # make sure the control time begins inside the range of the map, i.e. 
+    # the score is only controlled by performance notes occurring within the first and last beats
+    filtered_controls = [t for t in list(zip(controls[0::3], controls[1::3], controls[2::3])) \
+                    if range_min <= (t[0]-CONTROL_OFFSET)/TIME_RESOLUTION <= range_max]
+    controls = [item for tup in filtered_controls for item in tup]
+
+
+
+
+    with tqdm(range(end_time-start_time)) as progress:
+        if controls:
+            atime, adur, anote = controls[0:3]
+            anticipated_tokens = controls[3:]
+            anticipated_time = atime - ATIME_OFFSET
+        else:
+            # nothing to anticipate
+            anticipated_time = math.inf
+
+        while True:
+            while map(current_time/TIME_RESOLUTION)*TIME_RESOLUTION >= anticipated_time - delta:
+                tokens.extend([atime, adur, anote])
+                # print(f'inserted a control at time {(atime-ATIME_OFFSET)/TIME_RESOLUTION}')
+                if debug:
+                    note = anote - ANOTE_OFFSET
+                    instr = note//2**7
+                    print('A', atime - ATIME_OFFSET, adur - ADUR_OFFSET, instr, note - (2**7)*instr)
+
+                if len(anticipated_tokens) > 0:
+                    atime, adur, anote = anticipated_tokens[0:3]
+                    anticipated_tokens = anticipated_tokens[3:]
+                    anticipated_time = atime - ATIME_OFFSET
+                else:
+                    # nothing more to anticipate
+                    anticipated_time = math.inf
+
+            new_token = add_token(model, z, tokens, top_p, max(start_time,current_time))
+            new_time = new_token[0] - TIME_OFFSET
+            if new_time >= end_time:
+                # print(f'new time was {new_time/TIME_RESOLUTION} and end time was {end_time/TIME_RESOLUTION} so we are breaking')
+                break
+
+            # print(f'generated an event at time {new_time/TIME_RESOLUTION} with performance time {map(new_time/TIME_RESOLUTION)}')
+
+            if debug:
+                new_note = new_token[2] - NOTE_OFFSET
+                new_instr = new_note//2**7
+                new_pitch = new_note - (2**7)*new_instr
+                print('C', new_time, new_token[1] - DUR_OFFSET, new_instr, new_pitch)
+
+            tokens.extend(new_token)
+            dt = new_time - current_time
+            assert dt >= 0
+            current_time = new_time
+            progress.update(dt)
+
+    events, _ = ops.split(tokens)
+    return ops.sort(ops.unpad(events) + future)

anticipation/tokenize.py

@@ -0,0 +1,397 @@
+"""
+Top-level functions for preprocessing data to be used for training.
+"""
+
+from tqdm import tqdm
+
+import numpy as np
+
+from anticipation import ops
+from anticipation.config import *
+from anticipation.vocab import *
+from anticipation.convert import compound_to_events, midi_to_interarrival, midi_to_compound
+from alignment import *
+
+
+def extract_spans(all_events, rate):
+    events = []
+    controls = []
+    span = True
+    next_span = end_span = TIME_OFFSET+0
+    for time, dur, note in zip(all_events[0::3],all_events[1::3],all_events[2::3]):
+        assert(note not in [SEPARATOR, REST]) # shouldn't be in the sequence yet
+
+        # end of an anticipated span; decide when to do it again (next_span)
+        if span and time >= end_span:
+            span = False
+            next_span = time+int(TIME_RESOLUTION*np.random.exponential(1./rate))
+
+        # anticipate a 3-second span
+        if (not span) and time >= next_span:
+            span = True
+            end_span = time + DELTA*TIME_RESOLUTION
+
+        if span:
+            # mark this event as a control
+            controls.extend([CONTROL_OFFSET+time, CONTROL_OFFSET+dur, CONTROL_OFFSET+note])
+        else:
+            events.extend([time, dur, note])
+
+    return events, controls
+
+
+ANTICIPATION_RATES = 10
+def extract_random(all_events, rate):
+    events = []
+    controls = []
+    for time, dur, note in zip(all_events[0::3],all_events[1::3],all_events[2::3]):
+        assert(note not in [SEPARATOR, REST]) # shouldn't be in the sequence yet
+
+        if np.random.random() < rate/float(ANTICIPATION_RATES):
+            # mark this event as a control
+            controls.extend([CONTROL_OFFSET+time, CONTROL_OFFSET+dur, CONTROL_OFFSET+note])
+        else:
+            events.extend([time, dur, note])
+
+    return events, controls
+
+
+def extract_instruments(all_events, instruments):
+    events = []
+    controls = []
+    for time, dur, note in zip(all_events[0::3],all_events[1::3],all_events[2::3]):
+        assert note < CONTROL_OFFSET         # shouldn't be in the sequence yet
+        assert note not in [SEPARATOR, REST] # these shouldn't either
+
+        instr = (note-NOTE_OFFSET)//2**7
+        if instr in instruments:
+            # mark this event as a control
+            controls.extend([CONTROL_OFFSET+time, CONTROL_OFFSET+dur, CONTROL_OFFSET+note])
+        else:
+            events.extend([time, dur, note])
+
+    return events, controls
+
+
+def maybe_tokenize(compound_tokens):
+    """
+    Tokenizes a sequence of compound tokens if the length is appropriate.
+    Returns the list of events and truncations (number of notes above 10s that were truncated)
+    """
+    # skip sequences with very few events
+    if len(compound_tokens) < COMPOUND_SIZE*MIN_TRACK_EVENTS:
+        return None, None, 1 # short track
+
+    events, truncations = compound_to_events(compound_tokens, stats=True)
+    end_time = ops.max_time(events, seconds=False)
+
+    # don't want to deal with extremely short tracks
+    if end_time < TIME_RESOLUTION*MIN_TRACK_TIME_IN_SECONDS:
+        return None, None, 1 # short track
+
+    # don't want to deal with extremely long tracks
+    if end_time > TIME_RESOLUTION*MAX_TRACK_TIME_IN_SECONDS:
+        return None, None, 2 # long track
+
+    # skip sequences more instruments than MIDI channels (16)
+    if len(ops.get_instruments(events)) > MAX_TRACK_INSTR:
+        return None, None, 3 # too many instruments
+
+    return events, truncations, 0
+
+
+def tokenize_ia(datafiles, output, augment_factor, idx=0, debug=False):
+    assert augment_factor == 1 # can't augment interarrival-tokenized data
+
+    all_truncations = 0
+    seqcount = rest_count = 0
+    stats = 4*[0] # (short, long, too many instruments, inexpressible)
+    np.random.seed(0)
+
+    with open(output, 'w') as outfile:
+        concatenated_tokens = []
+        for j, filename in tqdm(list(enumerate(datafiles)), desc=f'#{idx}', position=idx+1, leave=True):
+            with open(filename, 'r') as f:
+                _, _, status = maybe_tokenize([int(token) for token in f.read().split()])
+
+            if status > 0:
+                stats[status-1] += 1
+                continue
+
+            filename = filename[:-len('.compound.txt')] # get the original MIDI
+
+            # already parsed; shouldn't raise an exception
+            tokens, truncations = midi_to_interarrival(filename, stats=True)
+            tokens[0:0] = [MIDI_SEPARATOR]
+            concatenated_tokens.extend(tokens)
+            all_truncations += truncations
+
+            # write out full sequences to file
+            while len(concatenated_tokens) >= CONTEXT_SIZE:
+                seq = concatenated_tokens[0:CONTEXT_SIZE]
+                concatenated_tokens = concatenated_tokens[CONTEXT_SIZE:]
+                outfile.write(' '.join([str(tok) for tok in seq]) + '\n')
+                seqcount += 1
+
+    if debug:
+        fmt = 'Processed {} sequences (discarded {} tracks, discarded {} seqs, added {} rest tokens)'
+        print(fmt.format(seqcount, stats[0]+stats[1]+stats[2], stats[3], rest_count))
+
+    return (seqcount, rest_count, stats[0], stats[1], stats[2], stats[3], all_truncations)
+
+
+def tokenize(datafiles, output, augment_factor, idx=0, debug=False):
+    """
+    Applies anticipatory tokenization to a list of datafiles, writing the results to output.
+    1. These datafiles should be .txt files containing compound tokenizations, which are converted
+       to events via maybe_tokenize.
+    2. Creates controls out of the events via augment_factor, or no augmentation (pure autoregression)
+       if augment_factor == 1.
+    3. Calls anticipate() to interleave controls and events
+    4. Splits the tokens into sequences of length 1023, which are written to the output
+    """
+    tokens = []
+    all_truncations = 0
+    seqcount = rest_count = 0
+    stats = 4*[0] # (short, long, too many instruments, inexpressible)
+    np.random.seed(0)
+
+    with open(output, 'w') as outfile:
+        concatenated_tokens = []
+        for j, filename in tqdm(list(enumerate(datafiles)), desc=f'#{idx}', position=idx+1, leave=True):
+            with open(filename, 'r') as f:
+                all_events, truncations, status = maybe_tokenize([int(token) for token in f.read().split()])
+
+            if status > 0:
+                stats[status-1] += 1
+                continue
+
+            instruments = list(ops.get_instruments(all_events).keys())
+            end_time = ops.max_time(all_events, seconds=False)
+
+            # different random augmentations
+            for k in range(augment_factor):
+                if k % 10 == 0:
+                    # no augmentation
+                    events = all_events.copy()
+                    controls = []
+                elif k % 10 == 1:
+                    # span augmentation
+                    lmbda = .05
+                    events, controls = extract_spans(all_events, lmbda)
+                elif k % 10 < 6:
+                    # random augmentation
+                    r = np.random.randint(1,ANTICIPATION_RATES)
+                    events, controls = extract_random(all_events, r)
+                else:
+                    if len(instruments) > 1:
+                        # instrument augmentation: at least one, but not all instruments
+                        u = 1+np.random.randint(len(instruments)-1)
+                        subset = np.random.choice(instruments, u, replace=False)
+                        events, controls = extract_instruments(all_events, subset)
+                    else:
+                        # no augmentation
+                        events = all_events.copy()
+                        controls = []
+
+                if len(concatenated_tokens) == 0:
+                    z = ANTICIPATE if k % 10 != 0 else AUTOREGRESS
+
+                all_truncations += truncations
+                events = ops.pad(events, end_time)
+                rest_count += sum(1 if tok == REST else 0 for tok in events[2::3])
+                tokens, controls = ops.anticipate(events, controls)
+                assert len(controls) == 0 # should have consumed all controls (because of padding)
+                tokens[0:0] = [SEPARATOR, SEPARATOR, SEPARATOR]
+                concatenated_tokens.extend(tokens)
+
+                # write out full sequences to file
+                while len(concatenated_tokens) >= EVENT_SIZE*M:
+                    seq = concatenated_tokens[0:EVENT_SIZE*M]
+                    concatenated_tokens = concatenated_tokens[EVENT_SIZE*M:]
+
+                    # relativize time to the context
+                    seq = ops.translate(seq, -ops.min_time(seq, seconds=False), seconds=False)
+                    assert ops.min_time(seq, seconds=False) == 0
+                    if ops.max_time(seq, seconds=False) >= MAX_TIME:
+                        stats[3] += 1
+                        continue
+
+                    # if seq contains SEPARATOR, global controls describe the first sequence
+                    seq.insert(0, z)
+
+                    outfile.write(' '.join([str(tok) for tok in seq]) + '\n')
+                    seqcount += 1
+
+                    # grab the current augmentation controls if we didn't already
+                    z = ANTICIPATE if k % 10 != 0 else AUTOREGRESS
+
+    if debug:
+        fmt = 'Processed {} sequences (discarded {} tracks, discarded {} seqs, added {} rest tokens)'
+        print(fmt.format(seqcount, stats[0]+stats[1]+stats[2], stats[3], rest_count))
+
+    return (seqcount, rest_count, stats[0], stats[1], stats[2], stats[3], all_truncations)
+
+
+def tokenize2(datafiles, output, idx=0, debug=False):
+    """
+    Applies anticipatory tokenization to a list of datafiles where each is a tuple
+    (file1, file2, file3, file4) with 
+    1. file1 being the path to the performance MIDI file
+    2. file2 being the path to the score MIDI file
+    3. file3 being the path to the performance annotation file
+    4. file4 being the path to the score annotation file
+
+    Note: This is the old tokenization process that uses anticipation with mapping
+    """
+    tokens = []
+    all_truncations = 0
+    seqcount = rest_count = 0
+    stats = 4*[0] # (short, long, too many instruments, inexpressible)
+    np.random.seed(0)
+
+    with open(output, 'w') as outfile:
+        concatenated_tokens = []
+        for j, filegroup in tqdm(list(enumerate(datafiles)), desc=f'#{idx}', position=idx+1, leave=True):
+
+            file1, file2 = midi_to_compound(filegroup[0]), midi_to_compound(filegroup[1])
+            file3, file4 = filegroup[2], filegroup[3]
+
+            controls, truncations_c, _ = maybe_tokenize(file1)
+            controls = [CONTROL_OFFSET+token for token in controls] # mark these tokens as controls
+            all_events, truncations_e, _ = maybe_tokenize(file2)
+
+            z = ANTICIPATE
+
+            all_truncations += truncations_c + truncations_e
+
+            # only need to pad the events 
+            events = ops.pad(all_events, end_time=ops.max_time(all_events, seconds=False))
+
+            rest_count += sum(1 if tok == REST else 0 for tok in events[2::3])
+
+            map = compare_annotations(file4, file3) # create mapping from score to performance
+            tokens, controls = ops.anticipate2(events, controls, map)
+
+            assert len(controls) == 0 # should have consumed all controls (because of padding)
+            tokens[0:0] = [SEPARATOR, SEPARATOR, SEPARATOR]
+            concatenated_tokens.extend(tokens)
+
+            # write sequences of length EVENT_SIZE*M = 1023 to the output file,
+            # any extra remain in concatenated_tokens for the next input file.      
+            while len(concatenated_tokens) >= EVENT_SIZE*M:
+                seq = concatenated_tokens[0:EVENT_SIZE*M]
+                concatenated_tokens = concatenated_tokens[EVENT_SIZE*M:]
+
+                # make sure each sequence starts at time 0
+                seq = ops.translate(seq, -ops.min_time(seq, seconds=False), seconds=False)
+                assert ops.min_time(seq, seconds=False) == 0
+                if ops.max_time(seq, seconds=False) >= MAX_TIME:
+                    stats[3] += 1
+                    continue
+
+                # if seq contains SEPARATOR, global controls describe the first sequence
+                seq.insert(0, z)
+
+                outfile.write(' '.join([str(tok) for tok in seq]) + '\n')
+                seqcount += 1
+
+    if debug:
+        fmt = 'Processed {} sequences (discarded {} tracks, discarded {} seqs, added {} rest tokens)'
+        print(fmt.format(seqcount, stats[0]+stats[1]+stats[2], stats[3], rest_count))
+
+    return (seqcount, rest_count, stats[0], stats[1], stats[2], stats[3], all_truncations)
+
+def tokenize3(datafiles, output, idx=0, debug=False, skip_Nones=True):
+    """
+    Applies anticipatory tokenization to a list of datafiles where each is a tuple
+    (file1, file2, file3, file4) with 
+    1. file1 being the path to the performance MIDI file
+    2. file2 being the path to the score MIDI file
+    3. file3 being the path to the performance annotation file
+    4. file4 being the path to the score annotation file
+
+    Note: This is the new tokenization process that alternates score and perf tokens and inserts 
+          None,None,None tokens whenver a corresponding score token cannot be found.
+    """
+    tokens = []
+    all_truncations = 0
+    seqcount = rest_count = 0
+    stats = 4*[0] # (short, long, too many instruments, inexpressible)
+    np.random.seed(0)
+
+    with open(output, 'w') as outfile:
+        concatenated_tokens = []
+        for j, filegroup in tqdm(list(enumerate(datafiles)), desc=f'#{idx}', position=idx+1, leave=True):
+
+            file1,file2,file3,file4 = filegroup
+
+            print(f'Now aligning {file1} and {file2}')
+            matched_tuples = align_tokens2(file1,file2,file3,file4,skip_Nones=skip_Nones)
+
+            # interleave the tokens via alternation
+            interleaved_tokens = []
+
+            for i, l in enumerate(matched_tuples):
+                if l[0][0]-CONTROL_OFFSET <= DELTA*TIME_RESOLUTION:
+                    interleaved_tokens.extend(l[0])
+
+            prefix_len = int(len(interleaved_tokens)/3)
+
+            for i, l in enumerate(matched_tuples):
+                if i < len(matched_tuples)-prefix_len:
+                    interleaved_tokens.extend(l[2])
+                    interleaved_tokens.extend(matched_tuples[i+prefix_len][0])
+                else:
+                    interleaved_tokens.extend(l[2])
+
+            # print(interleaved_tokens)
+
+            # because we already have a sequence of interleaved tokens, don't want to make any truncations
+            # controls, truncations_c, _ = maybe_tokenize(file1)
+            # controls = [CONTROL_OFFSET+token for token in controls] # mark these tokens as controls
+            # all_events, truncations_e, _ = maybe_tokenize(file2)
+
+            z = ANTICIPATE
+
+            # all_truncations += truncations_c + truncations_e
+
+            # only need to pad the events 
+            # events = ops.pad(all_events, end_time=ops.max_time(all_events, seconds=False))
+
+            # rest_count += sum(1 if tok == REST else 0 for tok in events[2::3])
+
+            # map = compare_annotations(file4, file3) # create mapping from score to performance
+            # tokens, controls = ops.anticipate2(events, controls, map)
+
+            # assert len(controls) == 0 # should have consumed all controls (because of padding)
+
+            # separator is a special token with value 55025
+            tokens[0:0] = [SEPARATOR, SEPARATOR, SEPARATOR]
+            concatenated_tokens.extend(interleaved_tokens)
+
+            # write sequences of length EVENT_SIZE*M = 1023 to the output file,
+            # any extra remain in concatenated_tokens for the next input file.      
+            while len(concatenated_tokens) >= EVENT_SIZE*M:
+                seq = concatenated_tokens[0:EVENT_SIZE*M]
+                concatenated_tokens = concatenated_tokens[EVENT_SIZE*M:]
+
+                # make sure each sequence starts at time 0 (shifts each token's arrival time by the 
+                # min time of the sequence, accounting for control offsets)
+                seq = ops.translate(seq, -ops.min_time(seq, seconds=False), seconds=False)
+                assert ops.min_time(seq, seconds=False) == 0
+                if ops.max_time(seq, seconds=False) >= MAX_TIME:
+                    stats[3] += 1
+                    continue
+
+                # if seq contains SEPARATOR, global controls describe the first sequence
+                seq.insert(0, z)
+
+                outfile.write(' '.join([str(tok) for tok in seq]) + '\n')
+                seqcount += 1
+
+    if debug:
+        fmt = 'Processed {} sequences (discarded {} tracks, discarded {} seqs, added {} rest tokens)'
+        print(fmt.format(seqcount, stats[0]+stats[1]+stats[2], stats[3], rest_count))
+
+    return (seqcount, rest_count, stats[0], stats[1], stats[2], stats[3], all_truncations)

anticipation/visuals.py

@@ -0,0 +1,65 @@
+"""
+Utilities for inspecting encoded music data.
+"""
+
+import numpy as np
+
+import matplotlib
+import matplotlib.pyplot as plt
+
+import anticipation.ops as ops
+from anticipation.config import *
+from anticipation.vocab import *
+
+def visualize(tokens, output, selected=None):
+    #colors = ['white', 'silver', 'red', 'sienna', 'darkorange', 'gold', 'yellow', 'palegreen', 'seagreen', 'cyan',
+    #          'dodgerblue', 'slategray', 'navy', 'mediumpurple', 'mediumorchid', 'magenta', 'lightpink']
+    colors = ['white', '#426aa0', '#b26789', '#de9283', '#eac29f', 'silver', 'red', 'sienna', 'darkorange', 'gold', 'yellow', 'palegreen', 'seagreen', 'cyan', 'dodgerblue', 'slategray', 'navy']
+
+    plt.rcParams['figure.dpi'] = 300
+    plt.rcParams['savefig.dpi'] = 300
+ 
+    max_time = ops.max_time(tokens, seconds=False)
+    grid = np.zeros([max_time, MAX_PITCH])
+    instruments = list(sorted(list(ops.get_instruments(tokens).keys())))
+    if 128 in instruments:
+        instruments.remove(128)
+ 
+    for j, (tm, dur, note) in enumerate(zip(tokens[0::3],tokens[1::3],tokens[2::3])):
+        if note == SEPARATOR:
+            assert tm == SEPARATOR and dur == SEPARATOR
+            print(j, 'SEPARATOR')
+            continue
+
+        if note == REST:
+            continue
+
+        assert note < CONTROL_OFFSET
+
+        tm = tm - TIME_OFFSET
+        dur = dur - DUR_OFFSET
+        note = note - NOTE_OFFSET
+        instr = note//2**7
+        pitch = note - (2**7)*instr
+
+        if instr == 128: # drums
+            continue     # we don't visualize this
+
+        if selected and instr not in selected:
+            continue
+
+        grid[tm:tm+dur, pitch] = 1+instruments.index(instr)
+
+    plt.clf()
+    plt.axis('off')
+    cmap = matplotlib.colors.ListedColormap(colors)
+    bounds = list(range(MAX_TRACK_INSTR)) + [16]
+    norm = matplotlib.colors.BoundaryNorm(bounds, cmap.N)
+    plt.imshow(np.flipud(grid.T), aspect=16, cmap=cmap, norm=norm, interpolation='none')
+
+    patches = [matplotlib.patches.Patch(color=colors[i+1], label=f"{instruments[i]}")
+               for i in range(len(instruments))]
+    plt.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0. )
+
+    plt.tight_layout()
+    plt.savefig(output)

anticipation/vocab.py

@@ -0,0 +1,58 @@
+"""
+The vocabularies used for arrival-time and interarrival-time encodings.
+"""
+
+# training sequence vocab
+
+from anticipation.config import *
+
+# the event block
+EVENT_OFFSET = 0
+TIME_OFFSET = EVENT_OFFSET
+DUR_OFFSET = TIME_OFFSET + MAX_TIME
+NOTE_OFFSET = DUR_OFFSET + MAX_DUR
+REST = NOTE_OFFSET + MAX_NOTE
+
+# the control block
+CONTROL_OFFSET = NOTE_OFFSET + MAX_NOTE + 1
+ATIME_OFFSET = CONTROL_OFFSET + 0
+ADUR_OFFSET = ATIME_OFFSET + MAX_TIME
+ANOTE_OFFSET = ADUR_OFFSET + MAX_DUR
+
+# the special block
+SPECIAL_OFFSET = ANOTE_OFFSET + MAX_NOTE
+SEPARATOR = SPECIAL_OFFSET
+AUTOREGRESS = SPECIAL_OFFSET + 1
+ANTICIPATE = SPECIAL_OFFSET + 2
+VOCAB_SIZE = ANTICIPATE+1
+
+# interarrival-time (MIDI-like) vocab
+MIDI_TIME_OFFSET = 0
+MIDI_START_OFFSET = MIDI_TIME_OFFSET + MAX_INTERARRIVAL
+MIDI_END_OFFSET = MIDI_START_OFFSET + MAX_NOTE
+MIDI_SEPARATOR = MIDI_END_OFFSET + MAX_NOTE
+MIDI_VOCAB_SIZE = MIDI_SEPARATOR + 1
+
+if __name__ == '__main__':
+    print('Arrival-Time Training Sequence Format:')
+    print('Event Offset: ', EVENT_OFFSET)
+    print('  -> time offset :', TIME_OFFSET)
+    print('  -> duration offset :', DUR_OFFSET)
+    print('  -> note offset :', NOTE_OFFSET)
+    print('  -> rest token: ', REST)
+    print('Anticipated Control Offset: ', CONTROL_OFFSET)
+    print('  -> anticipated time offset :', ATIME_OFFSET)
+    print('  -> anticipated duration offset :', ADUR_OFFSET)
+    print('  -> anticipated note offset :', ANOTE_OFFSET)
+    print('Special Token Offset: ', SPECIAL_OFFSET)
+    print('  -> separator token: ', SEPARATOR)
+    print('  -> autoregression flag: ', AUTOREGRESS)
+    print('  -> anticipation flag: ', ANTICIPATE)
+    print('Arrival Encoding Vocabulary Size: ', VOCAB_SIZE)
+    print('')
+    print('Interarrival-Time Training Sequence Format:')
+    print('  -> time offset: ', MIDI_TIME_OFFSET)
+    print('  -> note-on offset: ', MIDI_START_OFFSET)
+    print('  -> note-off offset: ', MIDI_END_OFFSET)
+    print('  -> separator token: ', MIDI_SEPARATOR)
+    print('Interarrival Encoding Vocabulary Size: ', MIDI_VOCAB_SIZE)

asap-dataset-master/Bach/Fugue/bwv_846/Shi05M_annotations.txt

@@ -0,0 +1,106 @@
+1.0950520000000001	1.0950520000000001	b,,0
+2.364583	2.364583	b
+3.66276	3.66276	b
+4.924479	4.924479	db,4/4
+6.210938	6.210938	b
+7.497396000000001	7.497396000000001	b
+8.639323	8.639323	b
+9.818359	9.818359	db
+11.042317	11.042317	b
+12.251302	12.251302	b
+13.502604000000002	13.502604000000002	b
+14.721354999999999	14.721354999999999	db
+15.946615	15.946615	b
+17.155599	17.155599	b
+18.324219	18.324219	b
+19.564453	19.564453	db
+20.798828	20.798828	b
+22.010417	22.010417	b
+23.303819	23.303819	b
+24.564128	24.564128	db
+25.757378	25.757378	b
+27.005209000000004	27.005209000000004	b
+28.206163	28.206163	b
+29.405599	29.405599	db
+30.61198	30.61198	b
+31.81987800000001	31.81987800000001	b
+33.057726	33.057726	b
+34.286892	34.286892	db
+35.509766	35.509766	b
+36.789714000000004	36.789714000000004	b
+38.077474	38.077474	b
+39.503254999999996	39.503254999999996	db
+40.701389	40.701389	b
+41.920139	41.920139	b
+43.140190999999994	43.140190999999994	b
+44.348958	44.348958	db
+45.572266	45.572266	b
+46.886285	46.886285	b
+48.307943	48.307943	b
+49.560764	49.560764	db
+50.781902	50.781902	b
+52.022135	52.022135	b
+53.286457999999996	53.286457999999996	b
+54.525391000000006	54.525391000000006	db
+55.806424	55.806424	b
+57.069336	57.069336	b
+58.253255	58.253255	b
+59.508246	59.508246	db
+60.778645	60.778645	b
+62.015625	62.015625	b
+63.40234399999999	63.40234399999999	b
+65.034722	65.034722	db
+66.674479	66.674479	b
+67.992839	67.992839	b
+69.281901	69.281901	b
+70.520834	70.520834	db
+71.84700500000002	71.84700500000002	b
+73.13736999999998	73.13736999999998	b
+74.381185	74.381185	b
+75.654948	75.654948	db
+76.88107600000002	76.88107600000002	b
+78.101562	78.101562	b
+79.407986	79.407986	b
+80.680555	80.680555	db
+81.935873	81.935873	b
+83.467014	83.467014	b
+84.91059	84.91059	b
+86.196614	86.196614	db
+87.561198	87.561198	b
+88.796875	88.796875	b
+90.025391	90.025391	b
+91.22743100000001	91.22743100000001	db
+92.546729	92.546729	b
+94.398112	94.398112	b
+95.845703	95.845703	b
+97.080078	97.080078	db
+98.30013000000001	98.30013000000001	b
+99.515625	99.515625	b
+100.772786	100.772786	b
+102.036458	102.036458	db
+103.23893199999999	103.23893199999999	b
+104.423828	104.423828	b
+105.63151	105.63151	b
+106.889974	106.889974	db
+108.09700500000001	108.09700500000001	b
+109.379232	109.379232	b
+110.68446200000001	110.68446200000001	b
+111.941732	111.941732	db
+113.167318	113.167318	b
+114.5	114.5	b
+116.00846399999999	116.00846399999999	b
+117.830729	117.830729	db
+119.62174499999999	119.62174499999999	b
+121.011067	121.011067	b
+122.38151	122.38151	b
+123.727864	123.727864	db
+125.05664099999998	125.05664099999998	b
+126.307942	126.307942	b
+127.67903600000001	127.67903600000001	b
+129.14800400000001	129.14800400000001	db
+130.71875	130.71875	b
+132.488281	132.488281	b
+134.296875	134.296875	b
+136.052083	136.052083	db
+138.016927	138.016927	b
+140.876303	140.876303	b

asap-dataset-master/Bach/Fugue/bwv_846/midi_score_annotations.txt

@@ -0,0 +1,106 @@
+0.5	0.5	b,,0
+1.0	1.0	b
+1.5	1.5	b
+2.0	2.0	db,4/4
+2.5	2.5	b
+3.0	3.0	b
+3.5	3.5	b
+4.0	4.0	db
+4.5	4.5	b
+5.0	5.0	b
+5.5	5.5	b
+6.0	6.0	db
+6.5	6.5	b
+7.0	7.0	b
+7.5	7.5	b
+8.0	8.0	db
+8.5	8.5	b
+9.0	9.0	b
+9.5	9.5	b
+10.0	10.0	db
+10.5	10.5	b
+11.0	11.0	b
+11.5	11.5	b
+12.0	12.0	db
+12.5	12.5	b
+13.0	13.0	b
+13.5	13.5	b
+14.0	14.0	db
+14.5	14.5	b
+15.0	15.0	b
+15.5	15.5	b
+16.0	16.0	db
+16.5	16.5	b
+17.0	17.0	b
+17.5	17.5	b
+18.0	18.0	db
+18.5	18.5	b
+19.0	19.0	b
+19.5	19.5	b
+20.0	20.0	db
+20.5	20.5	b
+21.0	21.0	b
+21.5	21.5	b
+22.0	22.0	db
+22.5	22.5	b
+23.0	23.0	b
+23.5	23.5	b
+24.0	24.0	db
+24.5	24.5	b
+25.0	25.0	b
+25.5	25.5	b
+26.0	26.0	db
+26.5	26.5	b
+27.0	27.0	b
+27.5	27.5	b
+28.0	28.0	db
+28.5	28.5	b
+29.0	29.0	b
+29.5	29.5	b
+30.0	30.0	db
+30.5	30.5	b
+31.0	31.0	b
+31.5	31.5	b
+32.0	32.0	db
+32.5	32.5	b
+33.0	33.0	b
+33.5	33.5	b
+34.0	34.0	db
+34.5	34.5	b
+35.0	35.0	b
+35.5	35.5	b
+36.0	36.0	db
+36.5	36.5	b
+37.0	37.0	b
+37.5	37.5	b
+38.0	38.0	db
+38.5	38.5	b
+39.0	39.0	b
+39.5	39.5	b
+40.0	40.0	db
+40.5	40.5	b
+41.0	41.0	b
+41.5	41.5	b
+42.0	42.0	db
+42.5	42.5	b
+43.0	43.0	b
+43.5	43.5	b
+44.0	44.0	db
+44.5	44.5	b
+45.0	45.0	b
+45.5	45.5	b
+46.0	46.0	db
+46.5	46.5	b
+47.0	47.0	b
+47.5	47.5	b
+48.0	48.0	db
+48.5	48.5	b
+49.0	49.0	b
+49.5	49.5	b
+50.0	50.0	db
+50.5	50.5	b
+51.0	51.0	b
+51.5	51.5	b
+52.0	52.0	db
+52.5	52.5	b
+53.0	53.0	b

asap-dataset-master/Bach/Fugue/bwv_848/Denisova06M_annotations.txt

@@ -0,0 +1,217 @@
+0.825521	0.825521	b,,7
+1.341146	1.341146	b
+1.9335939999999998	1.9335939999999998	db,4/4
+2.467448	2.467448	b
+3.005208	3.005208	b
+3.5664059999999997	3.5664059999999997	b
+4.113281	4.113281	db
+4.6354169999999995	4.6354169999999995	b
+5.147136	5.147136	b
+5.664713	5.664713	b
+6.186198	6.186198	db
+6.738281	6.738281	b
+7.274088000000001	7.274088000000001	b
+7.792317999999999	7.792317999999999	b
+8.280599	8.280599	db
+8.783854	8.783854	b
+9.29948	9.29948	b
+9.792100999999999	9.792100999999999	b
+10.307292	10.307292	db
+10.832682	10.832682	b
+11.343099	11.343099	b
+11.835069	11.835069	b
+12.343099	12.343099	db
+12.861979	12.861979	b
+13.371094	13.371094	b
+13.860676999999999	13.860676999999999	b
+14.365885999999998	14.365885999999998	db
+14.873698000000001	14.873698000000001	b
+15.39388	15.39388	b
+15.877604000000002	15.877604000000002	b
+16.389974	16.389974	db
+16.913412	16.913412	b
+17.398438	17.398438	b
+17.879557000000005	17.879557000000005	b
+18.378906	18.378906	db
+18.875651	18.875651	b
+19.370442999999998	19.370442999999998	b
+19.860677	19.860677	b
+20.392360999999998	20.392360999999998	db
+20.922526	20.922526	b
+21.426215	21.426215	b
+21.947048000000002	21.947048000000002	b
+22.447917	22.447917	db
+22.964192	22.964192	b
+23.438802	23.438802	b
+23.92513	23.92513	b
+24.450521	24.450521	db
+24.971355	24.971355	b
+25.487413	25.487413	b
+25.962239999999998	25.962239999999998	b
+26.477431	26.477431	db
+26.958333000000003	26.958333000000003	b
+27.435546999999996	27.435546999999996	b
+27.940103999999998	27.940103999999998	b
+28.464192999999998	28.464192999999998	db
+28.97526	28.97526	b
+29.48567700000001	29.48567700000001	b
+29.986328000000004	29.986328000000004	b
+30.44401	30.44401	db
+30.936849	30.936849	b
+31.427083000000003	31.427083000000003	b
+31.901692999999998	31.901692999999998	b
+32.376953	32.376953	db
+32.863281	32.863281	b
+33.337891	33.337891	b
+33.819660999999996	33.819660999999996	b
+34.291016	34.291016	db
+34.769531	34.769531	b
+35.24348900000001	35.24348900000001	b
+35.71875	35.71875	b
+36.208984	36.208984	db
+36.688151	36.688151	b
+37.182292	37.182292	b
+37.660807	37.660807	b
+38.182292	38.182292	db
+38.688802	38.688802	b
+39.188151	39.188151	b
+39.707465	39.707465	b
+40.240885999999996	40.240885999999996	db
+40.752604	40.752604	b
+41.243924	41.243924	b
+41.755642	41.755642	b
+42.259549	42.259549	db
+42.733724	42.733724	b
+43.284288000000004	43.284288000000004	b
+43.77474	43.77474	b
+44.263020000000004	44.263020000000004	db
+44.759766	44.759766	b
+45.285156	45.285156	b
+45.776041	45.776041	b
+46.263672	46.263672	db
+46.763672	46.763672	b
+47.275391	47.275391	b
+47.756510999999996	47.756510999999996	b
+48.237629999999996	48.237629999999996	db
+48.73090300000001	48.73090300000001	b
+49.251302	49.251302	b
+49.770833	49.770833	b
+50.246745000000004	50.246745000000004	db
+50.746961999999996	50.746961999999996	b
+51.243922999999995	51.243922999999995	b
+51.757813	51.757813	b
+52.225260999999996	52.225260999999996	db
+52.726996	52.726996	b
+53.225910999999996	53.225910999999996	b
+53.77734399999999	53.77734399999999	b
+54.25260400000001	54.25260400000001	db
+54.761067000000004	54.761067000000004	b
+55.25260400000001	55.25260400000001	b
+55.76888	55.76888	b
+56.264974	56.264974	db
+56.757160999999996	56.757160999999996	b
+57.257813	57.257813	b
+57.764323	57.764323	b
+58.26215300000001	58.26215300000001	db
+58.764323	58.764323	b
+59.265625	59.265625	b
+59.755207999999996	59.755207999999996	b
+60.240233999999994	60.240233999999994	db
+60.70703100000001	60.70703100000001	b
+61.171875	61.171875	b
+61.66015600000001	61.66015600000001	b
+62.126953	62.126953	db
+62.597005	62.597005	b
+63.059245	63.059245	b
+63.546224	63.546224	b
+64.015625	64.015625	db
+64.486328	64.486328	b
+64.936198	64.936198	b
+65.389323	65.389323	b
+65.86067800000001	65.86067800000001	db
+66.317709	66.317709	b
+66.811198	66.811198	b
+67.294271	67.294271	b
+67.78775999999999	67.78775999999999	db
+68.231771	68.231771	b
+68.751302	68.751302	b
+69.24349000000001	69.24349000000001	b
+69.722656	69.722656	db
+70.195964	70.195964	b
+70.716146	70.716146	b
+71.19205699999998	71.19205699999998	b
+71.666667	71.666667	db
+72.134114	72.134114	b
+72.654948	72.654948	b
+73.144531	73.144531	b
+73.619792	73.619792	db
+74.085286	74.085286	b
+74.610677	74.610677	b
+75.089844	75.089844	b
+75.66275999999998	75.66275999999998	db
+76.201823	76.201823	b
+76.710938	76.710938	b
+77.20768299999997	77.20768299999997	b
+77.695964	77.695964	db
+78.210938	78.210938	b
+78.70638000000002	78.70638000000002	b
+79.175781	79.175781	b
+79.661459	79.661459	db
+80.146484	80.146484	b
+80.661458	80.661458	b
+81.132813	81.132813	b
+81.61393299999997	81.61393299999997	db
+82.085938	82.085938	b
+82.586589	82.586589	b
+83.07356700000003	83.07356700000003	b
+83.59700500000002	83.59700500000002	db
+84.121094	84.121094	b
+84.61263000000002	84.61263000000002	b
+85.119791	85.119791	b
+85.641276	85.641276	db
+86.103515	86.103515	b
+86.587239	86.587239	b
+87.072482	87.072482	b
+87.583334	87.583334	db
+88.10611999999998	88.10611999999998	b
+88.59700500000002	88.59700500000002	b
+89.08138000000002	89.08138000000002	b
+89.578776	89.578776	db
+90.080729	90.080729	b
+90.58138000000001	90.58138000000001	b
+91.04774300000001	91.04774300000001	b
+91.57486999999999	91.57486999999999	db
+92.074219	92.074219	b
+92.588541	92.588541	b
+93.061198	93.061198	b
+93.580078	93.580078	db
+94.065104	94.065104	b
+94.587239	94.587239	b
+95.08268299999999	95.08268299999999	b
+95.608724	95.608724	db
+96.083984	96.083984	b
+96.589844	96.589844	b
+97.084636	97.084636	b
+97.602214	97.602214	db
+98.078776	98.078776	b
+98.586589	98.586589	b
+99.093099	99.093099	b
+99.596354	99.596354	db
+100.054688	100.054688	b
+100.55924499999999	100.55924499999999	b
+101.04361999999999	101.04361999999999	b
+101.549479	101.549479	db
+102.029514	102.029514	b
+102.56466999999999	102.56466999999999	b
+103.061849	103.061849	b
+103.57204899999999	103.57204899999999	db
+104.084202	104.084202	b
+104.58810799999999	104.58810799999999	b
+105.05924499999999	105.05924499999999	b
+105.53710900000002	105.53710900000002	db
+106.00716100000001	106.00716100000001	b
+106.48111999999999	106.48111999999999	b
+106.94791699999999	106.94791699999999	b
+107.501953	107.501953	db
+108.185221	108.185221	b
+109.11849	109.11849	b

asap-dataset-master/Bach/Fugue/bwv_848/Lee01M_annotations.txt

@@ -0,0 +1,217 @@
+0.846354	0.846354	b,,7
+1.4375	1.4375	b
+2.085938	2.085938	db,4/4
+2.7005209999999997	2.7005209999999997	b
+3.3359379999999996	3.3359379999999996	b
+3.951823000000001	3.951823000000001	b
+4.597656	4.597656	db
+5.19401	5.19401	b
+5.758463	5.758463	b
+6.327474	6.327474	b
+6.9069009999999995	6.9069009999999995	db
+7.494791999999999	7.494791999999999	b
+8.096355	8.096355	b
+8.647786	8.647786	b
+9.206380000000001	9.206380000000001	db
+9.757161	9.757161	b
+10.335286	10.335286	b
+10.880642	10.880642	b
+11.494791000000001	11.494791000000001	db
+12.086589	12.086589	b
+12.670573	12.670573	b
+13.226563	13.226563	b
+13.803385	13.803385	db
+14.38737	14.38737	b
+14.973307	14.973307	b
+15.531901000000001	15.531901000000001	b
+16.116537	16.116537	db
+16.707031	16.707031	b
+17.268881	17.268881	b
+17.843099	17.843099	b
+18.420573	18.420573	db
+19.000651	19.000651	b
+19.583984	19.583984	b
+20.154948	20.154948	b
+20.698567999999998	20.698567999999998	db
+21.261067999999998	21.261067999999998	b
+21.839844	21.839844	b
+22.395398999999998	22.395398999999998	b
+22.976562	22.976562	db
+23.569011	23.569011	b
+24.142360999999998	24.142360999999998	b
+24.706163	24.706163	b
+25.299479	25.299479	db
+25.873047	25.873047	b
+26.442057000000002	26.442057000000002	b
+26.994790999999996	26.994790999999996	b
+27.566406	27.566406	db
+28.188151	28.188151	b
+28.764322999999997	28.764322999999997	b
+29.337891	29.337891	b
+29.898871000000003	29.898871000000003	db
+30.464844	30.464844	b
+31.014322999999997	31.014322999999997	b
+31.564453000000004	31.564453000000004	b
+32.158854	32.158854	db
+32.714844	32.714844	b
+33.300781	33.300781	b
+33.871094	33.871094	b
+34.421875	34.421875	db
+34.981120000000004	34.981120000000004	b
+35.556641	35.556641	b
+36.103516	36.103516	b
+36.645833	36.645833	db
+37.210938	37.210938	b
+37.78776	37.78776	b
+38.34375	38.34375	b
+38.870443	38.870443	db
+39.433594	39.433594	b
+39.976563	39.976563	b
+40.543620000000004	40.543620000000004	b
+41.085938	41.085938	db
+41.636067	41.636067	b
+42.231771	42.231771	b
+42.770182	42.770182	b
+43.359375	43.359375	db
+43.963542	43.963542	b
+44.512370000000004	44.512370000000004	b
+45.071614000000004	45.071614000000004	b
+45.609375	45.609375	db
+46.203125	46.203125	b
+46.778646	46.778646	b
+47.371961999999996	47.371961999999996	b
+47.910157	47.910157	db
+48.503254999999996	48.503254999999996	b
+49.079427	49.079427	b
+49.667969	49.667969	b
+50.208984	50.208984	db
+50.759115	50.759115	b
+51.332031	51.332031	b
+51.894531	51.894531	b
+52.465495	52.465495	db
+53.042318	53.042318	b
+53.60612	53.60612	b
+54.169922	54.169922	b
+54.714193	54.714193	db
+55.26215300000001	55.26215300000001	b
+55.853516000000006	55.853516000000006	b
+56.454428	56.454428	b
+57.005858999999994	57.005858999999994	db
+57.57595500000001	57.57595500000001	b
+58.148437	58.148437	b
+58.71875	58.71875	b
+59.322916000000006	59.322916000000006	db
+59.875	59.875	b
+60.452474	60.452474	b
+61.036457999999996	61.036457999999996	b
+61.61328100000001	61.61328100000001	db
+62.17578100000001	62.17578100000001	b
+62.71875	62.71875	b
+63.27474	63.27474	b
+63.80859399999999	63.80859399999999	db
+64.388672	64.388672	b
+64.949219	64.949219	b
+65.566406	65.566406	b
+66.143663	66.143663	db
+66.710938	66.710938	b
+67.29231700000001	67.29231700000001	b
+67.860026	67.860026	b
+68.40625	68.40625	db
+68.935547	68.935547	b
+69.490235	69.490235	b
+70.045573	70.045573	b
+70.591797	70.591797	db
+71.152344	71.152344	b
+71.681641	71.681641	b
+72.249349	72.249349	b
+72.768229	72.768229	db
+73.263671	73.263671	b
+73.765625	73.765625	b
+74.296875	74.296875	b
+74.822266	74.822266	db
+75.353516	75.353516	b
+75.898438	75.898438	b
+76.44400999999998	76.44400999999998	b
+76.976562	76.976562	db
+77.514974	77.514974	b
+78.091146	78.091146	b
+78.62825500000002	78.62825500000002	b
+79.191406	79.191406	db
+79.735677	79.735677	b
+80.298828	80.298828	b
+80.850911	80.850911	b
+81.42838499999998	81.42838499999998	db
+81.983073	81.983073	b
+82.55143299999997	82.55143299999997	b
+83.113281	83.113281	b
+83.662109	83.662109	db
+84.218099	84.218099	b
+84.768229	84.768229	b
+85.31575500000002	85.31575500000002	b
+85.864583	85.864583	db
+86.41861999999998	86.41861999999998	b
+87.011719	87.011719	b
+87.541667	87.541667	b
+88.095052	88.095052	db
+88.65755300000002	88.65755300000002	b
+89.239584	89.239584	b
+89.77018299999996	89.77018299999996	b
+90.322266	90.322266	db
+90.857422	90.857422	b
+91.416666	91.416666	b
+91.934896	91.934896	b
+92.486979	92.486979	db
+93.039714	93.039714	b
+93.591146	93.591146	b
+94.140625	94.140625	b
+94.71875	94.71875	db
+95.300781	95.300781	b
+95.88150999999999	95.88150999999999	b
+96.463542	96.463542	b
+97.047527	97.047527	db
+97.614584	97.614584	b
+98.173828	98.173828	b
+98.726563	98.726563	b
+99.311198	99.311198	db
+99.863281	99.863281	b
+100.46549499999999	100.46549499999999	b
+101.013021	101.013021	b
+101.577474	101.577474	db
+102.15169200000001	102.15169200000001	b
+102.727214	102.727214	b
+103.28559	103.28559	b
+103.87174499999999	103.87174499999999	db
+104.45638000000001	104.45638000000001	b
+105.03906299999998	105.03906299999998	b
+105.61111100000001	105.61111100000001	b
+106.151692	106.151692	db
+106.73763000000001	106.73763000000001	b
+107.31835900000002	107.31835900000002	b
+107.88541699999999	107.88541699999999	b
+108.45638000000001	108.45638000000001	db
+109.018229	109.018229	b
+109.60156299999998	109.60156299999998	b
+110.20833300000001	110.20833300000001	b
+110.77083300000001	110.77083300000001	db
+111.345703	111.345703	b
+111.93033899999999	111.93033899999999	b
+112.49283899999999	112.49283899999999	b
+113.079427	113.079427	db
+113.63216100000001	113.63216100000001	b
+114.202474	114.202474	b
+114.72721399999999	114.72721399999999	b
+115.3125	115.3125	db
+115.87716999999999	115.87716999999999	b
+116.480903	116.480903	b
+117.05273400000002	117.05273400000002	b
+117.610677	117.610677	db
+118.18533000000001	118.18533000000001	b
+118.741753	118.741753	b
+119.292317	119.292317	b
+119.832031	119.832031	db
+120.372396	120.372396	b
+120.89974	120.89974	b
+121.45833300000001	121.45833300000001	b
+122.05599	122.05599	db
+122.75520800000001	122.75520800000001	b
+123.87161499999999	123.87161499999999	b

asap-dataset-master/Bach/Fugue/bwv_848/LeeSH01M_annotations.txt

@@ -0,0 +1,217 @@
+0.855208	0.855208	b,,7
+1.520833	1.520833	b
+2.229167	2.229167	db,4/4
+2.928125	2.928125	b
+3.6427080000000003	3.6427080000000003	b
+4.375	4.375	b
+5.0885419999999995	5.0885419999999995	db
+5.767708	5.767708	b
+6.419792	6.419792	b
+7.058333	7.058333	b
+7.727603999999999	7.727603999999999	db
+8.402083	8.402083	b
+9.067708	9.067708	b
+9.753125	9.753125	b
+10.4	10.4	db
+11.048958	11.048958	b
+11.703125	11.703125	b
+12.336111	12.336111	b
+12.983333	12.983333	db
+13.632291	13.632291	b
+14.290625	14.290625	b
+14.966667000000001	14.966667000000001	b
+15.613021	15.613021	db
+16.303125	16.303125	b
+16.961458	16.961458	b
+17.606771	17.606771	b
+18.277084	18.277084	db
+18.970312	18.970312	b
+19.645312	19.645312	b
+20.317187	20.317187	b
+20.957292000000002	20.957292000000002	db
+21.65625	21.65625	b
+22.308332999999998	22.308332999999998	b
+22.916666	22.916666	b
+23.563021	23.563021	db
+24.198957999999998	24.198957999999998	b
+24.852605	24.852605	b
+25.493403	25.493403	b
+26.1625	26.1625	db
+26.83125	26.83125	b
+27.484721999999998	27.484721999999998	b
+28.146875	28.146875	b
+28.786806	28.786806	db
+29.442708000000003	29.442708000000003	b
+30.080208000000002	30.080208000000002	b
+30.697396	30.697396	b
+31.277603999999997	31.277603999999997	db
+32.042709	32.042709	b
+32.682639	32.682639	b
+33.34948	33.34948	b
+34.010069	34.010069	db
+34.644791999999995	34.644791999999995	b
+35.270833	35.270833	b
+35.921875	35.921875	b
+36.58125	36.58125	db
+37.263542	37.263542	b
+37.928646	37.928646	b
+38.591146	38.591146	b
+39.229167	39.229167	db
+39.882813	39.882813	b
+40.543229	40.543229	b
+41.180208	41.180208	b
+41.808854	41.808854	db
+42.445313	42.445313	b
+43.0875	43.0875	b
+43.720312	43.720312	b
+44.346354	44.346354	db
+44.986979	44.986979	b
+45.6375	45.6375	b
+46.271355	46.271355	b
+46.895313	46.895313	db
+47.514583	47.514583	b
+48.202604	48.202604	b
+48.85	48.85	b
+49.55	49.55	db
+50.232292	50.232292	b
+50.878646	50.878646	b
+51.540972	51.540972	b
+52.26007	52.26007	db
+52.89375	52.89375	b
+53.561459	53.561459	b
+54.202778	54.202778	b
+54.89895799999999	54.89895799999999	db
+55.558854000000004	55.558854000000004	b
+56.286457999999996	56.286457999999996	b
+56.972917	56.972917	b
+57.608334	57.608334	db
+58.26302	58.26302	b
+58.911458999999994	58.911458999999994	b
+59.578125	59.578125	b
+60.229167000000004	60.229167000000004	db
+60.852084	60.852084	b
+61.483854	61.483854	b
+62.12916600000001	62.12916600000001	b
+62.766144999999995	62.766144999999995	db
+63.406943999999996	63.406943999999996	b
+64.10208399999999	64.10208399999999	b
+64.779687	64.779687	b
+65.427084	65.427084	db
+66.10625	66.10625	b
+66.795833	66.795833	b
+67.463021	67.463021	b
+68.136979	68.136979	db
+68.80555600000001	68.80555600000001	b
+69.508333	69.508333	b
+70.192709	70.192709	b
+70.87083299999998	70.87083299999998	db
+71.545834	71.545834	b
+72.227604	72.227604	b
+72.890625	72.890625	b
+73.548438	73.548438	db
+74.165104	74.165104	b
+74.850521	74.850521	b
+75.49947900000002	75.49947900000002	b
+76.160764	76.160764	db
+76.832986	76.832986	b
+77.475521	77.475521	b
+78.127604	78.127604	b
+78.767708	78.767708	db
+79.408333	79.408333	b
+80.044271	80.044271	b
+80.690104	80.690104	b
+81.315625	81.315625	db
+81.963021	81.963021	b
+82.595313	82.595313	b
+83.226563	83.226563	b
+83.860416	83.860416	db
+84.495312	84.495312	b
+85.11666600000002	85.11666600000002	b
+85.777604	85.777604	b
+86.414583	86.414583	db
+87.05416600000002	87.05416600000002	b
+87.82135500000004	87.82135500000004	b
+88.486458	88.486458	b
+89.127083	89.127083	db
+89.776562	89.776562	b
+90.44166700000001	90.44166700000001	b
+91.095833	91.095833	b
+91.735417	91.735417	db
+92.379688	92.379688	b
+93.04739599999999	93.04739599999999	b
+93.72604100000001	93.72604100000001	b
+94.382292	94.382292	db
+95.03072900000001	95.03072900000001	b
+95.678125	95.678125	b
+96.326562	96.326562	b
+96.971875	96.971875	db
+97.603646	97.603646	b
+98.258854	98.258854	b
+98.894791	98.894791	b
+99.43333299999999	99.43333299999999	db
+100.086979	100.086979	b
+100.732292	100.732292	b
+101.380729	101.380729	b
+102.01823	102.01823	db
+102.651042	102.651042	b
+103.322395	103.322395	b
+103.958333	103.958333	b
+104.58802	104.58802	db
+105.227604	105.227604	b
+105.88333300000001	105.88333300000001	b
+106.522396	106.522396	b
+107.139583	107.139583	db
+107.7625	107.7625	b
+108.40625	108.40625	b
+109.04635400000001	109.04635400000001	b
+109.77968700000001	109.77968700000001	db
+110.48125	110.48125	b
+111.143229	111.143229	b
+111.803646	111.803646	b
+112.469792	112.469792	db
+113.120313	113.120313	b
+113.761459	113.761459	b
+114.42361100000001	114.42361100000001	b
+115.111979	115.111979	db
+115.795833	115.795833	b
+116.4625	116.4625	b
+117.121354	117.121354	b
+117.759895	117.759895	db
+118.427604	118.427604	b
+119.08541699999999	119.08541699999999	b
+119.729514	119.729514	b
+120.394271	120.394271	db
+121.07291699999999	121.07291699999999	b
+121.700521	121.700521	b
+122.35763899999999	122.35763899999999	b
+123.028646	123.028646	db
+123.699479	123.699479	b
+124.37031200000001	124.37031200000001	b
+125.06458300000001	125.06458300000001	b
+125.722916	125.722916	db
+126.3875	126.3875	b
+127.059375	127.059375	b
+127.76406200000001	127.76406200000001	b
+128.41718799999998	128.41718799999998	db
+129.070313	129.070313	b
+129.726042	129.726042	b
+130.3875	130.3875	b
+131.055208	131.055208	db
+131.676042	131.676042	b
+132.31093700000002	132.31093700000002	b
+132.965625	132.965625	b
+133.647396	133.647396	db
+134.309028	134.309028	b
+134.981944	134.981944	b
+135.67031200000002	135.67031200000002	b
+136.348264	136.348264	db
+137.027431	137.027431	b
+137.781597	137.781597	b
+138.515104	138.515104	b
+139.165104	139.165104	db
+139.797396	139.797396	b
+140.448959	140.448959	b
+141.09531299999998	141.09531299999998	b
+141.872917	141.872917	db
+142.854167	142.854167	b
+144.533333	144.533333	b

asap-dataset-master/Bach/Fugue/bwv_848/Lin04M_annotations.txt

@@ -0,0 +1,217 @@
+0.81901	0.81901	b,,7
+1.3424479999999999	1.3424479999999999	b
+1.9726560000000002	1.9726560000000002	db,4/4
+2.519531	2.519531	b
+3.126302	3.126302	b
+3.7265620000000004	3.7265620000000004	b
+4.3125	4.3125	db
+4.871094	4.871094	b
+5.402344	5.402344	b
+5.929037	5.929037	b
+6.50651	6.50651	db
+7.063802000000001	7.063802000000001	b
+7.638021000000001	7.638021000000001	b
+8.210938	8.210938	b
+8.755208	8.755208	db
+9.282552	9.282552	b
+9.838541000000001	9.838541000000001	b
+10.359809	10.359809	b
+10.909505000000001	10.909505000000001	db
+11.470052	11.470052	b
+12.035156	12.035156	b
+12.560764	12.560764	b
+13.071614	13.071614	db
+13.615234	13.615234	b
+14.176432	14.176432	b
+14.718098999999999	14.718098999999999	b
+15.248698000000001	15.248698000000001	db
+15.817708999999999	15.817708999999999	b
+16.379557000000002	16.379557000000002	b
+16.941406	16.941406	b
+17.457682000000002	17.457682000000002	db
+18.027344	18.027344	b
+18.575521	18.575521	b
+19.113932000000002	19.113932000000002	b
+19.630208	19.630208	db
+20.160156	20.160156	b
+20.695963	20.695963	b
+21.259549	21.259549	b
+21.806424	21.806424	db
+22.369792	22.369792	b
+22.909722	22.909722	b
+23.460504	23.460504	b
+24.009114	24.009114	db
+24.546875	24.546875	b
+25.065755	25.065755	b
+25.594401	25.594401	b
+26.089844	26.089844	db
+26.660156	26.660156	b
+27.209635	27.209635	b
+27.746094	27.746094	b
+28.321615	28.321615	db
+28.871094	28.871094	b
+29.411458000000003	29.411458000000003	b
+29.946615	29.946615	b
+30.501303000000004	30.501303000000004	db
+31.059896000000002	31.059896000000002	b
+31.627603999999998	31.627603999999998	b
+32.188803	32.188803	b
+32.733073	32.733073	db
+33.279297	33.279297	b
+33.828776	33.828776	b
+34.375651	34.375651	b
+34.904297	34.904297	db
+35.451172	35.451172	b
+36.019531	36.019531	b
+36.545573	36.545573	b
+37.082682	37.082682	db
+37.619141	37.619141	b
+38.206379999999996	38.206379999999996	b
+38.736979	38.736979	b
+39.268229999999996	39.268229999999996	db
+39.789063	39.789063	b
+40.335938	40.335938	b
+40.859375	40.859375	b
+41.436849	41.436849	db
+41.997396	41.997396	b
+42.55599	42.55599	b
+43.123047	43.123047	b
+43.689236	43.689236	db
+44.265625	44.265625	b
+44.81684	44.81684	b
+45.391927	45.391927	b
+45.948785	45.948785	db
+46.505208	46.505208	b
+47.057292	47.057292	b
+47.60026	47.60026	b
+48.138672	48.138672	db
+48.651042	48.651042	b
+49.217448	49.217448	b
+49.749348	49.749348	b
+50.302083	50.302083	db
+50.832031	50.832031	b
+51.386719	51.386719	b
+51.917969	51.917969	b
+52.459635999999996	52.459635999999996	db
+53.006944	53.006944	b
+53.557291000000006	53.557291000000006	b
+54.114582999999996	54.114582999999996	b
+54.654947	54.654947	db
+55.23697900000001	55.23697900000001	b
+55.790365	55.790365	b
+56.34375	56.34375	b
+56.928385999999996	56.928385999999996	db
+57.467448	57.467448	b
+58.054035999999996	58.054035999999996	b
+58.619141000000006	58.619141000000006	b
+59.182943	59.182943	db
+59.73828100000001	59.73828100000001	b
+60.30078100000001	60.30078100000001	b
+60.87109399999999	60.87109399999999	b
+61.442707999999996	61.442707999999996	db
+61.999349	61.999349	b
+62.536457999999996	62.536457999999996	b
+63.11328100000001	63.11328100000001	b
+63.668836999999996	63.668836999999996	db
+64.237413	64.237413	b
+64.805339	64.805339	b
+65.345703	65.345703	b
+65.87174499999999	65.87174499999999	db
+66.419922	66.419922	b
+66.979166	66.979166	b
+67.51432199999999	67.51432199999999	b
+68.0625	68.0625	db
+68.602864	68.602864	b
+69.136719	69.136719	b
+69.667969	69.667969	b
+70.202473	70.202473	db
+70.73111999999998	70.73111999999998	b
+71.25455699999998	71.25455699999998	b
+71.80599000000002	71.80599000000002	b
+72.359375	72.359375	db
+72.88736999999998	72.88736999999998	b
+73.442709	73.442709	b
+74.011719	74.011719	b
+74.548177	74.548177	db
+75.085286	75.085286	b
+75.649089	75.649089	b
+76.208334	76.208334	b
+76.760417	76.760417	db
+77.295573	77.295573	b
+77.86263000000002	77.86263000000002	b
+78.425781	78.425781	b
+78.984375	78.984375	db
+79.516927	79.516927	b
+80.067708	80.067708	b
+80.617839	80.617839	b
+81.15494699999998	81.15494699999998	db
+81.689453	81.689453	b
+82.244791	82.244791	b
+82.717448	82.717448	b
+83.268229	83.268229	db
+83.818359	83.818359	b
+84.37955699999998	84.37955699999998	b
+84.93294200000003	84.93294200000003	b
+85.451172	85.451172	db
+85.998046	85.998046	b
+86.558594	86.558594	b
+87.09375	87.09375	b
+87.62044300000002	87.62044300000002	db
+88.167969	88.167969	b
+88.728516	88.728516	b
+89.274089	89.274089	b
+89.789062	89.789062	db
+90.322266	90.322266	b
+90.843099	90.843099	b
+91.373047	91.373047	b
+91.90950500000001	91.90950500000001	db
+92.460938	92.460938	b
+93.01106800000001	93.01106800000001	b
+93.561849	93.561849	b
+94.092448	94.092448	db
+94.616536	94.616536	b
+95.13736999999999	95.13736999999999	b
+95.66275999999999	95.66275999999999	b
+96.220052	96.220052	db
+96.753906	96.753906	b
+97.328125	97.328125	b
+97.88736999999999	97.88736999999999	b
+98.486979	98.486979	db
+98.953125	98.953125	b
+99.516927	99.516927	b
+100.02908000000001	100.02908000000001	b
+100.57486999999999	100.57486999999999	db
+101.117188	101.117188	b
+101.65755300000001	101.65755300000001	b
+102.175347	102.175347	b
+102.681641	102.681641	db
+103.25	103.25	b
+103.764974	103.764974	b
+104.337891	104.337891	b
+104.891927	104.891927	db
+105.44596399999999	105.44596399999999	b
+105.968099	105.968099	b
+106.53971399999999	106.53971399999999	b
+107.09960900000002	107.09960900000002	db
+107.65104199999999	107.65104199999999	b
+108.175781	108.175781	b
+108.72851599999998	108.72851599999998	b
+109.27408899999999	109.27408899999999	db
+109.811849	109.811849	b
+110.33658899999999	110.33658899999999	b
+110.852865	110.852865	b
+111.386068	111.386068	db
+111.916233	111.916233	b
+112.449219	112.449219	b
+112.996094	112.996094	b
+113.51736100000001	113.51736100000001	db
+114.069879	114.069879	b
+114.58420100000001	114.58420100000001	b
+115.11263000000001	115.11263000000001	b
+115.62174499999999	115.62174499999999	db
+116.15299499999999	116.15299499999999	b
+116.636068	116.636068	b
+117.14908899999999	117.14908899999999	b
+117.674479	117.674479	db
+118.313368	118.313368	b
+119.267187	119.267187	b

asap-dataset-master/Bach/Fugue/bwv_848/Lou01M_annotations.txt

@@ -0,0 +1,217 @@
+0.813802	0.813802	b,,7
+1.321615	1.321615	b
+1.9726560000000002	1.9726560000000002	db,4/4
+2.541667	2.541667	b
+3.154948	3.154948	b
+3.7317709999999997	3.7317709999999997	b
+4.372396	4.372396	db
+4.955729	4.955729	b
+5.513021	5.513021	b
+6.0052080000000005	6.0052080000000005	b
+6.6171880000000005	6.6171880000000005	db
+7.226561999999999	7.226561999999999	b
+7.798177000000001	7.798177000000001	b
+8.347005000000001	8.347005000000001	b
+8.920573	8.920573	db
+9.514323	9.514323	b
+10.102214	10.102214	b
+10.638021	10.638021	b
+11.257161	11.257161	db
+11.853516	11.853516	b
+12.438802	12.438802	b
+12.9796	12.9796	b
+13.607422	13.607422	db
+14.208332999999998	14.208332999999998	b
+14.766926999999999	14.766926999999999	b
+15.322266	15.322266	b
+15.892578	15.892578	db
+16.505208	16.505208	b
+17.065104	17.065104	b
+17.61263	17.61263	b
+18.180338	18.180338	db
+18.775391	18.775391	b
+19.348308	19.348308	b
+19.940104	19.940104	b
+20.519531	20.519531	db
+21.050131	21.050131	b
+21.59375	21.59375	b
+22.116319	22.116319	b
+22.724392	22.724392	db
+23.321614	23.321614	b
+23.885416	23.885416	b
+24.459201999999998	24.459201999999998	b
+25.090712	25.090712	db
+25.664713	25.664713	b
+26.22005200000001	26.22005200000001	b
+26.780599	26.780599	b
+27.320963	27.320963	db
+27.990885	27.990885	b
+28.561632	28.561632	b
+29.101563	29.101563	b
+29.683159000000003	29.683159000000003	db
+30.276041999999997	30.276041999999997	b
+30.84375	30.84375	b
+31.384766	31.384766	b
+31.989583000000003	31.989583000000003	db
+32.585938	32.585938	b
+33.149088	33.149088	b
+33.703776	33.703776	b
+34.291667	34.291667	db
+34.897135999999996	34.897135999999996	b
+35.445963	35.445963	b
+36.010417	36.010417	b
+36.563802	36.563802	db
+37.130208	37.130208	b
+37.699219	37.699219	b
+38.242188	38.242188	b
+38.778646	38.778646	db
+39.358724	39.358724	b
+39.924479	39.924479	b
+40.516927	40.516927	b
+41.129558	41.129558	db
+41.695963	41.695963	b
+42.261719	42.261719	b
+42.82465300000001	42.82465300000001	b
+43.425781	43.425781	db
+43.986328	43.986328	b
+44.576823	44.576823	b
+45.136719	45.136719	b
+45.759549	45.759549	db
+46.303385999999996	46.303385999999996	b
+46.865451	46.865451	b
+47.424479	47.424479	b
+48.033854	48.033854	db
+48.617838	48.617838	b
+49.273003	49.273003	b
+49.841146	49.841146	b
+50.408203	50.408203	db
+50.923177	50.923177	b
+51.489584	51.489584	b
+52.057942	52.057942	b
+52.64388	52.64388	db
+53.163410999999996	53.163410999999996	b
+53.757813	53.757813	b
+54.337891000000006	54.337891000000006	b
+54.904948	54.904948	db
+55.419270999999995	55.419270999999995	b
+55.998698	55.998698	b
+56.608073	56.608073	b
+57.147785999999996	57.147785999999996	db
+57.727431	57.727431	b
+58.361111	58.361111	b
+58.927083999999994	58.927083999999994	b
+59.523438	59.523438	db
+60.05078100000001	60.05078100000001	b
+60.671224	60.671224	b
+61.279297	61.279297	b
+61.852865	61.852865	db
+62.415365	62.415365	b
+62.958332999999996	62.958332999999996	b
+63.55859399999999	63.55859399999999	b
+64.13150999999999	64.13150999999999	db
+64.689454	64.689454	b
+65.298828	65.298828	b
+65.861329	65.861329	b
+66.4375	66.4375	db
+66.977864	66.977864	b
+67.53580699999999	67.53580699999999	b
+68.123047	68.123047	b
+68.673828	68.673828	db
+69.203776	69.203776	b
+69.726563	69.726563	b
+70.274739	70.274739	b
+70.816406	70.816406	db
+71.34505300000002	71.34505300000002	b
+71.88150999999998	71.88150999999998	b
+72.434895	72.434895	b
+72.96549499999998	72.96549499999998	db
+73.51236999999998	73.51236999999998	b
+74.037109	74.037109	b
+74.59375	74.59375	b
+75.144531	75.144531	db
+75.70052	75.70052	b
+76.302734	76.302734	b
+76.85025999999998	76.85025999999998	b
+77.376302	77.376302	db
+77.90039	77.90039	b
+78.47200500000002	78.47200500000002	b
+79.055339	79.055339	b
+79.583333	79.583333	db
+80.110026	80.110026	b
+80.688151	80.688151	b
+81.25	81.25	b
+81.807292	81.807292	db
+82.36393299999997	82.36393299999997	b
+82.962891	82.962891	b
+83.59700500000002	83.59700500000002	b
+84.143229	84.143229	db
+84.649739	84.649739	b
+85.212891	85.212891	b
+85.921224	85.921224	b
+86.496094	86.496094	db
+87.066406	87.066406	b
+87.649739	87.649739	b
+88.255208	88.255208	b
+88.798177	88.798177	db
+89.344401	89.344401	b
+89.935547	89.935547	b
+90.529948	90.529948	b
+91.075521	91.075521	db
+91.651041	91.651041	b
+92.25	92.25	b
+92.841797	92.841797	b
+93.390625	93.390625	db
+93.93294200000001	93.93294200000001	b
+94.481771	94.481771	b
+95.031901	95.031901	b
+95.61263000000001	95.61263000000001	db
+96.208333	96.208333	b
+96.763021	96.763021	b
+97.350261	97.350261	b
+97.98893299999999	97.98893299999999	db
+98.60481700000001	98.60481700000001	b
+99.13736999999999	99.13736999999999	b
+99.666666	99.666666	b
+100.263021	100.263021	db
+100.884766	100.884766	b
+101.46549499999999	101.46549499999999	b
+102.014974	102.014974	b
+102.59049499999999	102.59049499999999	db
+103.166667	103.166667	b
+103.738281	103.738281	b
+104.261719	104.261719	b
+104.86914099999998	104.86914099999998	db
+105.47851599999998	105.47851599999998	b
+106.03125	106.03125	b
+106.580729	106.580729	b
+107.21549499999999	107.21549499999999	db
+107.845703	107.845703	b
+108.41341100000001	108.41341100000001	b
+108.998698	108.998698	b
+109.584635	109.584635	db
+110.16341100000001	110.16341100000001	b
+110.705729	110.705729	b
+111.308594	111.308594	b
+111.910156	111.910156	db
+112.470703	112.470703	b
+113.016927	113.016927	b
+113.608073	113.608073	b
+114.14843799999998	114.14843799999998	db
+114.735026	114.735026	b
+115.35156299999998	115.35156299999998	b
+115.904297	115.904297	b
+116.453776	116.453776	db
+116.97091999999999	116.97091999999999	b
+117.570746	117.570746	b
+118.16601599999998	118.16601599999998	b
+118.732422	118.732422	db
+119.326823	119.326823	b
+119.942274	119.942274	b
+120.60091100000001	120.60091100000001	b
+121.16210900000002	121.16210900000002	db
+121.722656	121.722656	b
+122.33398400000002	122.33398400000002	b
+122.921875	122.921875	b
+123.557942	123.557942	db
+124.331055	124.331055	b
+125.465104	125.465104	b

asap-dataset-master/Bach/Fugue/bwv_848/MiyashitaM01M_annotations.txt

@@ -0,0 +1,217 @@
+0.809375	0.809375	b,,7
+1.36875	1.36875	b
+2.009375	2.009375	db,4/4
+2.6010419999999996	2.6010419999999996	b
+3.2208330000000003	3.2208330000000003	b
+3.839583	3.839583	b
+4.496875	4.496875	db
+5.1197919999999995	5.1197919999999995	b
+5.717187	5.717187	b
+6.2802089999999975	6.2802089999999975	b
+6.8994789999999995	6.8994789999999995	db
+7.5125	7.5125	b
+8.115103999999999	8.115103999999999	b
+8.719791	8.719791	b
+9.326563	9.326563	db
+9.971875	9.971875	b
+10.603646000000001	10.603646000000001	b
+11.193056	11.193056	b
+11.814062	11.814062	db
+12.450521	12.450521	b
+13.058333	13.058333	b
+13.688889000000001	13.688889000000001	b
+14.291667000000002	14.291667000000002	db
+14.942186999999999	14.942186999999999	b
+15.535936999999999	15.535936999999999	b
+16.130209	16.130209	b
+16.739062	16.739062	db
+17.376041	17.376041	b
+17.984896	17.984896	b
+18.569792	18.569792	b
+19.182292	19.182292	db
+19.798437	19.798437	b
+20.424479	20.424479	b
+20.994270999999998	20.994270999999998	b
+21.596875	21.596875	db
+22.183854999999998	22.183854999999998	b
+22.809896	22.809896	b
+23.38125	23.38125	b
+24.00625	24.00625	db
+24.622396	24.622396	b
+25.235417	25.235417	b
+25.852083	25.852083	b
+26.451389000000002	26.451389000000002	db
+27.042187	27.042187	b
+27.629687	27.629687	b
+28.209896	28.209896	b
+28.831771000000003	28.831771000000003	db
+29.502083000000002	29.502083000000002	b
+30.108681	30.108681	b
+30.710938	30.710938	b
+31.337846999999996	31.337846999999996	db
+31.9375	31.9375	b
+32.549479	32.549479	b
+33.109896	33.109896	b
+33.725	33.725	db
+34.341667	34.341667	b
+34.934895000000004	34.934895000000004	b
+35.536458	35.536458	b
+36.135417	36.135417	db
+36.733854	36.733854	b
+37.346875	37.346875	b
+37.914583	37.914583	b
+38.506771	38.506771	db
+39.119792	39.119792	b
+39.734896	39.734896	b
+40.317709	40.317709	b
+40.901562	40.901562	db
+41.502604	41.502604	b
+42.107292	42.107292	b
+42.696875	42.696875	b
+43.301041	43.301041	db
+43.89375	43.89375	b
+44.515104	44.515104	b
+45.083853999999995	45.083853999999995	b
+45.726042	45.726042	db
+46.358334	46.358334	b
+46.98020800000001	46.98020800000001	b
+47.595139	47.595139	b
+48.204167	48.204167	db
+48.798958	48.798958	b
+49.426041999999995	49.426041999999995	b
+50.031944	50.031944	b
+50.676041999999995	50.676041999999995	db
+51.321875	51.321875	b
+51.930208	51.930208	b
+52.559375	52.559375	b
+53.173438	53.173438	db
+53.757813	53.757813	b
+54.39010500000001	54.39010500000001	b
+54.998957999999995	54.998957999999995	b
+55.617188	55.617188	db
+56.20885500000001	56.20885500000001	b
+56.85260400000001	56.85260400000001	b
+57.472917	57.472917	b
+58.08125	58.08125	db
+58.665625	58.665625	b
+59.30104100000001	59.30104100000001	b
+59.935417	59.935417	b
+60.5375	60.5375	db
+61.162847	61.162847	b
+61.815971999999995	61.815971999999995	b
+62.411979	62.411979	b
+63.057291000000006	63.057291000000006	db
+63.653125	63.653125	b
+64.271354	64.271354	b
+64.900521	64.900521	b
+65.514062	65.514062	db
+66.113541	66.113541	b
+66.713889	66.713889	b
+67.322917	67.322917	b
+67.929688	67.929688	db
+68.536979	68.536979	b
+69.13125	69.13125	b
+69.766667	69.766667	b
+70.378472	70.378472	db
+70.993055	70.993055	b
+71.615625	71.615625	b
+72.201042	72.201042	b
+72.788542	72.788542	db
+73.390625	73.390625	b
+73.974479	73.974479	b
+74.59322900000002	74.59322900000002	b
+75.190625	75.190625	db
+75.790625	75.790625	b
+76.392708	76.392708	b
+77.014583	77.014583	b
+77.619271	77.619271	db
+78.206771	78.206771	b
+78.796355	78.796355	b
+79.409375	79.409375	b
+80.00573	80.00573	db
+80.58645899999998	80.58645899999998	b
+81.19895799999998	81.19895799999998	b
+81.814583	81.814583	b
+82.41770799999998	82.41770799999998	db
+83.017188	83.017188	b
+83.659896	83.659896	b
+84.276041	84.276041	b
+84.89375	84.89375	db
+85.476563	85.476563	b
+86.098959	86.098959	b
+86.698437	86.698437	b
+87.304167	87.304167	db
+87.892188	87.892188	b
+88.510937	88.510937	b
+89.114584	89.114584	b
+89.716667	89.716667	db
+90.345833	90.345833	b
+90.979166	90.979166	b
+91.616667	91.616667	b
+92.239583	92.239583	db
+92.869791	92.869791	b
+93.52448000000001	93.52448000000001	b
+94.142708	94.142708	b
+94.751563	94.751563	db
+95.363021	95.363021	b
+96.015105	96.015105	b
+96.627083	96.627083	b
+97.240625	97.240625	db
+97.85625	97.85625	b
+98.494791	98.494791	b
+99.115625	99.115625	b
+99.729687	99.729687	db
+100.342709	100.342709	b
+100.963541	100.963541	b
+101.571875	101.571875	b
+102.235938	102.235938	db
+102.8875	102.8875	b
+103.51302	103.51302	b
+104.132292	104.132292	b
+104.761979	104.761979	db
+105.42031200000001	105.42031200000001	b
+106.02968700000001	106.02968700000001	b
+106.64513899999999	106.64513899999999	b
+107.28854199999999	107.28854199999999	db
+107.927605	107.927605	b
+108.54479199999999	108.54479199999999	b
+109.157292	109.157292	b
+109.775	109.775	db
+110.418229	110.418229	b
+111.071354	111.071354	b
+111.65763899999999	111.65763899999999	b
+112.292709	112.292709	db
+112.9375	112.9375	b
+113.553646	113.553646	b
+114.19513899999998	114.19513899999998	b
+114.865104	114.865104	db
+115.49791699999999	115.49791699999999	b
+116.12031200000001	116.12031200000001	b
+116.77604199999999	116.77604199999999	b
+117.405208	117.405208	db
+118.02395800000001	118.02395800000001	b
+118.659375	118.659375	b
+119.30416699999999	119.30416699999999	b
+119.965104	119.965104	db
+120.589583	120.589583	b
+121.206771	121.206771	b
+121.85781200000001	121.85781200000001	b
+122.49270800000001	122.49270800000001	db
+123.078125	123.078125	b
+123.69583300000001	123.69583300000001	b
+124.301041	124.301041	b
+124.925	124.925	db
+125.518055	125.518055	b
+126.16493100000001	126.16493100000001	b
+126.790625	126.790625	b
+127.42708300000001	127.42708300000001	db
+128.071528	128.071528	b
+128.692361	128.692361	b
+129.320833	129.320833	b
+129.929167	129.929167	db
+130.547395	130.547395	b
+131.183854	131.183854	b
+131.790104	131.790104	b
+132.4625	132.4625	db
+133.45286399999998	133.45286399999998	b
+135.404792	135.404792	b

asap-dataset-master/Bach/Fugue/bwv_848/Mizumoto03M_annotations.txt

@@ -0,0 +1,217 @@
+0.88151	0.88151	b,,7
+1.459635	1.459635	b
+2.1276040000000003	2.1276040000000003	db,4/4
+2.729167	2.729167	b
+3.3619790000000003	3.3619790000000003	b
+4.042969	4.042969	b
+4.71875	4.71875	db
+5.326823	5.326823	b
+5.913411	5.913411	b
+6.481771	6.481771	b
+7.0774740000000005	7.0774740000000005	db
+7.674478999999999	7.674478999999999	b
+8.311849	8.311849	b
+8.9375	8.9375	b
+9.546875	9.546875	db
+10.125651	10.125651	b
+10.727213	10.727213	b
+11.28125	11.28125	b
+11.911458	11.911458	db
+12.519531	12.519531	b
+13.117188	13.117188	b
+13.684028	13.684028	b
+14.294270000000001	14.294270000000001	db
+14.917969	14.917969	b
+15.502604000000002	15.502604000000002	b
+16.092448	16.092448	b
+16.697266	16.697266	db
+17.309896	17.309896	b
+17.889974	17.889974	b
+18.479167	18.479167	b
+19.077474	19.077474	db
+19.692709	19.692709	b
+20.269531	20.269531	b
+20.849609	20.849609	b
+21.436198	21.436198	db
+22.045573	22.045573	b
+22.626953	22.626953	b
+23.202257	23.202257	b
+23.829860999999998	23.829860999999998	db
+24.384766	24.384766	b
+24.996094	24.996094	b
+25.592448	25.592448	b
+26.204427	26.204427	db
+26.795572999999997	26.795572999999997	b
+27.363281	27.363281	b
+27.915365	27.915365	b
+28.521484	28.521484	db
+29.13737	29.13737	b
+29.71875	29.71875	b
+30.292317999999998	30.292317999999998	b
+30.909722	30.909722	db
+31.48567700000001	31.48567700000001	b
+32.078776	32.078776	b
+32.641276	32.641276	b
+33.270833	33.270833	db
+33.90625	33.90625	b
+34.504558	34.504558	b
+35.138021	35.138021	b
+35.716146	35.716146	db
+36.291667	36.291667	b
+36.867838	36.867838	b
+37.435547	37.435547	b
+37.991535999999996	37.991535999999996	db
+38.569660999999996	38.569660999999996	b
+39.160156	39.160156	b
+39.749349	39.749349	b
+40.297526	40.297526	db
+40.886068	40.886068	b
+41.452474	41.452474	b
+42.008464000000004	42.008464000000004	b
+42.580078	42.580078	db
+43.171224	43.171224	b
+43.762370000000004	43.762370000000004	b
+44.330078	44.330078	b
+44.957031	44.957031	db
+45.550131	45.550131	b
+46.146484	46.146484	b
+46.751736	46.751736	b
+47.371961999999996	47.371961999999996	db
+47.966146	47.966146	b
+48.550781	48.550781	b
+49.140625	49.140625	b
+49.733073	49.733073	db
+50.377604999999996	50.377604999999996	b
+50.936632	50.936632	b
+51.498698	51.498698	b
+52.093099	52.093099	db
+52.666666000000006	52.666666000000006	b
+53.259115	53.259115	b
+53.83072900000001	53.83072900000001	b
+54.399089000000004	54.399089000000004	db
+54.952474	54.952474	b
+55.511068	55.511068	b
+56.114582999999996	56.114582999999996	b
+56.634766000000006	56.634766000000006	db
+57.22526	57.22526	b
+57.86263	57.86263	b
+58.460285999999996	58.460285999999996	b
+59.054035999999996	59.054035999999996	db
+59.660591000000004	59.660591000000004	b
+60.263020999999995	60.263020999999995	b
+60.838542000000004	60.838542000000004	b
+61.446615	61.446615	db
+62.013020999999995	62.013020999999995	b
+62.615233999999994	62.615233999999994	b
+63.248698	63.248698	b
+63.860026	63.860026	db
+64.423828	64.423828	b
+65.017361	65.017361	b
+65.608073	65.608073	b
+66.195964	66.195964	db
+66.76888000000001	66.76888000000001	b
+67.35611999999999	67.35611999999999	b
+67.944011	67.944011	b
+68.53689200000001	68.53689200000001	db
+69.13064200000001	69.13064200000001	b
+69.703125	69.703125	b
+70.259766	70.259766	b
+70.828777	70.828777	db
+71.390625	71.390625	b
+71.973958	71.973958	b
+72.541016	72.541016	b
+73.119792	73.119792	db
+73.69986999999998	73.69986999999998	b
+74.265625	74.265625	b
+74.852214	74.852214	b
+75.439454	75.439454	db
+76.009766	76.009766	b
+76.575521	76.575521	b
+77.130209	77.130209	b
+77.689453	77.689453	db
+78.259766	78.259766	b
+78.863281	78.863281	b
+79.420573	79.420573	b
+79.99349000000002	79.99349000000002	db
+80.552083	80.552083	b
+81.15169200000003	81.15169200000003	b
+81.707031	81.707031	b
+82.25911500000002	82.25911500000002	db
+82.825521	82.825521	b
+83.400391	83.400391	b
+83.962891	83.962891	b
+84.510417	84.510417	db
+85.085286	85.085286	b
+85.653645	85.653645	b
+86.240886	86.240886	b
+86.789714	86.789714	db
+87.324219	87.324219	b
+87.91275999999998	87.91275999999998	b
+88.41861999999998	88.41861999999998	b
+88.994792	88.994792	db
+89.559896	89.559896	b
+90.171875	90.171875	b
+90.764323	90.764323	b
+91.313802	91.313802	db
+91.894531	91.894531	b
+92.5	92.5	b
+93.070964	93.070964	b
+93.60481800000001	93.60481800000001	db
+94.183594	94.183594	b
+94.778646	94.778646	b
+95.304036	95.304036	b
+95.85677	95.85677	db
+96.399089	96.399089	b
+96.951172	96.951172	b
+97.515625	97.515625	b
+98.154297	98.154297	db
+98.755208	98.755208	b
+99.326172	99.326172	b
+99.920573	99.920573	b
+100.526042	100.526042	db
+101.13736999999999	101.13736999999999	b
+101.652344	101.652344	b
+102.22091999999999	102.22091999999999	b
+102.80794300000001	102.80794300000001	db
+103.40625	103.40625	b
+104.001953	104.001953	b
+104.574219	104.574219	b
+105.205729	105.205729	db
+105.70898400000002	105.70898400000002	b
+106.27604199999999	106.27604199999999	b
+106.83854199999999	106.83854199999999	b
+107.44335900000002	107.44335900000002	db
+108.050781	108.050781	b
+108.625	108.625	b
+109.1875	109.1875	b
+109.81835900000002	109.81835900000002	db
+110.384115	110.384115	b
+110.99414099999998	110.99414099999998	b
+111.579427	111.579427	b
+112.174479	112.174479	db
+112.761067	112.761067	b
+113.34700500000001	113.34700500000001	b
+113.96354199999999	113.96354199999999	b
+114.56770800000001	114.56770800000001	db
+115.14843799999998	115.14843799999998	b
+115.776692	115.776692	b
+116.40039099999998	116.40039099999998	b
+116.971354	116.971354	db
+117.529948	117.529948	b
+118.16471399999999	118.16471399999999	b
+118.785807	118.785807	b
+119.358724	119.358724	db
+119.9579	119.9579	b
+120.56033000000001	120.56033000000001	b
+121.154948	121.154948	b
+121.74132	121.74132	db
+122.351128	122.351128	b
+123.001302	123.001302	b
+123.561849	123.561849	b
+124.11263000000001	124.11263000000001	db
+124.639323	124.639323	b
+125.19596399999999	125.19596399999999	b
+125.764974	125.764974	b
+126.417318	126.417318	db
+127.243164	127.243164	b
+128.558333	128.558333	b

asap-dataset-master/Bach/Fugue/bwv_848/SunY01M_annotations.txt

@@ -0,0 +1,217 @@
+0.822917	0.822917	b,,7
+1.36875	1.36875	b
+1.965625	1.965625	db,4/4
+2.545833	2.545833	b
+3.1333330000000004	3.1333330000000004	b
+3.723958	3.723958	b
+4.3125	4.3125	db
+4.890625	4.890625	b
+5.454167	5.454167	b
+5.992708	5.992708	b
+6.525521	6.525521	db
+7.084375	7.084375	b
+7.6458330000000005	7.6458330000000005	b
+8.173438	8.173438	b
+8.684896	8.684896	db
+9.227083	9.227083	b
+9.797396	9.797396	b
+10.344445	10.344445	b
+10.923958	10.923958	db
+11.486459	11.486459	b
+12.057813000000001	12.057813000000001	b
+12.588889	12.588889	b
+13.133332999999999	13.133332999999999	db
+13.709375	13.709375	b
+14.246355	14.246355	b
+14.797917000000002	14.797917000000002	b
+15.328645000000002	15.328645000000002	db
+15.904166	15.904166	b
+16.458333	16.458333	b
+17.001562	17.001562	b
+17.542188	17.542188	db
+18.108333	18.108333	b
+18.667188	18.667188	b
+19.195313	19.195313	b
+19.756771	19.756771	db
+20.293229	20.293229	b
+20.851042	20.851042	b
+21.389931	21.389931	b
+21.944097	21.944097	db
+22.511457999999998	22.511457999999998	b
+23.078472	23.078472	b
+23.621875	23.621875	b
+24.192014	24.192014	db
+24.739062	24.739062	b
+25.2875	25.2875	b
+25.822917	25.822917	b
+26.364583000000003	26.364583000000003	db
+26.949478999999997	26.949478999999997	b
+27.484721999999998	27.484721999999998	b
+28.03177100000001	28.03177100000001	b
+28.578125	28.578125	db
+29.108333000000002	29.108333000000002	b
+29.685938	29.685938	b
+30.225521	30.225521	b
+30.790625	30.790625	db
+31.360416999999998	31.360416999999998	b
+31.899479	31.899479	b
+32.457813	32.457813	b
+33.005208	33.005208	db
+33.564583	33.564583	b
+34.113021	34.113021	b
+34.638542	34.638542	b
+35.188542	35.188542	db
+35.748959	35.748959	b
+36.314583	36.314583	b
+36.85	36.85	b
+37.41614600000001	37.41614600000001	db
+37.988541999999995	37.988541999999995	b
+38.558854	38.558854	b
+39.106771	39.106771	b
+39.652604	39.652604	db
+40.207291999999995	40.207291999999995	b
+40.757813	40.757813	b
+41.309375	41.309375	b
+41.894791	41.894791	db
+42.483334	42.483334	b
+43.030729	43.030729	b
+43.594097	43.594097	b
+44.189583	44.189583	db
+44.743229	44.743229	b
+45.308681	45.308681	b
+45.842014	45.842014	b
+46.409375	46.409375	db
+46.983854	46.983854	b
+47.564236	47.564236	b
+48.142708	48.142708	b
+48.68177100000001	48.68177100000001	db
+49.247395000000004	49.247395000000004	b
+49.802083	49.802083	b
+50.3625	50.3625	b
+50.903645000000004	50.903645000000004	db
+51.438021	51.438021	b
+51.998437	51.998437	b
+52.534895	52.534895	b
+53.073437	53.073437	db
+53.606597	53.606597	b
+54.160938	54.160938	b
+54.75677099999999	54.75677099999999	b
+55.311459	55.311459	db
+55.863195	55.863195	b
+56.421875	56.421875	b
+56.970833	56.970833	b
+57.544270999999995	57.544270999999995	db
+58.084028	58.084028	b
+58.66041600000001	58.66041600000001	b
+59.245833999999995	59.245833999999995	b
+59.78698000000001	59.78698000000001	db
+60.342188	60.342188	b
+60.91631999999999	60.91631999999999	b
+61.470312	61.470312	b
+62.01823	62.01823	db
+62.564583	62.564583	b
+63.125521	63.125521	b
+63.708333999999994	63.708333999999994	b
+64.267708	64.267708	db
+64.842361	64.842361	b
+65.395834	65.395834	b
+65.956771	65.956771	b
+66.494271	66.494271	db
+67.042709	67.042709	b
+67.577605	67.577605	b
+68.121875	68.121875	b
+68.671875	68.671875	db
+69.215625	69.215625	b
+69.761459	69.761459	b
+70.295834	70.295834	b
+70.829688	70.829688	db
+71.376563	71.376563	b
+71.91354100000002	71.91354100000002	b
+72.471875	72.471875	b
+73.008333	73.008333	db
+73.55625	73.55625	b
+74.110938	74.110938	b
+74.642708	74.642708	b
+75.179167	75.179167	db
+75.717709	75.717709	b
+76.290625	76.290625	b
+76.846875	76.846875	b
+77.397917	77.397917	db
+77.934375	77.934375	b
+78.497396	78.497396	b
+79.04375	79.04375	b
+79.598958	79.598958	db
+80.133854	80.133854	b
+80.676563	80.676563	b
+81.223438	81.223438	b
+81.75885500000003	81.75885500000003	db
+82.283333	82.283333	b
+82.834896	82.834896	b
+83.342187	83.342187	b
+83.860417	83.860417	db
+84.41041700000002	84.41041700000002	b
+84.9625	84.9625	b
+85.508854	85.508854	b
+86.052084	86.052084	db
+86.588021	86.588021	b
+87.144271	87.144271	b
+87.679167	87.679167	b
+88.216145	88.216145	db
+88.768229	88.768229	b
+89.304167	89.304167	b
+89.849479	89.849479	b
+90.363021	90.363021	db
+90.902604	90.902604	b
+91.453125	91.453125	b
+91.99427	91.99427	b
+92.573437	92.573437	db
+93.159375	93.159375	b
+93.706771	93.706771	b
+94.256771	94.256771	b
+94.813541	94.813541	db
+95.39375	95.39375	b
+95.930208	95.930208	b
+96.469792	96.469792	b
+97.026041	97.026041	db
+97.626563	97.626563	b
+98.17239599999999	98.17239599999999	b
+98.717708	98.717708	b
+99.241667	99.241667	db
+99.817709	99.817709	b
+100.392708	100.392708	b
+100.931944	100.931944	b
+101.513021	101.513021	db
+102.099479	102.099479	b
+102.65572900000001	102.65572900000001	b
+103.203125	103.203125	b
+103.765625	103.765625	db
+104.326042	104.326042	b
+104.89218799999999	104.89218799999999	b
+105.459375	105.459375	b
+106.02395800000001	106.02395800000001	db
+106.59322900000001	106.59322900000001	b
+107.145312	107.145312	b
+107.72604199999999	107.72604199999999	b
+108.309375	108.309375	db
+108.847396	108.847396	b
+109.40416699999999	109.40416699999999	b
+109.993229	109.993229	b
+110.557813	110.557813	db
+111.09583300000001	111.09583300000001	b
+111.65416699999999	111.65416699999999	b
+112.20156200000001	112.20156200000001	b
+112.77604099999999	112.77604099999999	db
+113.32951399999999	113.32951399999999	b
+113.886458	113.886458	b
+114.46041699999999	114.46041699999999	b
+115.025695	115.025695	db
+115.57361100000001	115.57361100000001	b
+116.153125	116.153125	b
+116.692187	116.692187	b
+117.239062	117.239062	db
+117.785416	117.785416	b
+118.340625	118.340625	b
+118.8875	118.8875	b
+119.4625	119.4625	db
+120.14609399999999	120.14609399999999	b
+121.303125	121.303125	b