Add files using upload-large-folder tool

.gitattributes

@@ -8,7 +8,6 @@
 *.h5 filter=lfs diff=lfs merge=lfs -text
 *.joblib filter=lfs diff=lfs merge=lfs -text
 *.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
 *.mlmodel filter=lfs diff=lfs merge=lfs -text
 *.model filter=lfs diff=lfs merge=lfs -text
 *.msgpack filter=lfs diff=lfs merge=lfs -text
@@ -34,25 +33,3 @@ 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
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -0,0 +1,13 @@
+[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/yourmt3-multi-instrument-music-transcription/multi-instrument-music-transcription-on)](https://paperswithcode.com/sota/multi-instrument-music-transcription-on?p=yourmt3-multi-instrument-music-transcription) [![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/yourmt3-multi-instrument-music-transcription/music-transcription-on-slakh2100)](https://paperswithcode.com/sota/music-transcription-on-slakh2100?p=yourmt3-multi-instrument-music-transcription) [![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/yourmt3-multi-instrument-music-transcription/drum-transcription-in-music-dtm-on-enst-drums)](https://paperswithcode.com/sota/drum-transcription-in-music-dtm-on-enst-drums?p=yourmt3-multi-instrument-music-transcription)
+
+![yourmt3-low-resolution-color-logo-crop](https://user-images.githubusercontent.com/26891722/204390355-001877a1-d019-46d7-a33c-d3a3adc0743c.png)
+### YourMT3: Multi-task and multi-track music transcription for everyone
+
+## NEWS
+	
+- **YourMT3+ (MLSP2024)**: [arxiv:2407.04822](https://arxiv.org/abs/2407.04822) | [Colab Demo](https://colab.research.google.com/drive/1AgOVEBfZknDkjmSRA7leoa81a2vrnhBG?usp=sharing) | [Code](https://github.com/mimbres/YourMT3/issues/2#issuecomment-2255643217)(pre-release)
+  - 2024.08 🤗HuggingFace [Spaces Demo](https://huggingface.co/spaces/mimbres/YourMT3) (Free GPU) is out!
+  - ⭐️ YouTube transcription is working again! (you'll need to authenticate your google account).
+
+![ymt3p_front_img_hi](https://github.com/mimbres/YourMT3/assets/26891722/2e152609-5131-4787-8422-8c4a8877fee1)
+

config/task.py

@@ -0,0 +1,119 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+"""task.py"""
+from config.vocabulary import *
+from utils.note_event_dataclasses import Event
+
+task_cfg = {
+    "mt3_midi": { # 11 classes + drum class
+        "name": "mt3_midi",
+        "train_program_vocab": program_vocab_presets["mt3_midi"],
+        "train_drum_vocab": drum_vocab_presets["gm"],
+    },
+    "mt3_midi_plus": { # 11 classes + singing + drum class
+        "name": "mt3_midi_plus",
+        "train_program_vocab": program_vocab_presets["mt3_midi_plus"],
+        "train_drum_vocab": drum_vocab_presets["gm"],
+    },
+    "mt3_full": { # 34 classes (except drums) as in MT3 paper
+        "name": "mt3_full",
+        "train_program_vocab": program_vocab_presets["mt3_full"],
+        "train_drum_vocab": drum_vocab_presets["gm"],
+    },
+    "mt3_full_plus": { # 34 classes (except drums) as in MT3 paper + singing + drum class
+        "name": "mt3_full_plus",
+        "train_program_vocab": program_vocab_presets["mt3_full_plus"],
+        "train_drum_vocab": drum_vocab_presets["gm"],
+    },
+    "gm_ext_plus": { # 13 classes + singing + chorus (except drums) 
+        "name": "gm_ext_plus",
+        "train_program_vocab": program_vocab_presets["gm_ext_plus"],
+        "train_drum_vocab": drum_vocab_presets["gm"],
+    },
+    "singing_v1": {
+        "name": "singing",
+        "train_program_vocab": program_vocab_presets["mt3_full_plus"],
+        "train_drum_vocab": drum_vocab_presets["gm"],
+        "subtask_tokens": ["task", "transcribe_singing", "transcribe_all"],
+        "ignore_decoding_tokens": ["task", "transcribe_singing", "transcribe_all"],
+        "max_task_token_length": 2,
+        "eval_subtask_prefix": {
+            "default": [Event("transcribe_all", 0), Event("task", 0)],
+            "singing-only": [Event("transcribe_singing", 0),
+                             Event("task", 0)],
+        }
+    },
+    "singing_drum_v1": {
+        "name": "singing_drum",
+        "train_program_vocab": program_vocab_presets["mt3_full_plus"],
+        "train_drum_vocab": drum_vocab_presets["gm"],
+        "subtask_tokens": ["task", "transcribe_singing", "transcribe_drum", "transcribe_all"],
+        "ignore_decoding_tokens": [
+            "task", "transcribe_singing", "transcribe_drum", "transcribe_all"
+        ],
+        "max_task_token_length": 2,
+        "eval_subtask_prefix": {
+            "default": [Event("transcribe_all", 0), Event("task", 0)],
+            "singing-only": [Event("transcribe_singing", 0),
+                             Event("task", 0)],
+            "drum-only": [Event("transcribe_drum", 0),
+                          Event("task", 0)],
+        }
+    },
+    "mc13": { # multi-channel decoding task of {11 classes + drums + singing}
+        "name": "mc13",
+        "train_program_vocab": program_vocab_presets["gm_plus"],
+        "train_drum_vocab": drum_vocab_presets["gm"],
+        "num_decoding_channels": len(program_vocab_presets["gm_plus"]) + 1, # 13
+        "max_note_token_length_per_ch": 512, # multi-channel decoding exclusive parameter
+        "mask_loss_strategy": None, # multi-channel decoding exclusive parameter
+    },
+    "mc13_256": { # multi-channel decoding task of {11 classes + drums + singing}
+        "name": "mc13_256",
+        "train_program_vocab": program_vocab_presets["gm_plus"],
+        "train_drum_vocab": drum_vocab_presets["gm"],
+        "num_decoding_channels": len(program_vocab_presets["gm_plus"]) + 1, # 13
+        "max_note_token_length_per_ch": 256, # multi-channel decoding exclusive parameter
+        "mask_loss_strategy": None, # multi-channel decoding exclusive parameter
+    },
+    "mc13_full_plus": { # multi-channel decoding task of {34 classes + drums + singing & chorus} mapped to 13 channels
+        "name": "mc13_full_plus",
+        "train_program_vocab": program_vocab_presets["mt3_full_plus"],
+        "train_drum_vocab": drum_vocab_presets["gm"],
+        "program2channel_vocab_source": program_vocab_presets["gm_plus"],
+        "num_decoding_channels": 13,
+        "max_note_token_length_per_ch": 512, # multi-channel decoding exclusive parameter
+        "mask_loss_strategy": None, # multi-channel decoding exclusive parameter
+    },
+    "mc13_full_plus_256": { # multi-channel decoding task of {34 classes + drums + singing & chorus} mapped to 13 channels
+        "name": "mc13_full_plus_256",
+        "train_program_vocab": program_vocab_presets["mt3_full_plus"],
+        "train_drum_vocab": drum_vocab_presets["gm"],
+        "program2channel_vocab_source": program_vocab_presets["gm_plus"],
+        "num_decoding_channels": 13,
+        "max_note_token_length_per_ch": 256, # multi-channel decoding exclusive parameter
+        "mask_loss_strategy": None, # multi-channel decoding exclusive parameter
+    },
+    "exc_v1": {
+        "name": "exclusive",
+        "train_program_vocab": program_vocab_presets["mt3_full_plus"],
+        "train_drum_vocab": drum_vocab_presets["gm"],
+        "subtask_tokens": ["transcribe", "all", ":"],
+        # "ignore_decoding_tokens": [
+        #     "task", "transcribe_singing", "transcribe_drum", "transcribe_all"
+        # ],
+        # "max_task_token_length": 2,
+        "ignore_decoding_tokens_from_and_to": ["transcribe", ":"],
+        "eval_subtask_prefix": { # this is the main task that transcribe all instruments
+            "default": [Event("transcribe", 0), Event("all", 0), Event(":", 0)],
+        },
+        "shuffle_subtasks": True,
+    },
+}

extras/datasets_eval_testing.py

@@ -0,0 +1,42 @@
+from utils.datasets_eval import AudioFileDataset
+from torch.utils.data import DataLoader
+import pytorch_lightning as pl
+
+
+def test():
+
+    ds = AudioFileDataset()
+    dl = DataLoader(
+        ds, batch_size=None, collate_fn=lambda k: k
+    )  # empty collate_fn is required to use mixed types.
+
+    for x, y in dl:
+        break
+
+    class MyModel(pl.LightningModule):
+
+        def __init__(self, **kwargs):
+            super().__init__()
+
+        def forward(self, x):
+            return x
+
+        def training_step(self, batch, batch_idx):
+            return 0
+
+        def validation_step(self, batch, batch_idx):
+            print(batch)
+            return 0
+
+        def train_dataloader(self):
+            return dl
+
+        def val_dataloader(self):
+            return dl
+
+        def configure_optimizers(self):
+            return None
+
+    model = MyModel()
+    trainer = pl.Trainer()
+    trainer.validate(model)

extras/install_deepspeed.md

@@ -0,0 +1,28 @@
+"""
+
+# not required on pytorch 2.0:latest container
+pip install cupy-cuda11x -f https://pip.cupy.dev/aarch64
+
+apt-get update
+apt-get install git
+apt-get install libaio-dev
+
+DS_BUILD_OPS=1 pip install deepspeed
+ds_report
+
+
+pip install deepspeed==0.7.7
+
+git clone https://github.com/NVIDIA/apex
+cd apex
+pip install -v --disable-pip-version-check --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" ./
+
+In case you have trouble building apex from source we recommend using the NGC containers
+ from here which come with a pre-built PyTorch and apex release.
+
+nvcr.io/nvidia/pytorch:23.01-py3
+
+pip install deepspeed, pip install transformers[deepspeed]
+https://www.deepspeed.ai/docs/config-json/#autotuning
+
+"""

extras/multi_channel_seqlen_stats.py

@@ -0,0 +1,177 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+from typing import Dict, Tuple
+from copy import deepcopy
+from collections import Counter
+import numpy as np
+import torch
+from utils.data_modules import AMTDataModule
+from utils.task_manager import TaskManager
+from config.data_presets import data_preset_single_cfg, data_preset_multi_cfg
+from utils.augment import intra_stem_augment_processor
+
+
+def get_ds(data_preset_multi: Dict, task_name: str, train_num_samples_per_epoch: int = 90000):
+    tm = TaskManager(task_name=task_name)
+    tm.max_note_token_length_per_ch = 1024  # only to check the max length
+    dm = AMTDataModule(data_preset_multi=data_preset_multi,
+                       task_manager=tm,
+                       train_num_samples_per_epoch=train_num_samples_per_epoch)
+    dm.setup('fit')
+    dl = dm.train_dataloader()
+    ds = dl.flattened[0].dataset
+    return ds
+
+
+data_preset_multi = data_preset_multi_cfg["all_cross_v6"]
+task_name = "mc13"  # "mt3_full_plus"
+ds = get_ds(data_preset_multi, task_name=task_name)
+ds.random_amp_range = [0.8, 1.1]
+ds.stem_xaug_policy = {
+    "max_k": 5,
+    "tau": 0.3,
+    "alpha": 1.0,
+    "max_subunit_stems": 12,
+    "no_instr_overlap": True,
+    "no_drum_overlap": True,
+    "uhat_intra_stem_augment": True,
+}
+
+length_all = []
+for i in range(40000):
+    if i % 5000 == 0:
+        print(i)
+    audio_arr, note_token_arr, task_totken_arr, pshift_steps = ds.__getitem__(i)
+    lengths = torch.sum(note_token_arr != 0, dim=2).flatten().cpu().tolist()
+    length_all.extend(lengths)
+
+length_all = np.asarray(length_all)
+
+# stats
+empty_sequence = np.sum(length_all < 3) / len(length_all) * 100
+print("empty_sequences:", f"{empty_sequence:.2f}", "%")
+
+mean_except_empty = np.mean(length_all[length_all > 2])
+print("mean_except_empty:", mean_except_empty)
+
+median_except_empty = np.median(length_all[length_all > 2])
+print("median_except_empty:", median_except_empty)
+
+ch_less_than_768 = np.sum(length_all < 768) / len(length_all) * 100
+print("ch_less_than_768:", f"{ch_less_than_768:.2f}", "%")
+
+ch_larger_than_512 = np.sum(length_all > 512) / len(length_all) * 100
+print("ch_larger_than_512:", f"{ch_larger_than_512:.6f}", "%")
+
+ch_larger_than_256 = np.sum(length_all > 256) / len(length_all) * 100
+print("ch_larger_than_256:", f"{ch_larger_than_256:.6f}", "%")
+
+ch_larger_than_128 = np.sum(length_all > 128) / len(length_all) * 100
+print("ch_larger_than_128:", f"{ch_larger_than_128:.6f}", "%")
+
+ch_larger_than_64 = np.sum(length_all > 64) / len(length_all) * 100
+print("ch_larger_than_64:", f"{ch_larger_than_64:.6f}", "%")
+
+song_length_all = length_all.reshape(-1, 13)
+song_larger_than_512 = 0
+song_larger_than_256 = 0
+song_larger_than_128 = 0
+song_larger_than_64 = 0
+for l in song_length_all:
+    if np.sum(l > 512) > 0:
+        song_larger_than_512 += 1
+    if np.sum(l > 256) > 0:
+        song_larger_than_256 += 1
+    if np.sum(l > 128) > 0:
+        song_larger_than_128 += 1
+    if np.sum(l > 64) > 0:
+        song_larger_than_64 += 1
+num_songs = len(song_length_all)
+print("song_larger_than_512:", f"{song_larger_than_512/num_songs*100:.4f}", "%")
+print("song_larger_than_256:", f"{song_larger_than_256/num_songs*100:.4f}", "%")
+print("song_larger_than_128:", f"{song_larger_than_128/num_songs*100:.4f}", "%")
+print("song_larger_than_64:", f"{song_larger_than_64/num_songs*100:.4f}", "%")
+
+instr_dict = {
+    0: "Piano",
+    1: "Chromatic Percussion",
+    2: "Organ",
+    3: "Guitar",
+    4: "Bass",
+    5: "Strings + Ensemble",
+    6: "Brass",
+    7: "Reed",
+    8: "Pipe",
+    9: "Synth Lead",
+    10: "Synth Pad",
+    11: "Singing",
+    12: "Drums",
+}
+cnt_larger_than_512 = Counter()
+for i in np.where(length_all > 512)[0] % 13:
+    cnt_larger_than_512[i] += 1
+print("larger_than_512:")
+for k, v in cnt_larger_than_512.items():
+    print(f"    - {instr_dict[k]}: {v}")
+
+cnt_larger_than_256 = Counter()
+for i in np.where(length_all > 256)[0] % 13:
+    cnt_larger_than_256[i] += 1
+print("larger_than_256:")
+for k, v in cnt_larger_than_256.items():
+    print(f"    - {instr_dict[k]}: {v}")
+
+cnt_larger_than_128 = Counter()
+for i in np.where(length_all > 128)[0] % 13:
+    cnt_larger_than_128[i] += 1
+print("larger_than_128:")
+for k, v in cnt_larger_than_128.items():
+    print(f"    - {instr_dict[k]}: {v}")
+"""
+empty_sequences: 91.06 %
+mean_except_empty: 36.68976799156269
+median_except_empty: 31.0
+ch_less_than_768: 100.00 %
+ch_larger_than_512: 0.000158 %
+ch_larger_than_256: 0.015132 %
+ch_larger_than_128: 0.192061 %
+ch_larger_than_64: 0.661260 %
+song_larger_than_512: 0.0021 %
+song_larger_than_256: 0.1926 %
+song_larger_than_128: 2.2280 %
+song_larger_than_64: 6.1033 %
+
+larger_than_512:
+    - Guitar: 7
+    - Strings + Ensemble: 3
+larger_than_256:
+    - Piano: 177
+    - Guitar: 680
+    - Strings + Ensemble: 79
+    - Organ: 2
+    - Chromatic Percussion: 11
+    - Bass: 1
+    - Synth Lead: 2
+    - Brass: 1
+    - Reed: 5
+larger_than_128:
+    - Guitar: 4711
+    - Strings + Ensemble: 1280
+    - Piano: 5548
+    - Bass: 211
+    - Synth Pad: 22
+    - Pipe: 18
+    - Chromatic Percussion: 55
+    - Synth Lead: 22
+    - Organ: 75
+    - Reed: 161
+    - Brass: 45
+    - Drums: 11
+"""

extras/remove_silence_musicnet_midi.py

@@ -0,0 +1,32 @@
+import os
+import glob
+
+from utils.midi import midi2note
+from utils.note2event import note2note_event
+from utils.note_event_dataclasses import Note
+from utils.note_event_dataclasses import NoteEvent
+from utils.midi import note_event2midi
+
+data_home = '../../data'
+dataset_name = 'musicnet'
+base_dir = os.path.join(data_home, dataset_name + '_yourmt3_16k')
+mid_pattern = os.path.join(base_dir, '*_midi', '*.mid')
+mid_files = glob.glob(mid_pattern, recursive=True)
+
+for mid_file in mid_files:
+    notes, _ = midi2note(mid_file)
+    first_onset_time = notes[0].onset
+    fixed_notes = []
+    for note in notes:
+        fixed_notes.append(
+            Note(
+                is_drum=note.is_drum,
+                program=note.program,
+                onset=note.onset - first_onset_time,
+                offset=note.offset - first_onset_time,
+                pitch=note.pitch,
+                velocity=note.velocity))
+    assert len(notes) == len(fixed_notes)
+    fixed_note_events = note2note_event(fixed_notes, return_activity=False)
+    note_event2midi(fixed_note_events, mid_file)
+    print(f'Overwriting {mid_file}')

infer.py

@@ -0,0 +1,232 @@
+# @title Model helper
+import os
+from collections import Counter
+import argparse
+import torch
+import numpy as np
+from typing import Literal, Dict
+import torchaudio
+
+from model.init_train import initialize_trainer, update_config
+from utils.task_manager import TaskManager
+from config.vocabulary import drum_vocab_presets
+from utils.utils import str2bool
+from utils.utils import Timer
+from utils.audio import slice_padded_array
+from utils.note2event import mix_notes
+from utils.event2note import merge_zipped_note_events_and_ties_to_notes
+from utils.utils import write_model_output_as_midi, write_err_cnt_as_json
+from model.ymt3 import YourMT3
+
+def load_model_checkpoint(args=None):
+    parser = argparse.ArgumentParser(description="YourMT3")
+    # General
+    parser.add_argument('exp_id', type=str, help='A unique identifier for the experiment is used to resume training. The "@" symbol can be used to load a specific checkpoint.')
+    parser.add_argument('-p', '--project', type=str, default='ymt3', help='project name')
+    parser.add_argument('-ac', '--audio-codec', type=str, default=None, help='audio codec (default=None). {"spec", "melspec"}. If None, default value defined in config.py will be used.')
+    parser.add_argument('-hop', '--hop-length', type=int, default=None, help='hop length in frames (default=None). {128, 300} 128 for MT3, 300 for PerceiverTFIf None, default value defined in config.py will be used.')
+    parser.add_argument('-nmel', '--n-mels', type=int, default=None, help='number of mel bins (default=None). If None, default value defined in config.py will be used.')
+    parser.add_argument('-if', '--input-frames', type=int, default=None, help='number of audio frames for input segment (default=None). If None, default value defined in config.py will be used.')
+    # Model configurations
+    parser.add_argument('-sqr', '--sca-use-query-residual', type=str2bool, default=None, help='sca use query residual flag. Default follows config.py')
+    parser.add_argument('-enc', '--encoder-type', type=str, default=None, help="Encoder type. 't5' or 'perceiver-tf' or 'conformer'. Default is 't5', following config.py.")
+    parser.add_argument('-dec', '--decoder-type', type=str, default=None, help="Decoder type. 't5' or 'multi-t5'. Default is 't5', following config.py.")
+    parser.add_argument('-preenc', '--pre-encoder-type', type=str, default='default', help="Pre-encoder type. None or 'conv' or 'default'. By default, t5_enc:None, perceiver_tf_enc:conv, conformer:None")
+    parser.add_argument('-predec', '--pre-decoder-type', type=str, default='default', help="Pre-decoder type. {None, 'linear', 'conv1', 'mlp', 'group_linear'} or 'default'. Default is {'t5': None, 'perceiver-tf': 'linear', 'conformer': None}.")
+    parser.add_argument('-cout', '--conv-out-channels', type=int, default=None, help='Number of filters for pre-encoder conv layer. Default follows "model_cfg" of config.py.')
+    parser.add_argument('-tenc', '--task-cond-encoder', type=str2bool, default=True, help='task conditional encoder (default=True). True or False')
+    parser.add_argument('-tdec', '--task-cond-decoder', type=str2bool, default=True, help='task conditional decoder (default=True). True or False')
+    parser.add_argument('-df', '--d-feat', type=int, default=None, help='Audio feature will be projected to this dimension for Q,K,V of T5 or K,V of Perceiver (default=None). If None, default value defined in config.py will be used.')
+    parser.add_argument('-pt', '--pretrained', type=str2bool, default=False, help='pretrained T5(default=False). True or False')
+    parser.add_argument('-b', '--base-name', type=str, default="google/t5-v1_1-small", help='base model name (default="google/t5-v1_1-small")')
+    parser.add_argument('-epe', '--encoder-position-encoding-type', type=str, default='default', help="Positional encoding type of encoder. By default, pre-defined PE for T5 or Perceiver-TF encoder in config.py. For T5: {'sinusoidal', 'trainable'}, conformer: {'rotary', 'trainable'}, Perceiver-TF: {'trainable', 'rope', 'alibi', 'alibit', 'None', '0', 'none', 'tkd', 'td', 'tk', 'kdt'}.")
+    parser.add_argument('-dpe', '--decoder-position-encoding-type', type=str, default='default', help="Positional encoding type of decoder. By default, pre-defined PE for T5 in config.py. {'sinusoidal', 'trainable'}.")
+    parser.add_argument('-twe', '--tie-word-embedding', type=str2bool, default=None, help='tie word embedding (default=None). If None, default value defined in config.py will be used.')
+    parser.add_argument('-el', '--event-length', type=int, default=None, help='event length (default=None). If None, default value defined in model cfg of config.py will be used.')
+    # Perceiver-TF configurations
+    parser.add_argument('-dl', '--d-latent', type=int, default=None, help='Latent dimension of Perceiver. On T5, this will be ignored (default=None). If None, default value defined in config.py will be used.')
+    parser.add_argument('-nl', '--num-latents', type=int, default=None, help='Number of latents of Perceiver. On T5, this will be ignored (default=None). If None, default value defined in config.py will be used.')
+    parser.add_argument('-dpm', '--perceiver-tf-d-model', type=int, default=None, help='Perceiver-TF d_model (default=None). If None, default value defined in config.py will be used.')
+    parser.add_argument('-npb', '--num-perceiver-tf-blocks', type=int, default=None, help='Number of blocks of Perceiver-TF. On T5, this will be ignored (default=None). If None, default value defined in config.py.')
+    parser.add_argument('-npl', '--num-perceiver-tf-local-transformers-per-block', type=int, default=None, help='Number of local layers per block of Perceiver-TF. On T5, this will be ignored (default=None). If None, default value defined in config.py will be used.')
+    parser.add_argument('-npt', '--num-perceiver-tf-temporal-transformers-per-block', type=int, default=None, help='Number of temporal layers per block of Perceiver-TF. On T5, this will be ignored (default=None). If None, default value defined in config.py will be used.')
+    parser.add_argument('-atc', '--attention-to-channel', type=str2bool, default=None, help='Attention to channel flag of Perceiver-TF. On T5, this will be ignored (default=None). If None, default value defined in config.py will be used.')
+    parser.add_argument('-ln', '--layer-norm-type', type=str, default=None, help='Layer normalization type (default=None). {"layer_norm", "rms_norm"}. If None, default value defined in config.py will be used.')
+    parser.add_argument('-ff', '--ff-layer-type', type=str, default=None, help='Feed forward layer type (default=None). {"mlp", "moe", "gmlp"}. If None, default value defined in config.py will be used.')
+    parser.add_argument('-wf', '--ff-widening-factor', type=int, default=None, help='Feed forward layer widening factor for MLP/MoE/gMLP (default=None). If None, default value defined in config.py will be used.')
+    parser.add_argument('-nmoe', '--moe-num-experts', type=int, default=None, help='Number of experts for MoE (default=None). If None, default value defined in config.py will be used.')
+    parser.add_argument('-kmoe', '--moe-topk', type=int, default=None, help='Top-k for MoE (default=None). If None, default value defined in config.py will be used.')
+    parser.add_argument('-act', '--hidden-act', type=str, default=None, help='Hidden activation function (default=None). {"gelu", "silu", "relu", "tanh"}. If None, default value defined in config.py will be used.')
+    parser.add_argument('-rt', '--rotary-type', type=str, default=None, help='Rotary embedding type expressed in three letters. e.g. ppl: "pixel" for SCA and latents, "lang" for temporal transformer. If None, use config.')
+    parser.add_argument('-rk', '--rope-apply-to-keys', type=str2bool, default=None, help='Apply rope to keys (default=None). If None, use config.')
+    parser.add_argument('-rp', '--rope-partial-pe', type=str2bool, default=None, help='Whether to apply RoPE to partial positions (default=None). If None, use config.')
+    # Decoder configurations
+    parser.add_argument('-dff', '--decoder-ff-layer-type', type=str, default=None, help='Feed forward layer type of decoder (default=None). {"mlp", "moe", "gmlp"}. If None, default value defined in config.py will be used.')
+    parser.add_argument('-dwf', '--decoder-ff-widening-factor', type=int, default=None, help='Feed forward layer widening factor for decoder MLP/MoE/gMLP (default=None). If None, default value defined in config.py will be used.')
+    # Task and Evaluation configurations
+    parser.add_argument('-tk', '--task', type=str, default='mt3_full_plus', help='tokenizer type (default=mt3_full_plus). See config/task.py for more options.')
+    parser.add_argument('-epv', '--eval-program-vocab', type=str, default=None, help='evaluation vocabulary (default=None). If None, default vocabulary of the data preset will be used.')
+    parser.add_argument('-edv', '--eval-drum-vocab', type=str, default=None, help='evaluation vocabulary for drum (default=None). If None, default vocabulary of the data preset will be used.')
+    parser.add_argument('-etk', '--eval-subtask-key', type=str, default='default', help='evaluation subtask key (default=default). See config/task.py for more options.')
+    parser.add_argument('-t', '--onset-tolerance', type=float, default=0.05, help='onset tolerance (default=0.05).')
+    parser.add_argument('-os', '--test-octave-shift', type=str2bool, default=False, help='test optimal octave shift (default=False). True or False')
+    parser.add_argument('-w', '--write-model-output', type=str2bool, default=True, help='write model test output to file (default=False). True or False')
+    # Trainer configurations
+    parser.add_argument('-pr','--precision', type=str, default="bf16-mixed", help='precision (default="bf16-mixed") {32, 16, bf16, bf16-mixed}')
+    parser.add_argument('-st', '--strategy', type=str, default='auto', help='strategy (default=auto). auto or deepspeed or ddp')
+    parser.add_argument('-n', '--num-nodes', type=int, default=1, help='number of nodes (default=1)')
+    parser.add_argument('-g', '--num-gpus', type=str, default='auto', help='number of gpus (default="auto")')
+    parser.add_argument('-wb', '--wandb-mode', type=str, default="disabled", help='wandb mode for logging (default=None). "disabled" or "online" or "offline". If None, default value defined in config.py will be used.')
+    # Debug
+    parser.add_argument('-debug', '--debug-mode', type=str2bool, default=False, help='debug mode (default=False). True or False')
+    parser.add_argument('-tps', '--test-pitch-shift', type=int, default=None, help='use pitch shift when testing. debug-purpose only. (default=None). semitone in int.')
+    args = parser.parse_args(args)
+    # yapf: enable
+    if torch.__version__ >= "1.13":
+        torch.set_float32_matmul_precision("high")
+    args.epochs = None
+
+    # Initialize and update config
+    _, _, dir_info, shared_cfg = initialize_trainer(args, stage='test')
+    shared_cfg, audio_cfg, model_cfg = update_config(args, shared_cfg, stage='test')
+
+    if args.eval_drum_vocab != None:  # override eval_drum_vocab
+        eval_drum_vocab = drum_vocab_presets[args.eval_drum_vocab]
+
+    # Initialize task manager
+    tm = TaskManager(task_name=args.task,
+                     max_shift_steps=int(shared_cfg["TOKENIZER"]["max_shift_steps"]),
+                     debug_mode=args.debug_mode)
+    print(f"Task: {tm.task_name}, Max Shift Steps: {tm.max_shift_steps}")
+
+    # Use GPU if available
+    device = "cpu" # torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # Model
+    model = YourMT3(
+        audio_cfg=audio_cfg,
+        model_cfg=model_cfg,
+        shared_cfg=shared_cfg,
+        optimizer=None,
+        task_manager=tm,  # tokenizer is a member of task_manager
+        eval_subtask_key=args.eval_subtask_key,
+        write_output_dir=dir_info["lightning_dir"] if args.write_model_output or args.test_octave_shift else None
+    ).to(device)
+    checkpoint = torch.load(dir_info["last_ckpt_path"])
+    state_dict = checkpoint['state_dict']
+    new_state_dict = {k: v for k, v in state_dict.items() if 'pitchshift' not in k}
+    model.load_state_dict(new_state_dict, strict=False)
+    return model.eval()
+
+
+def transcribe(model, audio_info):
+    t = Timer()
+
+    # Converting Audio
+    t.start()
+    audio, sr = torchaudio.load(uri=audio_info['filepath'])
+    audio = torch.mean(audio, dim=0).unsqueeze(0)
+    audio = torchaudio.functional.resample(audio, sr, model.audio_cfg['sample_rate'])
+    audio_segments = slice_padded_array(audio, model.audio_cfg['input_frames'], model.audio_cfg['input_frames'])
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    audio_segments = torch.from_numpy(audio_segments.astype('float32')).to(device).unsqueeze(1) # (n_seg, 1, seg_sz)
+    t.stop(); t.print_elapsed_time("converting audio");
+
+    # Inference
+    t.start()
+    pred_token_arr, _ = model.inference_file(bsz=8, audio_segments=audio_segments)
+    t.stop(); t.print_elapsed_time("model inference");
+
+    # Post-processing
+    t.start()
+    num_channels = model.task_manager.num_decoding_channels
+    n_items = audio_segments.shape[0]
+    start_secs_file = [model.audio_cfg['input_frames'] * i / model.audio_cfg['sample_rate'] for i in range(n_items)]
+    pred_notes_in_file = []
+    n_err_cnt = Counter()
+    for ch in range(num_channels):
+        pred_token_arr_ch = [arr[:, ch, :] for arr in pred_token_arr]  # (B, L)
+        zipped_note_events_and_tie, list_events, ne_err_cnt = model.task_manager.detokenize_list_batches(
+            pred_token_arr_ch, start_secs_file, return_events=True)
+        pred_notes_ch, n_err_cnt_ch = merge_zipped_note_events_and_ties_to_notes(zipped_note_events_and_tie)
+        pred_notes_in_file.append(pred_notes_ch)
+        n_err_cnt += n_err_cnt_ch
+    pred_notes = mix_notes(pred_notes_in_file)  # This is the mixed notes from all channels
+
+    # Write MIDI
+    write_model_output_as_midi(pred_notes, 'content/',
+                              audio_info['track_name'], model.midi_output_inverse_vocab)
+    t.stop(); t.print_elapsed_time("post processing");
+    midifile =  os.path.join('content/model_output/', audio_info['track_name']  + '.mid')
+    assert os.path.exists(midifile)
+    return midifile
+
+
+def prepare_media(source_path_or_url: os.PathLike,
+                  source_type: Literal['audio_filepath', 'youtube_url'],
+                  delete_video: bool = True) -> Dict:
+    """prepare media from source path or youtube, and return audio info"""
+    # Get audio_file
+    if source_type == 'audio_filepath':
+        audio_file = source_path_or_url
+    else:
+        raise ValueError(source_type)
+
+    # Create info
+    info = torchaudio.info(audio_file)
+    return {
+        "filepath": audio_file,
+        "track_name": os.path.basename(audio_file).split('.')[0],
+        "sample_rate": int(info.sample_rate),
+        "bits_per_sample": int(info.bits_per_sample),
+        "num_channels": int(info.num_channels),
+        "num_frames": int(info.num_frames),
+        "duration": int(info.num_frames / info.sample_rate),
+        "encoding": str.lower(info.encoding),
+    }
+
+def process_audio(audio_filepath, model):
+    if audio_filepath is None:
+        return None
+    audio_info = prepare_media(audio_filepath, source_type='audio_filepath')
+    midifile = transcribe(model, audio_info)
+    return midifile
+
+if __name__ == "__main__":
+    # @title Load Checkpoint
+    model_name = 'YPTF+Single (noPS)' # @param ["YMT3+", "YPTF+Single (noPS)", "YPTF+Multi (PS)", "YPTF.MoE+Multi (noPS)", "YPTF.MoE+Multi (PS)"]
+    precision = '16' # @param ["32", "bf16-mixed", "16"]
+    project = '2024'
+
+    if model_name == "YMT3+":
+        checkpoint = "[email protected]"
+        args = [checkpoint, '-p', project, '-pr', precision]
+    elif model_name == "YPTF+Single (noPS)":
+        checkpoint = "ptf_all_cross_rebal5_mirst_xk2_edr005_attend_c_full_plus_b100@model.ckpt"
+        args = [checkpoint, '-p', project, '-enc', 'perceiver-tf', '-ac', 'spec',
+                '-hop', '300', '-atc', '1', '-pr', precision]
+    elif model_name == "YPTF+Multi (PS)":
+        checkpoint = "mc13_256_all_cross_v6_xk5_amp0811_edr005_attend_c_full_plus_2psn_nl26_sb_b26r_800k@model.ckpt"
+        args = [checkpoint, '-p', project, '-tk', 'mc13_full_plus_256',
+                '-dec', 'multi-t5', '-nl', '26', '-enc', 'perceiver-tf',
+                '-ac', 'spec', '-hop', '300', '-atc', '1', '-pr', precision]
+    elif model_name == "YPTF.MoE+Multi (noPS)":
+        checkpoint = "mc13_256_g4_all_v7_mt3f_sqr_rms_moe_wf4_n8k2_silu_rope_rp_b36_nops@last.ckpt"
+        args = [checkpoint, '-p', project, '-tk', 'mc13_full_plus_256', '-dec', 'multi-t5',
+                '-nl', '26', '-enc', 'perceiver-tf', '-sqr', '1', '-ff', 'moe',
+                '-wf', '4', '-nmoe', '8', '-kmoe', '2', '-act', 'silu', '-epe', 'rope',
+                '-rp', '1', '-ac', 'spec', '-hop', '300', '-atc', '1', '-pr', precision]
+    elif model_name == "YPTF.MoE+Multi (PS)":
+        checkpoint = "mc13_256_g4_all_v7_mt3f_sqr_rms_moe_wf4_n8k2_silu_rope_rp_b80_ps2@model.ckpt"
+        args = [checkpoint, '-p', project, '-tk', 'mc13_full_plus_256', '-dec', 'multi-t5',
+                '-nl', '26', '-enc', 'perceiver-tf', '-sqr', '1', '-ff', 'moe',
+                '-wf', '4', '-nmoe', '8', '-kmoe', '2', '-act', 'silu', '-epe', 'rope',
+                '-rp', '1', '-ac', 'spec', '-hop', '300', '-atc', '1', '-pr', precision]
+    else:
+        raise ValueError(model_name)
+
+    model = load_model_checkpoint(args=args)
+
+    TEST_AUDIO_FILEPATH = "/home/richhiey/Desktop/code/test_data/test.mp3"
+    midifile = process_audio(TEST_AUDIO_FILEPATH, model)
+    print(midifile)

install_dataset.py

@@ -0,0 +1,285 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+""" install_dataset.py """
+import os
+import argparse
+import mirdata
+from typing import Optional, Tuple, Union
+from utils.preprocess.generate_dataset_stats import generate_dataset_stats_for_all_datasets, update_dataset_stats_for_new_dataset
+from utils.mirdata_dev.datasets import slakh16k
+from utils.preprocess.preprocess_slakh import preprocess_slakh16k, add_program_and_is_drum_info_to_file_list
+from utils.preprocess.preprocess_musicnet import preprocess_musicnet16k
+from utils.preprocess.preprocess_maps import preprocess_maps16k
+from utils.preprocess.preprocess_maestro import preprocess_maestro16k
+from utils.preprocess.preprocess_guitarset import preprocess_guitarset16k, create_filelist_by_style_guitarset16k
+from utils.preprocess.preprocess_enstdrums import preprocess_enstdrums16k, create_filelist_dtm_random_enstdrums16k
+from utils.preprocess.preprocess_mir_st500 import preprocess_mir_st500_16k
+from utils.preprocess.preprocess_cmedia import preprocess_cmedia_16k
+from utils.preprocess.preprocess_rwc_pop_full import preprocess_rwc_pop_full16k
+from utils.preprocess.preprocess_rwc_pop import preprocess_rwc_pop16k
+from utils.preprocess.preprocess_egmd import preprocess_egmd16k
+from utils.preprocess.preprocess_mir1k import preprocess_mir1k_16k
+from utils.preprocess.preprocess_urmp import preprocess_urmp16k
+from utils.preprocess.preprocess_idmt_smt_bass import preprocess_idmt_smt_bass_16k
+from utils.preprocess.preprocess_geerdes import preprocess_geerdes16k
+from utils.utils import download_and_extract  #, download_and_extract_zenodo_restricted
+
+# zenodo_token = "eyJhbGciOiJIUzUxMiIsImlhdCI6MTcxMDE1MDYzNywiZXhwIjoxNzEyNzA3MTk5fQ.eyJpZCI6ImRmODA5NzZlLTBjM2QtNDk5NS05YjM0LWFiNGM4NzJhMmZhMSIsImRhdGEiOnt9LCJyYW5kb20iOiIwMzY5ZDcxZjc2NTMyN2UyYmVmN2ExYjJkMmMyYTRhNSJ9.0aHnNC-7ivWQO6l8twjLR0NDH4boC0uOolAAmogVt7XRi2PHU5MEKBQoK7-wgDdnmWEIqEIvoLO6p8KTnsY9dg"
+
+
+def install_slakh(data_home=os.PathLike, no_down=False) -> None:
+    if not no_down:
+        ds = slakh16k.Dataset(data_home, version='2100-yourmt3-16k')
+        ds.download(partial_download=['2100-yourmt3-16k', 'index'])
+        del (ds)
+    preprocess_slakh16k(data_home, delete_source_files=False, fix_bass_octave=True)
+    add_program_and_is_drum_info_to_file_list(data_home)
+
+
+def install_musicnet(data_home=os.PathLike, no_down=False) -> None:
+    if not no_down:
+        url = "https://zenodo.org/record/7811639/files/musicnet_yourmt3_16k.tar.gz?download=1"
+        checksum = "a2da7c169e26d452a4e8b9bef498b3d7"
+        download_and_extract(data_home, url, remove_tar_file=True, check_sum=checksum)
+    preprocess_musicnet16k(data_home, dataset_name='musicnet')
+
+
+def install_maps(data_home=os.PathLike, no_down=False, sanity_check=False) -> None:
+    if not no_down:
+        url = "https://zenodo.org/record/7812075/files/maps_yourmt3_16k.tar.gz?download=1"
+        checksum = "6b070d162c931cd5e69c16ef2398a649"
+        download_and_extract(data_home, url, remove_tar_file=True, check_sum=checksum)
+    preprocess_maps16k(data_home, dataset_name='maps', ignore_pedal=False, sanity_check=sanity_check)
+
+
+def install_maestro(data_home=os.PathLike, no_down=False, sanity_check=False) -> None:
+    if not no_down:
+        url = "https://zenodo.org/record/7852176/files/maestro_yourmt3_16k.tar.gz?download=1"
+        checksum = "c17c6a188d936e5ff3870ef27144d397"
+        download_and_extract(data_home, url, remove_tar_file=True, check_sum=checksum)
+    preprocess_maestro16k(data_home, dataset_name='maestro', ignore_pedal=False, sanity_check=sanity_check)
+
+
+def install_guitarset(data_home=os.PathLike, no_down=False) -> None:
+    if not no_down:
+        url = "https://zenodo.org/record/7831843/files/guitarset_yourmt3_16k.tar.gz?download=1"
+        checksum = "e3cfe0cc9394d91d9c290ce888821360"
+        download_and_extract(data_home, url, remove_tar_file=True, check_sum=checksum)
+    preprocess_guitarset16k(data_home, dataset_name='guitarset')
+    create_filelist_by_style_guitarset16k(data_home, dataset_name='guitarset')
+
+
+def install_enstdrums(data_home, no_down=False) -> None:
+    if not no_down:
+        url = "https://zenodo.org/record/7831843/files/enstdrums_yourmt3_16k.tar.gz?download=1"
+        checksum = "7e28c2a923e4f4162b3d83877cedb5eb"
+        download_and_extract(data_home, url, remove_tar_file=True, check_sum=checksum)
+    preprocess_enstdrums16k(data_home, dataset_name='enstdrums')
+    create_filelist_dtm_random_enstdrums16k(data_home, dataset_name='enstdrums')
+
+
+def install_egmd(data_home, no_down=False) -> None:
+    if not no_down:
+        url = "https://zenodo.org/record/7831072/files/egmc_yourmt3_16k.tar.gz?download=1"
+        checksum = "4f615157ea4c52a64c6c9dcf68bf2bde"
+        download_and_extract(data_home, url, remove_tar_file=True, check_sum=checksum)
+    preprocess_egmd16k(data_home, dataset_name='egmd')
+
+
+def install_mirst500(data_home, zenodo_token, no_down=False, sanity_check=True, apply_correction=False) -> None:
+    """ Update Oct 2023: MIR-ST500 with FULL audio files"""
+    if not no_down:
+        url = "https://zenodo.org/records/10016397/files/mir_st500_yourmt3_16k.tar.gz?download=1"
+        checksum = "98eb52eb2456ce4034e21750f309da13"
+        download_and_extract(data_home, url, check_sum=checksum, zenodo_token=zenodo_token)
+    preprocess_mir_st500_16k(data_home, dataset_name='mir_st500', sanity_check=sanity_check)
+
+
+def install_cmedia(data_home, zenodo_token, no_down=False, sanity_check=True) -> None:
+    if not no_down:
+        url = "https://zenodo.org/records/10016397/files/cmedia_yourmt3_16k.tar.gz?download=1"
+        checksum = "e6cca23577ba7588e9ed9711a398f7cf"
+        download_and_extract(data_home, url, check_sum=checksum, zenodo_token=zenodo_token)
+    preprocess_cmedia_16k(data_home, dataset_name='cmedia', sanity_check=sanity_check, apply_correction=True)
+
+
+def install_rwc_pop(data_home, zenodo_token, no_down=False) -> None:
+    if not no_down:
+        url = "https://zenodo.org/records/10016397/files/rwc_pop_yourmt3_16k.tar.gz?download=1"
+        checksum = "ad459f9fa1b6b87676b2fb37c0ba5dfc"
+        download_and_extract(data_home, url, check_sum=checksum, zenodo_token=zenodo_token)
+    preprocess_rwc_pop16k(data_home, dataset_name='rwc_pop')  # bass transcriptions
+    preprocess_rwc_pop_full16k(data_home, dataset_name='rwc_pop')  # full transcriptions
+
+
+def install_mir1k(data_home, no_down=False) -> None:
+    if not no_down:
+        url = "https://zenodo.org/record/7955481/files/mir1k_yourmt3_16k.tar.gz?download=1"
+        checksum = "4cbac56a4e971432ca807efd5cb76d67"
+        download_and_extract(data_home, url, remove_tar_file=True, check_sum=checksum)
+    # preprocess_mir1k_16k(data_home, dataset_name='mir1k')
+
+
+def install_urmp(data_home, no_down=False) -> None:
+    if not no_down:
+        url = "https://zenodo.org/record/8021437/files/urmp_yourmt3_16k.tar.gz?download=1"
+        checksum = "4f539c71678a77ba34f6dfca41072102"
+        download_and_extract(data_home, url, remove_tar_file=True, check_sum=checksum)
+    preprocess_urmp16k(data_home, dataset_name='urmp')
+
+
+def install_idmt_smt_bass(data_home, no_down=False) -> None:
+    if not no_down:
+        url = "https://zenodo.org/records/10009959/files/idmt_smt_bass_yourmt3_16k.tar.gz?download=1"
+        checksum = "0c95f91926a1e95b1f5d075c05b7eb76"
+        download_and_extract(data_home, url, remove_tar_file=True, check_sum=checksum)
+    preprocess_idmt_smt_bass_16k(data_home, dataset_name='idmt_smt_bass', sanity_check=True,
+                                 edit_audio=False)  # the donwloaded audio has already been edited
+
+
+def install_random_nsynth(data_home, no_down=False) -> None:
+    return
+
+
+def install_geerdes(data_home) -> None:
+    try:
+        preprocess_geerdes16k(data_home, dataset_name='geerdes', sanity_check=False)
+    except Exception as e:
+        print(e)
+        print("Geerdes dataset is not available for download. Please contact the dataset provider.")
+
+
+def regenerate_dataset_stats(data_home) -> None:
+    generate_dataset_stats_for_all_datasets(data_home)
+
+
+def get_cached_zenodo_token() -> str:
+    # check if cached token exists
+    if not os.path.exists('.cached_zenodo_token'):
+        raise Exception("Cached Zenodo token not found. Please enter your Zenodo token.")
+    # read cached token
+    with open('.cached_zenodo_token', 'r') as f:
+        zenodo_token = f.read().strip()
+        print(f"Using cached Zenodo token: {zenodo_token}")
+    return zenodo_token
+
+
+def cache_zenodo_token(zenodo_token: str) -> None:
+    with open('.cached_zenodo_token', 'w') as f:
+        f.write(zenodo_token)
+    print("Your Zenodo token is cached.")
+
+
+def option_prompt(data_home: os.PathLike, no_download: bool = False) -> None:
+    print("Select the dataset(s) to install (enter comma-separated numbers):")
+    print("1. Slakh")
+    print("2. MusicNet")
+    print("3. MAPS")
+    print("4. Maestro")
+    print("5. GuitarSet")
+    print("6. ENST-drums")
+    print("7. EGMD")
+    print("8. MIR-ST500 ** Restricted Access **")
+    print("9. CMedia ** Restricted Access **")
+    print("10. RWC-Pop (Bass and Full) ** Restricted Access **")
+    print("11. MIR-1K (NOT SUPPORTED)")
+    print("12. URMP")
+    print("13. IDMT-SMT-Bass")
+    print("14. Random-NSynth")
+    print("15. Geerdes")
+    print("16. Regenerate Dataset Stats (experimental)")
+    print("17. Request Token for ** Restricted Access **")
+    print("18. Exit")
+
+    choice = input("Enter your choices (multiple choices with comma): ")
+    choices = [c.strip() for c in choice.split(',')]
+
+    if "18" in choices:
+        print("Exiting.")
+    else:
+        # ask for Zenodo token
+        for c in choices:
+            if int(c) in [8, 9, 10]:
+                if no_download is True:
+                    zenodo_token = None
+                else:
+                    zenodo_token = input("Enter Zenodo token, or press enter to use the cached token:")
+                    if zenodo_token == "":
+                        zenodo_token = get_cached_zenodo_token()
+                    else:
+                        cache_zenodo_token(zenodo_token)
+                    break
+
+        if "1" in choices:
+            install_slakh(data_home, no_down=no_download)
+        if "2" in choices:
+            install_musicnet(data_home, no_down=no_download)
+        if "3" in choices:
+            install_maps(data_home, no_down=no_download)
+        if "4" in choices:
+            install_maestro(data_home, no_down=no_download)
+        if "5" in choices:
+            install_guitarset(data_home, no_down=no_download)
+        if "6" in choices:
+            install_enstdrums(data_home, no_down=no_download)
+        if "7" in choices:
+            install_egmd(data_home, no_down=no_download)
+        if "8" in choices:
+            install_mirst500(data_home, zenodo_token, no_down=no_download)
+        if "9" in choices:
+            install_cmedia(data_home, zenodo_token, no_down=no_download)
+        if "10" in choices:
+            install_rwc_pop(data_home, zenodo_token, no_down=no_download)
+        if "11" in choices:
+            install_mir1k(data_home, no_down=no_download)
+        if "12" in choices:
+            install_urmp(data_home, no_down=no_download)
+        if "13" in choices:
+            install_idmt_smt_bass(data_home, no_down=no_download)
+        if "14" in choices:
+            install_random_nsynth(data_home, no_down=no_download)
+        if "15" in choices:
+            install_geerdes(data_home)  # not available for download
+        if "16" in choices:
+            regenerate_dataset_stats(data_home, no_down=no_download)
+        if "17" in choices:
+            print("\nPlease visit https://zenodo.org/records/10016397 to request a Zenodo token.")
+            print("Upon submitting your request, you will receive an email with a link labeled 'Access the record'.")
+            print("Copy the token that follows 'token=' in that link.")
+        if not any(int(c) in range(16) for c in choices):
+            print("Invalid choice(s). Please enter valid numbers separated by commas.")
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(description='Dataset installer script.')
+    # data home dir
+    parser.add_argument(
+        'data_home',
+        type=str,
+        nargs='?',
+        default=None,
+        help='Path to data home directory. If None, use the default path defined in src/config/config.py')
+    # `no_download` option
+    parser.add_argument('--nodown',
+                        '-nd',
+                        action='store_true',
+                        help='Flag to control downloading. If set, no downloading will occur.')
+    args = parser.parse_args()
+
+    if args.data_home is None:
+        from config.config import shared_cfg
+        data_home = shared_cfg["PATH"]["data_home"]
+    else:
+        data_home = args.data_home
+    os.makedirs(data_home, exist_ok=True)
+    no_download = args.nodown
+
+    option_prompt(data_home, no_download)

logs/2024/mc13_256_g4_all_v7_mt3f_sqr_rms_moe_wf4_n8k2_silu_rope_rp_b36_nops/result_mc13_full_plus_256_default_all_eval_final.json

@@ -0,0 +1,444 @@
+[   '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [   {   'Bass': array([32, 33, 34, 35, 36, 37, 38, 39]),
+                              'Brass': array([56, 57, 58, 59, 60, 61, 62, 63]),
+                              'Chromatic Percussion': array([ 8,  9, 10, 11, 12, 13, 14, 15]),
+                              'Guitar': array([24, 25, 26, 27, 28, 29, 30, 31]),
+                              'Organ': array([16, 17, 18, 19, 20, 21, 22, 23]),
+                              'Piano': array([0, 1, 2, 3, 4, 5, 6, 7]),
+                              'Pipe': array([72, 73, 74, 75, 76, 77, 78, 79]),
+                              'Reed': array([64, 65, 66, 67, 68, 69, 70, 71]),
+                              'Strings': array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55]),
+                              'Synth Lead': array([80, 81, 82, 83, 84, 85, 86, 87]),
+                              'Synth Pad': array([88, 89, 90, 91, 92, 93, 94, 95])}],
+        'presets': ['slakh']},
+    [   {   'test/(slakh)frame_f': 0.8487486243247986,
+            'test/(slakh)frame_f_pc': 0.8603377938270569,
+            'test/(slakh)micro_offset_f_Bass': 0.869631290435791,
+            'test/(slakh)micro_offset_f_Brass': 0.6678106784820557,
+            'test/(slakh)micro_offset_f_Chromatic Percussion': 0.3883885443210602,
+            'test/(slakh)micro_offset_f_Guitar': 0.6883301734924316,
+            'test/(slakh)micro_offset_f_Organ': 0.6711145043373108,
+            'test/(slakh)micro_offset_f_Piano': 0.683600664138794,
+            'test/(slakh)micro_offset_f_Pipe': 0.6132691502571106,
+            'test/(slakh)micro_offset_f_Reed': 0.6974674463272095,
+            'test/(slakh)micro_offset_f_Strings': 0.5805016160011292,
+            'test/(slakh)micro_offset_f_Synth Lead': 0.7929936647415161,
+            'test/(slakh)micro_offset_f_Synth Pad': 0.2877211272716522,
+            'test/(slakh)micro_onset_f_Bass': 0.9328573346138,
+            'test/(slakh)micro_onset_f_Brass': 0.7279624342918396,
+            'test/(slakh)micro_onset_f_Chromatic Percussion': 0.7239300012588501,
+            'test/(slakh)micro_onset_f_Guitar': 0.8129678964614868,
+            'test/(slakh)micro_onset_f_Organ': 0.7785788178443909,
+            'test/(slakh)micro_onset_f_Piano': 0.8763775825500488,
+            'test/(slakh)micro_onset_f_Pipe': 0.7128946185112,
+            'test/(slakh)micro_onset_f_Reed': 0.8024615049362183,
+            'test/(slakh)micro_onset_f_Strings': 0.7257015109062195,
+            'test/(slakh)micro_onset_f_Synth Lead': 0.8566879034042358,
+            'test/(slakh)micro_onset_f_Synth Pad': 0.4453693926334381,
+            'test/(slakh)micro_onset_f_drum': 0.9112541079521179,
+            'test/(slakh)multi_f': 0.7397979497909546,
+            'test/(slakh)offset_f': 0.6961227655410767,
+            'test/(slakh)offset_f_Bass': 0.8508948087692261,
+            'test/(slakh)offset_f_Brass': 0.6707911491394043,
+            'test/(slakh)offset_f_Chromatic Percussion': 0.3454752266407013,
+            'test/(slakh)offset_f_Guitar': 0.6841201186180115,
+            'test/(slakh)offset_f_Organ': 0.6124169230461121,
+            'test/(slakh)offset_f_Piano': 0.6597973108291626,
+            'test/(slakh)offset_f_Pipe': 0.5729255676269531,
+            'test/(slakh)offset_f_Reed': 0.6875563263893127,
+            'test/(slakh)offset_f_Strings': 0.5812338590621948,
+            'test/(slakh)offset_f_Synth Lead': 0.7286868095397949,
+            'test/(slakh)offset_f_Synth Pad': 0.27617573738098145,
+            'test/(slakh)onset_f': 0.8419071435928345,
+            'test/(slakh)onset_f_Bass': 0.9303264617919922,
+            'test/(slakh)onset_f_Brass': 0.7301008701324463,
+            'test/(slakh)onset_f_Chromatic Percussion': 0.6354409456253052,
+            'test/(slakh)onset_f_Guitar': 0.8215969800949097,
+            'test/(slakh)onset_f_Organ': 0.740757942199707,
+            'test/(slakh)onset_f_Piano': 0.8769294619560242,
+            'test/(slakh)onset_f_Pipe': 0.6801912784576416,
+            'test/(slakh)onset_f_Reed': 0.7921974658966064,
+            'test/(slakh)onset_f_Strings': 0.7303540110588074,
+            'test/(slakh)onset_f_Synth Lead': 0.8201698064804077,
+            'test/(slakh)onset_f_Synth Pad': 0.4131230413913727,
+            'test/(slakh)onset_f_drum': 0.9040946960449219}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [   {   'Piano': array([0, 1, 2, 3, 4, 5, 6, 7]),
+                              'Strings': array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51]),
+                              'Winds': array([64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79])}],
+        'presets': ['musicnet_thickstun']},
+    [   {   'test/(musicnet)frame_f': 0.6431668400764465,
+            'test/(musicnet)frame_f_pc': 0.6712867617607117,
+            'test/(musicnet)micro_offset_f_Piano': 0.462179034948349,
+            'test/(musicnet)micro_offset_f_Strings': 0.2768903076648712,
+            'test/(musicnet)micro_offset_f_Winds': 0.29622459411621094,
+            'test/(musicnet)micro_onset_f_Piano': 0.8591256141662598,
+            'test/(musicnet)micro_onset_f_Strings': 0.43876463174819946,
+            'test/(musicnet)micro_onset_f_Winds': 0.5208131670951843,
+            'test/(musicnet)micro_onset_f_drum': nan,
+            'test/(musicnet)multi_f': 0.34509798884391785,
+            'test/(musicnet)offset_f': 0.3474598824977875,
+            'test/(musicnet)offset_f_Piano': 0.462179034948349,
+            'test/(musicnet)offset_f_Strings': 0.2768903076648712,
+            'test/(musicnet)offset_f_Winds': 0.29622459411621094,
+            'test/(musicnet)onset_f': 0.6119987964630127,
+            'test/(musicnet)onset_f_Piano': 0.8591256141662598,
+            'test/(musicnet)onset_f_Strings': 0.43876463174819946,
+            'test/(musicnet)onset_f_Winds': 0.5208131670951843,
+            'test/(musicnet)onset_f_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [   {   'Piano': array([0, 1, 2, 3, 4, 5, 6, 7]),
+                              'Strings': array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51]),
+                              'Winds': array([64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79])}],
+        'presets': ['musicnet_thickstun_em']},
+    [   {   'test/(musicnet)frame_f': 0.7289137840270996,
+            'test/(musicnet)frame_f_pc': 0.7467241287231445,
+            'test/(musicnet)micro_offset_f_Piano': 0.8453038334846497,
+            'test/(musicnet)micro_offset_f_Strings': 0.5030071139335632,
+            'test/(musicnet)micro_offset_f_Winds': 0.5958272814750671,
+            'test/(musicnet)micro_onset_f_Piano': 0.9820442199707031,
+            'test/(musicnet)micro_onset_f_Strings': 0.696555495262146,
+            'test/(musicnet)micro_onset_f_Winds': 0.7763221859931946,
+            'test/(musicnet)micro_onset_f_drum': nan,
+            'test/(musicnet)multi_f': 0.64804607629776,
+            'test/(musicnet)offset_f': 0.647705078125,
+            'test/(musicnet)offset_f_Piano': 0.8453038930892944,
+            'test/(musicnet)offset_f_Strings': 0.5030071139335632,
+            'test/(musicnet)offset_f_Winds': 0.5958272814750671,
+            'test/(musicnet)onset_f': 0.8195822834968567,
+            'test/(musicnet)onset_f_Piano': 0.9820442199707031,
+            'test/(musicnet)onset_f_Strings': 0.696555495262146,
+            'test/(musicnet)onset_f_Winds': 0.7763221859931946,
+            'test/(musicnet)onset_f_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [   {   'Piano': array([0, 1, 2, 3, 4, 5, 6, 7]),
+                              'Strings': array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51]),
+                              'Winds': array([64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79])}],
+        'presets': ['musicnet_thickstun_ext']},
+    [   {   'test/(musicnet)frame_f': 0.7118843793869019,
+            'test/(musicnet)frame_f_pc': 0.7285126447677612,
+            'test/(musicnet)micro_offset_f_Piano': 0.3649955093860626,
+            'test/(musicnet)micro_offset_f_Strings': 0.3690282702445984,
+            'test/(musicnet)micro_offset_f_Winds': 0.32839900255203247,
+            'test/(musicnet)micro_onset_f_Piano': 0.6793581247329712,
+            'test/(musicnet)micro_onset_f_Strings': 0.5712332129478455,
+            'test/(musicnet)micro_onset_f_Winds': 0.5383739471435547,
+            'test/(musicnet)micro_onset_f_drum': nan,
+            'test/(musicnet)multi_f': 0.39981773495674133,
+            'test/(musicnet)offset_f': 0.4001583456993103,
+            'test/(musicnet)offset_f_Piano': 0.38060951232910156,
+            'test/(musicnet)offset_f_Strings': 0.447208970785141,
+            'test/(musicnet)offset_f_Winds': 0.3266069293022156,
+            'test/(musicnet)onset_f': 0.6380151510238647,
+            'test/(musicnet)onset_f_Piano': 0.7089095115661621,
+            'test/(musicnet)onset_f_Strings': 0.6469746828079224,
+            'test/(musicnet)onset_f_Winds': 0.5373958349227905,
+            'test/(musicnet)onset_f_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [   {   'Piano': array([0, 1, 2, 3, 4, 5, 6, 7]),
+                              'Strings': array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51]),
+                              'Winds': array([64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79])}],
+        'presets': ['musicnet_thickstun_ext_em']},
+    [   {   'test/(musicnet)frame_f': 0.8102308511734009,
+            'test/(musicnet)frame_f_pc': 0.8194969296455383,
+            'test/(musicnet)micro_offset_f_Piano': 0.7447232007980347,
+            'test/(musicnet)micro_offset_f_Strings': 0.7160074710845947,
+            'test/(musicnet)micro_offset_f_Winds': 0.6263686418533325,
+            'test/(musicnet)micro_onset_f_Piano': 0.9545997381210327,
+            'test/(musicnet)micro_onset_f_Strings': 0.8443388342857361,
+            'test/(musicnet)micro_onset_f_Winds': 0.7937955856323242,
+            'test/(musicnet)micro_onset_f_drum': nan,
+            'test/(musicnet)multi_f': 0.741904616355896,
+            'test/(musicnet)offset_f': 0.7412658929824829,
+            'test/(musicnet)offset_f_Piano': 0.7575887441635132,
+            'test/(musicnet)offset_f_Strings': 0.7756823897361755,
+            'test/(musicnet)offset_f_Winds': 0.6246463060379028,
+            'test/(musicnet)onset_f': 0.8913213014602661,
+            'test/(musicnet)onset_f_Piano': 0.9567371606826782,
+            'test/(musicnet)onset_f_Strings': 0.8836190104484558,
+            'test/(musicnet)onset_f_Winds': 0.7928102612495422,
+            'test/(musicnet)onset_f_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [{'Singing Voice': [100, 101]}],
+        'presets': ['mir_st500_voc']},
+    [   {   'test/(mir_st500)frame_f': 0.8046330809593201,
+            'test/(mir_st500)frame_f_pc': 0.8059064745903015,
+            'test/(mir_st500)melody_oa_Singing Voice': 0.7024147510528564,
+            'test/(mir_st500)melody_rca_Singing Voice': 0.7087444067001343,
+            'test/(mir_st500)melody_rpa_Singing Voice': 0.7024147510528564,
+            'test/(mir_st500)micro_offset_f_Singing Voice': 0.5492644309997559,
+            'test/(mir_st500)micro_onset_f_Singing Voice': 0.7167699337005615,
+            'test/(mir_st500)micro_onset_f_drum': nan,
+            'test/(mir_st500)multi_f': 0.5463830828666687,
+            'test/(mir_st500)offset_f': 0.5456082820892334,
+            'test/(mir_st500)offset_f_Singing Voice': 0.5464057922363281,
+            'test/(mir_st500)onset_f': 0.714525580406189,
+            'test/(mir_st500)onset_f_Singing Voice': 0.7155958414077759,
+            'test/(mir_st500)onset_f_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [{'Singing Voice': [100, 101]}],
+        'presets': ['mir_st500']},
+    [   {   'test/(mir_st500)frame_f': 0.17174109816551208,
+            'test/(mir_st500)frame_f_pc': 0.17959092557430267,
+            'test/(mir_st500)melody_oa_Singing Voice': 0.6857293844223022,
+            'test/(mir_st500)melody_rca_Singing Voice': 0.6941294074058533,
+            'test/(mir_st500)melody_rpa_Singing Voice': 0.6857293844223022,
+            'test/(mir_st500)micro_offset_f_Singing Voice': 0.5249119997024536,
+            'test/(mir_st500)micro_onset_f_Singing Voice': 0.6945751905441284,
+            'test/(mir_st500)micro_onset_f_drum': nan,
+            'test/(mir_st500)multi_f': 0.394542932510376,
+            'test/(mir_st500)offset_f': 0.10482196509838104,
+            'test/(mir_st500)offset_f_Singing Voice': 0.5240825414657593,
+            'test/(mir_st500)onset_f': 0.14195600152015686,
+            'test/(mir_st500)onset_f_Singing Voice': 0.6942352056503296,
+            'test/(mir_st500)onset_f_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [None],
+        'presets': ['enstdrums_dtp']},
+    [   {   'test/(enstdrums)frame_f': nan,
+            'test/(enstdrums)frame_f_pc': nan,
+            'test/(enstdrums)micro_onset_f_drum': 0.8911184072494507,
+            'test/(enstdrums)offset_f': nan,
+            'test/(enstdrums)onset_f': nan,
+            'test/(enstdrums)onset_f_drum': 0.895440399646759}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [None],
+        'presets': ['enstdrums_dtm']},
+    [   {   'test/(enstdrums)frame_f': nan,
+            'test/(enstdrums)frame_f_pc': nan,
+            'test/(enstdrums)micro_onset_f_drum': 0.8614727258682251,
+            'test/(enstdrums)offset_f': nan,
+            'test/(enstdrums)onset_f': nan,
+            'test/(enstdrums)onset_f_drum': 0.866191565990448}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [None],
+        'presets': ['guitarset_progression_pshift']},
+    [   {   'test/(guitarset)frame_f': 0.8917033672332764,
+            'test/(guitarset)frame_f_pc': 0.8943274617195129,
+            'test/(guitarset)micro_onset_f_drum': nan,
+            'test/(guitarset)offset_f': 0.8057622909545898,
+            'test/(guitarset)onset_f': 0.894720196723938,
+            'test/(guitarset)onset_f_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [{'Bass': array([32, 33, 34, 35, 36, 37, 38, 39])}],
+        'presets': ['rwc_pop_bass']},
+    [   {   'test/(rwc_pop)frame_f': 0.11498401314020157,
+            'test/(rwc_pop)frame_f_pc': 0.22951407730579376,
+            'test/(rwc_pop)micro_offset_f_Bass': 0.23757217824459076,
+            'test/(rwc_pop)micro_onset_f_Bass': 0.3047849237918854,
+            'test/(rwc_pop)micro_onset_f_drum': nan,
+            'test/(rwc_pop)multi_f': 0.08871123939752579,
+            'test/(rwc_pop)offset_f': 0.07318931818008423,
+            'test/(rwc_pop)offset_f_Bass': 0.22453349828720093,
+            'test/(rwc_pop)onset_f': 0.10135377943515778,
+            'test/(rwc_pop)onset_f_Bass': 0.2894594371318817,
+            'test/(rwc_pop)onset_f_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [{'Piano': array([0, 1, 2, 3, 4, 5, 6, 7])}],
+        'presets': ['maestro']},
+    [   {   'test/(maestro)frame_f': 0.8877186179161072,
+            'test/(maestro)frame_f_pc': 0.891477108001709,
+            'test/(maestro)micro_offset_f_Piano': 0.8288719058036804,
+            'test/(maestro)micro_onset_f_Piano': 0.953188419342041,
+            'test/(maestro)micro_onset_f_drum': nan,
+            'test/(maestro)multi_f': 0.8396718502044678,
+            'test/(maestro)offset_f': 0.8396490216255188,
+            'test/(maestro)offset_f_Piano': 0.8396718502044678,
+            'test/(maestro)onset_f': 0.9605904221534729,
+            'test/(maestro)onset_f_Piano': 0.9606162905693054,
+            'test/(maestro)onset_f_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [   {   'Bass': array([32, 33, 34, 35, 36, 37, 38, 39]),
+                              'Brass': array([56, 57, 58, 59, 60, 61, 62, 63]),
+                              'Chromatic Percussion': array([ 8,  9, 10, 11, 12, 13, 14, 15]),
+                              'Guitar': array([24, 25, 26, 27, 28, 29, 30, 31]),
+                              'Organ': array([16, 17, 18, 19, 20, 21, 22, 23]),
+                              'Piano': array([0, 1, 2, 3, 4, 5, 6, 7]),
+                              'Pipe': array([72, 73, 74, 75, 76, 77, 78, 79]),
+                              'Reed': array([64, 65, 66, 67, 68, 69, 70, 71]),
+                              'Strings': array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55]),
+                              'Synth Lead': array([80, 81, 82, 83, 84, 85, 86, 87]),
+                              'Synth Pad': array([88, 89, 90, 91, 92, 93, 94, 95])}],
+        'presets': ['urmp']},
+    [   {   'test/(urmp)frame_f': 0.8529648780822754,
+            'test/(urmp)frame_f_pc': 0.8660681247711182,
+            'test/(urmp)micro_offset_f_Bass': nan,
+            'test/(urmp)micro_offset_f_Brass': 0.6444324851036072,
+            'test/(urmp)micro_offset_f_Chromatic Percussion': nan,
+            'test/(urmp)micro_offset_f_Guitar': nan,
+            'test/(urmp)micro_offset_f_Organ': nan,
+            'test/(urmp)micro_offset_f_Piano': nan,
+            'test/(urmp)micro_offset_f_Pipe': nan,
+            'test/(urmp)micro_offset_f_Reed': 0.024539878591895103,
+            'test/(urmp)micro_offset_f_Strings': 0.6389819383621216,
+            'test/(urmp)micro_offset_f_Synth Lead': nan,
+            'test/(urmp)micro_offset_f_Synth Pad': nan,
+            'test/(urmp)micro_onset_f_Bass': nan,
+            'test/(urmp)micro_onset_f_Brass': 0.8284024000167847,
+            'test/(urmp)micro_onset_f_Chromatic Percussion': nan,
+            'test/(urmp)micro_onset_f_Guitar': nan,
+            'test/(urmp)micro_onset_f_Organ': nan,
+            'test/(urmp)micro_onset_f_Piano': nan,
+            'test/(urmp)micro_onset_f_Pipe': nan,
+            'test/(urmp)micro_onset_f_Reed': 0.030674846842885017,
+            'test/(urmp)micro_onset_f_Strings': 0.7788345813751221,
+            'test/(urmp)micro_onset_f_Synth Lead': nan,
+            'test/(urmp)micro_onset_f_Synth Pad': nan,
+            'test/(urmp)micro_onset_f_drum': nan,
+            'test/(urmp)multi_f': 0.6515601277351379,
+            'test/(urmp)offset_f': 0.6573383808135986,
+            'test/(urmp)offset_f_Bass': nan,
+            'test/(urmp)offset_f_Brass': 0.6444324851036072,
+            'test/(urmp)offset_f_Chromatic Percussion': nan,
+            'test/(urmp)offset_f_Guitar': nan,
+            'test/(urmp)offset_f_Organ': nan,
+            'test/(urmp)offset_f_Piano': nan,
+            'test/(urmp)offset_f_Pipe': nan,
+            'test/(urmp)offset_f_Reed': 0.025221969932317734,
+            'test/(urmp)offset_f_Strings': 0.6739915609359741,
+            'test/(urmp)offset_f_Synth Lead': nan,
+            'test/(urmp)offset_f_Synth Pad': nan,
+            'test/(urmp)onset_f': 0.7913210391998291,
+            'test/(urmp)onset_f_Bass': nan,
+            'test/(urmp)onset_f_Brass': 0.8284023404121399,
+            'test/(urmp)onset_f_Chromatic Percussion': nan,
+            'test/(urmp)onset_f_Guitar': nan,
+            'test/(urmp)onset_f_Organ': nan,
+            'test/(urmp)onset_f_Piano': nan,
+            'test/(urmp)onset_f_Pipe': nan,
+            'test/(urmp)onset_f_Reed': 0.0308399461209774,
+            'test/(urmp)onset_f_Strings': 0.8027772903442383,
+            'test/(urmp)onset_f_Synth Lead': nan,
+            'test/(urmp)onset_f_Synth Pad': nan,
+            'test/(urmp)onset_f_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [{'Piano': array([0, 1, 2, 3, 4, 5, 6, 7])}],
+        'presets': ['maps_default']},
+    [   {   'test/(maps)frame_f': 0.7393348217010498,
+            'test/(maps)frame_f_pc': 0.7572816610336304,
+            'test/(maps)micro_offset_f_Piano': 0.5382159948348999,
+            'test/(maps)micro_onset_f_Piano': 0.8817331194877625,
+            'test/(maps)micro_onset_f_drum': nan,
+            'test/(maps)multi_f': 0.5370228290557861,
+            'test/(maps)offset_f': 0.5364712476730347,
+            'test/(maps)offset_f_Piano': 0.5370274186134338,
+            'test/(maps)onset_f': 0.8763453960418701,
+            'test/(maps)onset_f_Piano': 0.8772046566009521,
+            'test/(maps)onset_f_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [   {   'Bass': array([32, 33, 34, 35, 36, 37, 38, 39]),
+                              'Brass': array([56, 57, 58, 59, 60, 61, 62, 63]),
+                              'Chromatic Percussion': array([ 8,  9, 10, 11, 12, 13, 14, 15]),
+                              'Guitar': array([24, 25, 26, 27, 28, 29, 30, 31]),
+                              'Organ': array([16, 17, 18, 19, 20, 21, 22, 23]),
+                              'Piano': array([0, 1, 2, 3, 4, 5, 6, 7]),
+                              'Pipe': array([72, 73, 74, 75, 76, 77, 78, 79]),
+                              'Reed': array([64, 65, 66, 67, 68, 69, 70, 71]),
+                              'Singing Voice': [100, 101],
+                              'Strings': array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55]),
+                              'Synth Lead': array([80, 81, 82, 83, 84, 85, 86, 87]),
+                              'Synth Pad': array([88, 89, 90, 91, 92, 93, 94, 95])}],
+        'presets': ['rwc_pop_full']},
+    [   {   'test/(rwc_pop)frame_f': 0.5036451816558838,
+            'test/(rwc_pop)frame_f_pc': 0.6125867366790771,
+            'test/(rwc_pop)melody_oa_Singing Voice': 0.11486613005399704,
+            'test/(rwc_pop)melody_rca_Singing Voice': 0.5412429571151733,
+            'test/(rwc_pop)melody_rpa_Singing Voice': 0.11486613005399704,
+            'test/(rwc_pop)micro_offset_f_Bass': 0.12412633746862411,
+            'test/(rwc_pop)micro_offset_f_Brass': 0.17169594764709473,
+            'test/(rwc_pop)micro_offset_f_Chromatic Percussion': 0.00454988656565547,
+            'test/(rwc_pop)micro_offset_f_Guitar': 0.10689836740493774,
+            'test/(rwc_pop)micro_offset_f_Organ': 0.03003580868244171,
+            'test/(rwc_pop)micro_offset_f_Piano': 0.26919493079185486,
+            'test/(rwc_pop)micro_offset_f_Pipe': 0.0404929593205452,
+            'test/(rwc_pop)micro_offset_f_Reed': 0.0871850997209549,
+            'test/(rwc_pop)micro_offset_f_Singing Voice': 0.05066283047199249,
+            'test/(rwc_pop)micro_offset_f_Strings': 0.07972945272922516,
+            'test/(rwc_pop)micro_offset_f_Synth Lead': 0.00444957846775651,
+            'test/(rwc_pop)micro_offset_f_Synth Pad': 0.003691470716148615,
+            'test/(rwc_pop)micro_onset_f_Bass': 0.15706360340118408,
+            'test/(rwc_pop)micro_onset_f_Brass': 0.21161191165447235,
+            'test/(rwc_pop)micro_onset_f_Chromatic Percussion': 0.01451630424708128,
+            'test/(rwc_pop)micro_onset_f_Guitar': 0.22117385268211365,
+            'test/(rwc_pop)micro_onset_f_Organ': 0.04916893690824509,
+            'test/(rwc_pop)micro_onset_f_Piano': 0.4931323528289795,
+            'test/(rwc_pop)micro_onset_f_Pipe': 0.05809858813881874,
+            'test/(rwc_pop)micro_onset_f_Reed': 0.09726177901029587,
+            'test/(rwc_pop)micro_onset_f_Singing Voice': 0.08127696067094803,
+            'test/(rwc_pop)micro_onset_f_Strings': 0.15419140458106995,
+            'test/(rwc_pop)micro_onset_f_Synth Lead': 0.01814058981835842,
+            'test/(rwc_pop)micro_onset_f_Synth Pad': 0.01224013976752758,
+            'test/(rwc_pop)micro_onset_f_drum': 0.6436583399772644,
+            'test/(rwc_pop)multi_f': 0.25216758251190186,
+            'test/(rwc_pop)offset_f': 0.1824045181274414,
+            'test/(rwc_pop)offset_f_Bass': 0.11402810364961624,
+            'test/(rwc_pop)offset_f_Brass': 0.1329607367515564,
+            'test/(rwc_pop)offset_f_Chromatic Percussion': 0.005995466839522123,
+            'test/(rwc_pop)offset_f_Guitar': 0.09556090831756592,
+            'test/(rwc_pop)offset_f_Organ': 0.028927000239491463,
+            'test/(rwc_pop)offset_f_Piano': 0.24980537593364716,
+            'test/(rwc_pop)offset_f_Pipe': 0.06132758408784866,
+            'test/(rwc_pop)offset_f_Reed': 0.10889723151922226,
+            'test/(rwc_pop)offset_f_Singing Voice': 0.056261900812387466,
+            'test/(rwc_pop)offset_f_Strings': 0.09541783481836319,
+            'test/(rwc_pop)offset_f_Synth Lead': 0.009463030844926834,
+            'test/(rwc_pop)offset_f_Synth Pad': 0.002910840790718794,
+            'test/(rwc_pop)onset_f': 0.33215251564979553,
+            'test/(rwc_pop)onset_f_Bass': 0.14644065499305725,
+            'test/(rwc_pop)onset_f_Brass': 0.16938887536525726,
+            'test/(rwc_pop)onset_f_Chromatic Percussion': 0.01952812261879444,
+            'test/(rwc_pop)onset_f_Guitar': 0.19601118564605713,
+            'test/(rwc_pop)onset_f_Organ': 0.053188469260931015,
+            'test/(rwc_pop)onset_f_Piano': 0.4373621344566345,
+            'test/(rwc_pop)onset_f_Pipe': 0.07636822760105133,
+            'test/(rwc_pop)onset_f_Reed': 0.126461461186409,
+            'test/(rwc_pop)onset_f_Singing Voice': 0.0904482901096344,
+            'test/(rwc_pop)onset_f_Strings': 0.1726456582546234,
+            'test/(rwc_pop)onset_f_Synth Lead': 0.022806964814662933,
+            'test/(rwc_pop)onset_f_Synth Pad': 0.009439672343432903,
+            'test/(rwc_pop)onset_f_drum': 0.6497281193733215}]]

logs/2024/mc13_256_g4_all_v7_mt3f_sqr_rms_moe_wf4_n8k2_silu_rope_rp_b36_nops/result_mc13_full_plus_256_default_mir_st500_voc_debug.json

@@ -0,0 +1,18 @@
+[   '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': None,
+        'eval_vocab': [{'Singing Voice': [100, 101]}],
+        'presets': ['mir_st500_voc_debug']},
+    [   {   'test/(mir_st500)frame_f': 0.8410361409187317,
+            'test/(mir_st500)frame_f_pc': 0.841644287109375,
+            'test/(mir_st500)melody_oa_Singing Voice': 0.7632298469543457,
+            'test/(mir_st500)melody_rca_Singing Voice': 0.765277087688446,
+            'test/(mir_st500)melody_rpa_Singing Voice': 0.7632298469543457,
+            'test/(mir_st500)micro_offset_f_Singing Voice': 0.589411199092865,
+            'test/(mir_st500)micro_onset_f_Singing Voice': 0.7484803795814514,
+            'test/(mir_st500)micro_onset_f_drum': nan,
+            'test/(mir_st500)multi_f': 0.586248517036438,
+            'test/(mir_st500)offset_f': 0.5856963992118835,
+            'test/(mir_st500)offset_f_Singing Voice': 0.5862772464752197,
+            'test/(mir_st500)onset_f': 0.7450660467147827,
+            'test/(mir_st500)onset_f_Singing Voice': 0.745836615562439,
+            'test/(mir_st500)onset_f_drum': nan}]]

logs/2024/mc13_256_g4_all_v7_mt3f_sqr_rms_moe_wf4_n8k2_silu_rope_rp_b36_nops/result_mc13_full_plus_256_default_rwc_pop_bass.json

@@ -0,0 +1,20 @@
+[   '-----------------------------------------------------------------',
+    {   'add_pitch_class_metric': ['Bass'],
+        'eval_drum_vocab': None,
+        'eval_vocab': [{'Bass': array([32, 33, 34, 35, 36, 37, 38, 39])}],
+        'presets': ['rwc_pop_bass']},
+    [   {   'test/(rwc_pop)frame_f': 0.11498401314020157,
+            'test/(rwc_pop)frame_f_pc': 0.22951407730579376,
+            'test/(rwc_pop)micro_offset_f_Bass': 0.25098368525505066,
+            'test/(rwc_pop)micro_offset_f_Bass_pc': 0.38576385378837585,
+            'test/(rwc_pop)micro_onset_f_Bass': 0.32546746730804443,
+            'test/(rwc_pop)micro_onset_f_Bass_pc': 0.509304940700531,
+            'test/(rwc_pop)micro_onset_f_drum': nan,
+            'test/(rwc_pop)multi_f': 0.1446290910243988,
+            'test/(rwc_pop)offset_f': 0.07808000594377518,
+            'test/(rwc_pop)offset_f_Bass': 0.23580260574817657,
+            'test/(rwc_pop)offset_f_Bass_pc': 0.35772594809532166,
+            'test/(rwc_pop)onset_f': 0.1098790168762207,
+            'test/(rwc_pop)onset_f_Bass': 0.30800098180770874,
+            'test/(rwc_pop)onset_f_Bass_pc': 0.4801085293292999,
+            'test/(rwc_pop)onset_f_drum': nan}]]

logs/2024/notask_all_cross_v6_xk2_amp0811_gm_ext_plus_nops_b72/result_mt3_full_plus_default_all_eval_final.json

@@ -0,0 +1,654 @@
+[   '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [None],
+        'presets': ['slakh']},
+    [   {   'test/(slakh)offset_f': 0.6083431839942932,
+            'test/(slakh)offset_p': 0.6622373461723328,
+            'test/(slakh)offset_r': 0.5666455626487732,
+            'test/(slakh)onset_f': 0.7774602174758911,
+            'test/(slakh)onset_f_drum': 0.863847553730011,
+            'test/(slakh)onset_p': 0.847067654132843,
+            'test/(slakh)onset_p_drum': 0.8507407307624817,
+            'test/(slakh)onset_r': 0.7236887216567993,
+            'test/(slakh)onset_r_drum': 0.9046840071678162,
+            'test/macro_offset_f': 0.6083431839942932,
+            'test/macro_offset_p': 0.6622373461723328,
+            'test/macro_offset_r': 0.5666455626487732,
+            'test/macro_onset_f': 0.7774602174758911,
+            'test/macro_onset_f_drum': 0.863847553730011,
+            'test/macro_onset_p': 0.847067654132843,
+            'test/macro_onset_p_drum': 0.8507407307624817,
+            'test/macro_onset_r': 0.7236887216567993,
+            'test/macro_onset_r_drum': 0.9046840071678162}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [   {   'Piano': array([0, 1, 2, 3, 4, 5, 6, 7]),
+                              'Strings': array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51]),
+                              'Winds': array([64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79])}],
+        'presets': ['musicnet_thickstun']},
+    [   {   'test/(musicnet)offset_f': 0.3357182443141937,
+            'test/(musicnet)offset_f_Piano': 0.48227936029434204,
+            'test/(musicnet)offset_f_Strings': 0.25815683603286743,
+            'test/(musicnet)offset_f_Winds': 0.26120856404304504,
+            'test/(musicnet)offset_p': 0.34956488013267517,
+            'test/(musicnet)offset_p_Piano': 0.4812760055065155,
+            'test/(musicnet)offset_p_Strings': 0.29323798418045044,
+            'test/(musicnet)offset_p_Winds': 0.25695109367370605,
+            'test/(musicnet)offset_r': 0.32450374960899353,
+            'test/(musicnet)offset_r_Piano': 0.48328691720962524,
+            'test/(musicnet)offset_r_Strings': 0.23057259619235992,
+            'test/(musicnet)offset_r_Winds': 0.2656095027923584,
+            'test/(musicnet)onset_f': 0.61080002784729,
+            'test/(musicnet)onset_f_Piano': 0.8672689199447632,
+            'test/(musicnet)onset_f_Strings': 0.41614195704460144,
+            'test/(musicnet)onset_f_Winds': 0.5253411531448364,
+            'test/(musicnet)onset_f_drum': nan,
+            'test/(musicnet)onset_p': 0.6341683268547058,
+            'test/(musicnet)onset_p_Piano': 0.8654646277427673,
+            'test/(musicnet)onset_p_Strings': 0.4726918041706085,
+            'test/(musicnet)onset_p_Winds': 0.5167785286903381,
+            'test/(musicnet)onset_p_drum': nan,
+            'test/(musicnet)onset_r': 0.5917337536811829,
+            'test/(musicnet)onset_r_Piano': 0.8690807819366455,
+            'test/(musicnet)onset_r_Strings': 0.37167689204216003,
+            'test/(musicnet)onset_r_Winds': 0.5341922640800476,
+            'test/(musicnet)onset_r_drum': nan,
+            'test/macro_offset_f': 0.3357182443141937,
+            'test/macro_offset_f_Piano': 0.48227936029434204,
+            'test/macro_offset_f_Strings': 0.25815683603286743,
+            'test/macro_offset_f_Winds': 0.26120856404304504,
+            'test/macro_offset_p': 0.34956488013267517,
+            'test/macro_offset_p_Piano': 0.4812760055065155,
+            'test/macro_offset_p_Strings': 0.29323798418045044,
+            'test/macro_offset_p_Winds': 0.25695109367370605,
+            'test/macro_offset_r': 0.32450374960899353,
+            'test/macro_offset_r_Piano': 0.48328691720962524,
+            'test/macro_offset_r_Strings': 0.23057259619235992,
+            'test/macro_offset_r_Winds': 0.2656095027923584,
+            'test/macro_onset_f': 0.61080002784729,
+            'test/macro_onset_f_Piano': 0.8672689199447632,
+            'test/macro_onset_f_Strings': 0.41614195704460144,
+            'test/macro_onset_f_Winds': 0.5253411531448364,
+            'test/macro_onset_f_drum': nan,
+            'test/macro_onset_p': 0.6341683268547058,
+            'test/macro_onset_p_Piano': 0.8654646277427673,
+            'test/macro_onset_p_Strings': 0.4726918041706085,
+            'test/macro_onset_p_Winds': 0.5167785286903381,
+            'test/macro_onset_p_drum': nan,
+            'test/macro_onset_r': 0.5917337536811829,
+            'test/macro_onset_r_Piano': 0.8690807819366455,
+            'test/macro_onset_r_Strings': 0.37167689204216003,
+            'test/macro_onset_r_Winds': 0.5341922640800476,
+            'test/macro_onset_r_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [   {   'Piano': array([0, 1, 2, 3, 4, 5, 6, 7]),
+                              'Strings': array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51]),
+                              'Winds': array([64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79])}],
+        'presets': ['musicnet_thickstun_em']},
+    [   {   'test/(musicnet)offset_f': 0.6265446543693542,
+            'test/(musicnet)offset_f_Piano': 0.8271092772483826,
+            'test/(musicnet)offset_f_Strings': 0.5159010887145996,
+            'test/(musicnet)offset_f_Winds': 0.5344406366348267,
+            'test/(musicnet)offset_p': 0.6488454937934875,
+            'test/(musicnet)offset_p_Piano': 0.8294035792350769,
+            'test/(musicnet)offset_p_Strings': 0.5695708990097046,
+            'test/(musicnet)offset_p_Winds': 0.5244486927986145,
+            'test/(musicnet)offset_r': 0.6074720025062561,
+            'test/(musicnet)offset_r_Piano': 0.8248276114463806,
+            'test/(musicnet)offset_r_Strings': 0.47147470712661743,
+            'test/(musicnet)offset_r_Winds': 0.5448207259178162,
+            'test/(musicnet)onset_f': 0.8307012915611267,
+            'test/(musicnet)onset_f_Piano': 0.9861687421798706,
+            'test/(musicnet)onset_f_Strings': 0.6919905543327332,
+            'test/(musicnet)onset_f_Winds': 0.8070346713066101,
+            'test/(musicnet)onset_f_drum': nan,
+            'test/(musicnet)onset_p': 0.861139714717865,
+            'test/(musicnet)onset_p_Piano': 0.9889042973518372,
+            'test/(musicnet)onset_p_Strings': 0.7639791965484619,
+            'test/(musicnet)onset_p_Winds': 0.791946291923523,
+            'test/(musicnet)onset_p_drum': nan,
+            'test/(musicnet)onset_r': 0.8046172261238098,
+            'test/(musicnet)onset_r_Piano': 0.9834482669830322,
+            'test/(musicnet)onset_r_Strings': 0.6324004530906677,
+            'test/(musicnet)onset_r_Winds': 0.8227091431617737,
+            'test/(musicnet)onset_r_drum': nan,
+            'test/macro_offset_f': 0.6265446543693542,
+            'test/macro_offset_f_Piano': 0.8271092772483826,
+            'test/macro_offset_f_Strings': 0.5159010887145996,
+            'test/macro_offset_f_Winds': 0.5344406366348267,
+            'test/macro_offset_p': 0.6488454937934875,
+            'test/macro_offset_p_Piano': 0.8294035792350769,
+            'test/macro_offset_p_Strings': 0.5695708990097046,
+            'test/macro_offset_p_Winds': 0.5244486927986145,
+            'test/macro_offset_r': 0.6074720025062561,
+            'test/macro_offset_r_Piano': 0.8248276114463806,
+            'test/macro_offset_r_Strings': 0.47147470712661743,
+            'test/macro_offset_r_Winds': 0.5448207259178162,
+            'test/macro_onset_f': 0.8307012915611267,
+            'test/macro_onset_f_Piano': 0.9861687421798706,
+            'test/macro_onset_f_Strings': 0.6919905543327332,
+            'test/macro_onset_f_Winds': 0.8070346713066101,
+            'test/macro_onset_f_drum': nan,
+            'test/macro_onset_p': 0.861139714717865,
+            'test/macro_onset_p_Piano': 0.9889042973518372,
+            'test/macro_onset_p_Strings': 0.7639791965484619,
+            'test/macro_onset_p_Winds': 0.791946291923523,
+            'test/macro_onset_p_drum': nan,
+            'test/macro_onset_r': 0.8046172261238098,
+            'test/macro_onset_r_Piano': 0.9834482669830322,
+            'test/macro_onset_r_Strings': 0.6324004530906677,
+            'test/macro_onset_r_Winds': 0.8227091431617737,
+            'test/macro_onset_r_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [   {   'Piano': array([0, 1, 2, 3, 4, 5, 6, 7]),
+                              'Strings': array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51]),
+                              'Winds': array([64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79])}],
+        'presets': ['musicnet_thickstun_ext']},
+    [   {   'test/(musicnet)offset_f': 0.3959674835205078,
+            'test/(musicnet)offset_f_Piano': 0.3805476725101471,
+            'test/(musicnet)offset_f_Strings': 0.4404304027557373,
+            'test/(musicnet)offset_f_Winds': 0.30910158157348633,
+            'test/(musicnet)offset_p': 0.39991551637649536,
+            'test/(musicnet)offset_p_Piano': 0.30609330534935,
+            'test/(musicnet)offset_p_Strings': 0.45054253935813904,
+            'test/(musicnet)offset_p_Winds': 0.198689267039299,
+            'test/(musicnet)offset_r': 0.39315736293792725,
+            'test/(musicnet)offset_r_Piano': 0.3786337375640869,
+            'test/(musicnet)offset_r_Strings': 0.4319221079349518,
+            'test/(musicnet)offset_r_Winds': 0.3212359547615051,
+            'test/(musicnet)onset_f': 0.6437932252883911,
+            'test/(musicnet)onset_f_Piano': 0.7200534343719482,
+            'test/(musicnet)onset_f_Strings': 0.6363336443901062,
+            'test/(musicnet)onset_f_Winds': 0.5482662916183472,
+            'test/(musicnet)onset_f_drum': nan,
+            'test/(musicnet)onset_p': 0.6502920985221863,
+            'test/(musicnet)onset_p_Piano': 0.5792450308799744,
+            'test/(musicnet)onset_p_Strings': 0.652239203453064,
+            'test/(musicnet)onset_p_Winds': 0.3531217575073242,
+            'test/(musicnet)onset_p_drum': nan,
+            'test/(musicnet)onset_r': 0.6391699910163879,
+            'test/(musicnet)onset_r_Piano': 0.716358482837677,
+            'test/(musicnet)onset_r_Strings': 0.6230224967002869,
+            'test/(musicnet)onset_r_Winds': 0.5685860514640808,
+            'test/(musicnet)onset_r_drum': nan,
+            'test/macro_offset_f': 0.3959674835205078,
+            'test/macro_offset_f_Piano': 0.3805476725101471,
+            'test/macro_offset_f_Strings': 0.4404304027557373,
+            'test/macro_offset_f_Winds': 0.30910158157348633,
+            'test/macro_offset_p': 0.39991551637649536,
+            'test/macro_offset_p_Piano': 0.30609330534935,
+            'test/macro_offset_p_Strings': 0.45054253935813904,
+            'test/macro_offset_p_Winds': 0.198689267039299,
+            'test/macro_offset_r': 0.39315736293792725,
+            'test/macro_offset_r_Piano': 0.3786337375640869,
+            'test/macro_offset_r_Strings': 0.4319221079349518,
+            'test/macro_offset_r_Winds': 0.3212359547615051,
+            'test/macro_onset_f': 0.6437932252883911,
+            'test/macro_onset_f_Piano': 0.7200534343719482,
+            'test/macro_onset_f_Strings': 0.6363336443901062,
+            'test/macro_onset_f_Winds': 0.5482662916183472,
+            'test/macro_onset_f_drum': nan,
+            'test/macro_onset_p': 0.6502920985221863,
+            'test/macro_onset_p_Piano': 0.5792450308799744,
+            'test/macro_onset_p_Strings': 0.652239203453064,
+            'test/macro_onset_p_Winds': 0.3531217575073242,
+            'test/macro_onset_p_drum': nan,
+            'test/macro_onset_r': 0.6391699910163879,
+            'test/macro_onset_r_Piano': 0.716358482837677,
+            'test/macro_onset_r_Strings': 0.6230224967002869,
+            'test/macro_onset_r_Winds': 0.5685860514640808,
+            'test/macro_onset_r_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [   {   'Piano': array([0, 1, 2, 3, 4, 5, 6, 7]),
+                              'Strings': array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51]),
+                              'Winds': array([64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79])}],
+        'presets': ['musicnet_thickstun_ext_em']},
+    [   {   'test/(musicnet)offset_f': 0.735069990158081,
+            'test/(musicnet)offset_f_Piano': 0.7454416751861572,
+            'test/(musicnet)offset_f_Strings': 0.7720898389816284,
+            'test/(musicnet)offset_f_Winds': 0.6024924516677856,
+            'test/(musicnet)offset_p': 0.7449241280555725,
+            'test/(musicnet)offset_p_Piano': 0.6016747951507568,
+            'test/(musicnet)offset_p_Strings': 0.7943185567855835,
+            'test/(musicnet)offset_p_Winds': 0.38696134090423584,
+            'test/(musicnet)offset_r': 0.7270892262458801,
+            'test/(musicnet)offset_r_Piano': 0.7391372919082642,
+            'test/(musicnet)offset_r_Strings': 0.752295732498169,
+            'test/(musicnet)offset_r_Winds': 0.6266684532165527,
+            'test/(musicnet)onset_f': 0.8967338800430298,
+            'test/(musicnet)onset_f_Piano': 0.9509001970291138,
+            'test/(musicnet)onset_f_Strings': 0.8831208944320679,
+            'test/(musicnet)onset_f_Winds': 0.8164795637130737,
+            'test/(musicnet)onset_f_drum': nan,
+            'test/(musicnet)onset_p': 0.9097173810005188,
+            'test/(musicnet)onset_p_Piano': 0.7678321003913879,
+            'test/(musicnet)onset_p_Strings': 0.9111027717590332,
+            'test/(musicnet)onset_p_Winds': 0.5252859592437744,
+            'test/(musicnet)onset_p_drum': nan,
+            'test/(musicnet)onset_r': 0.8861774206161499,
+            'test/(musicnet)onset_r_Piano': 0.9424763321876526,
+            'test/(musicnet)onset_r_Strings': 0.8583273887634277,
+            'test/(musicnet)onset_r_Winds': 0.8477022647857666,
+            'test/(musicnet)onset_r_drum': nan,
+            'test/macro_offset_f': 0.735069990158081,
+            'test/macro_offset_f_Piano': 0.7454416751861572,
+            'test/macro_offset_f_Strings': 0.7720898389816284,
+            'test/macro_offset_f_Winds': 0.6024924516677856,
+            'test/macro_offset_p': 0.7449241280555725,
+            'test/macro_offset_p_Piano': 0.6016747951507568,
+            'test/macro_offset_p_Strings': 0.7943185567855835,
+            'test/macro_offset_p_Winds': 0.38696134090423584,
+            'test/macro_offset_r': 0.7270892262458801,
+            'test/macro_offset_r_Piano': 0.7391372919082642,
+            'test/macro_offset_r_Strings': 0.752295732498169,
+            'test/macro_offset_r_Winds': 0.6266684532165527,
+            'test/macro_onset_f': 0.8967338800430298,
+            'test/macro_onset_f_Piano': 0.9509001970291138,
+            'test/macro_onset_f_Strings': 0.8831208944320679,
+            'test/macro_onset_f_Winds': 0.8164795637130737,
+            'test/macro_onset_f_drum': nan,
+            'test/macro_onset_p': 0.9097173810005188,
+            'test/macro_onset_p_Piano': 0.7678321003913879,
+            'test/macro_onset_p_Strings': 0.9111027717590332,
+            'test/macro_onset_p_Winds': 0.5252859592437744,
+            'test/macro_onset_p_drum': nan,
+            'test/macro_onset_r': 0.8861774206161499,
+            'test/macro_onset_r_Piano': 0.9424763321876526,
+            'test/macro_onset_r_Strings': 0.8583273887634277,
+            'test/macro_onset_r_Winds': 0.8477022647857666,
+            'test/macro_onset_r_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [{'Singing Voice': [100]}],
+        'presets': ['mir_st500_voc']},
+    [   {   'test/(mir_st500)offset_f': 0.5048608183860779,
+            'test/(mir_st500)offset_f_Singing Voice': 0.5061416029930115,
+            'test/(mir_st500)offset_p': 0.5133110880851746,
+            'test/(mir_st500)offset_p_Singing Voice': 0.5161048769950867,
+            'test/(mir_st500)offset_r': 0.4993303716182709,
+            'test/(mir_st500)offset_r_Singing Voice': 0.49919605255126953,
+            'test/(mir_st500)onset_f': 0.6959291696548462,
+            'test/(mir_st500)onset_f_Singing Voice': 0.6976490616798401,
+            'test/(mir_st500)onset_f_drum': nan,
+            'test/(mir_st500)onset_p': 0.7078328728675842,
+            'test/(mir_st500)onset_p_Singing Voice': 0.7117308974266052,
+            'test/(mir_st500)onset_p_drum': 0.0,
+            'test/(mir_st500)onset_r': 0.6881252527236938,
+            'test/(mir_st500)onset_r_Singing Voice': 0.6878247261047363,
+            'test/(mir_st500)onset_r_drum': nan,
+            'test/macro_offset_f': 0.5048608183860779,
+            'test/macro_offset_f_Singing Voice': 0.5061416029930115,
+            'test/macro_offset_p': 0.5133110880851746,
+            'test/macro_offset_p_Singing Voice': 0.5161048769950867,
+            'test/macro_offset_r': 0.4993303716182709,
+            'test/macro_offset_r_Singing Voice': 0.49919605255126953,
+            'test/macro_onset_f': 0.6959291696548462,
+            'test/macro_onset_f_Singing Voice': 0.6976490616798401,
+            'test/macro_onset_f_drum': nan,
+            'test/macro_onset_p': 0.7078328728675842,
+            'test/macro_onset_p_Singing Voice': 0.7117308974266052,
+            'test/macro_onset_p_drum': 0.0,
+            'test/macro_onset_r': 0.6881252527236938,
+            'test/macro_onset_r_Singing Voice': 0.6878247261047363,
+            'test/macro_onset_r_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [{'Singing Voice': [100]}],
+        'presets': ['mir_st500']},
+    [   {   'test/(mir_st500)offset_f': 0.08752609044313431,
+            'test/(mir_st500)offset_f_Singing Voice': 0.4340810775756836,
+            'test/(mir_st500)offset_p': 0.04927415773272514,
+            'test/(mir_st500)offset_p_Singing Voice': 0.44511955976486206,
+            'test/(mir_st500)offset_r': 0.4603072702884674,
+            'test/(mir_st500)offset_r_Singing Voice': 0.427217572927475,
+            'test/(mir_st500)onset_f': 0.1349075436592102,
+            'test/(mir_st500)onset_f_Singing Voice': 0.6468554735183716,
+            'test/(mir_st500)onset_f_drum': nan,
+            'test/(mir_st500)onset_p': 0.07584631443023682,
+            'test/(mir_st500)onset_p_Singing Voice': 0.6652325391769409,
+            'test/(mir_st500)onset_p_drum': 0.0,
+            'test/(mir_st500)onset_r': 0.7170646786689758,
+            'test/(mir_st500)onset_r_Singing Voice': 0.6353515386581421,
+            'test/(mir_st500)onset_r_drum': nan,
+            'test/macro_offset_f': 0.08752609044313431,
+            'test/macro_offset_f_Singing Voice': 0.4340810775756836,
+            'test/macro_offset_p': 0.04927415773272514,
+            'test/macro_offset_p_Singing Voice': 0.44511955976486206,
+            'test/macro_offset_r': 0.4603072702884674,
+            'test/macro_offset_r_Singing Voice': 0.427217572927475,
+            'test/macro_onset_f': 0.1349075436592102,
+            'test/macro_onset_f_Singing Voice': 0.6468554735183716,
+            'test/macro_onset_f_drum': nan,
+            'test/macro_onset_p': 0.07584631443023682,
+            'test/macro_onset_p_Singing Voice': 0.6652325391769409,
+            'test/macro_onset_p_drum': 0.0,
+            'test/macro_onset_r': 0.7170646786689758,
+            'test/macro_onset_r_Singing Voice': 0.6353515386581421,
+            'test/macro_onset_r_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [None],
+        'presets': ['enstdrums_dtp']},
+    [   {   'test/(enstdrums)offset_f': nan,
+            'test/(enstdrums)offset_p': 0.0,
+            'test/(enstdrums)offset_r': nan,
+            'test/(enstdrums)onset_f': nan,
+            'test/(enstdrums)onset_f_drum': 0.8802791833877563,
+            'test/(enstdrums)onset_p': 0.0,
+            'test/(enstdrums)onset_p_drum': 0.8829243183135986,
+            'test/(enstdrums)onset_r': nan,
+            'test/(enstdrums)onset_r_drum': 0.8793073296546936,
+            'test/macro_offset_f': nan,
+            'test/macro_offset_p': 0.0,
+            'test/macro_offset_r': nan,
+            'test/macro_onset_f': nan,
+            'test/macro_onset_f_drum': 0.8802791833877563,
+            'test/macro_onset_p': 0.0,
+            'test/macro_onset_p_drum': 0.8829243183135986,
+            'test/macro_onset_r': nan,
+            'test/macro_onset_r_drum': 0.8793073296546936}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [None],
+        'presets': ['enstdrums_dtm']},
+    [   {   'test/(enstdrums)offset_f': nan,
+            'test/(enstdrums)offset_p': 0.0,
+            'test/(enstdrums)offset_r': nan,
+            'test/(enstdrums)onset_f': nan,
+            'test/(enstdrums)onset_f_drum': 0.8131747245788574,
+            'test/(enstdrums)onset_p': 0.0,
+            'test/(enstdrums)onset_p_drum': 0.8289992213249207,
+            'test/(enstdrums)onset_r': nan,
+            'test/(enstdrums)onset_r_drum': 0.8042031526565552,
+            'test/macro_offset_f': nan,
+            'test/macro_offset_p': 0.0,
+            'test/macro_offset_r': nan,
+            'test/macro_onset_f': nan,
+            'test/macro_onset_f_drum': 0.8131747245788574,
+            'test/macro_onset_p': 0.0,
+            'test/macro_onset_p_drum': 0.8289992213249207,
+            'test/macro_onset_r': nan,
+            'test/macro_onset_r_drum': 0.8042031526565552}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [None],
+        'presets': ['guitarset_pshift']},
+    [   {   'test/(guitarset)offset_f': 0.7842957973480225,
+            'test/(guitarset)offset_p': 0.7916637063026428,
+            'test/(guitarset)offset_r': 0.7788985967636108,
+            'test/(guitarset)onset_f': 0.8876206874847412,
+            'test/(guitarset)onset_f_drum': nan,
+            'test/(guitarset)onset_p': 0.8953325748443604,
+            'test/(guitarset)onset_p_drum': 0.0,
+            'test/(guitarset)onset_r': 0.8822049498558044,
+            'test/(guitarset)onset_r_drum': nan,
+            'test/macro_offset_f': 0.7842957973480225,
+            'test/macro_offset_p': 0.7916637063026428,
+            'test/macro_offset_r': 0.7788985967636108,
+            'test/macro_onset_f': 0.8876206874847412,
+            'test/macro_onset_f_drum': nan,
+            'test/macro_onset_p': 0.8953325748443604,
+            'test/macro_onset_p_drum': 0.0,
+            'test/macro_onset_r': 0.8822049498558044,
+            'test/macro_onset_r_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [{'Bass': array([32, 33, 34, 35, 36, 37, 38, 39])}],
+        'presets': ['rwc_pop_bass']},
+    [   {   'test/(rwc_pop)offset_f': 0.08935749530792236,
+            'test/(rwc_pop)offset_f_Bass': 0.2769419252872467,
+            'test/(rwc_pop)offset_p': 0.05388070270419121,
+            'test/(rwc_pop)offset_p_Bass': 0.33313581347465515,
+            'test/(rwc_pop)offset_r': 0.3093760907649994,
+            'test/(rwc_pop)offset_r_Bass': 0.24953310191631317,
+            'test/(rwc_pop)onset_f': 0.12388304620981216,
+            'test/(rwc_pop)onset_f_Bass': 0.364982932806015,
+            'test/(rwc_pop)onset_f_drum': nan,
+            'test/(rwc_pop)onset_p': 0.07472005486488342,
+            'test/(rwc_pop)onset_p_Bass': 0.438348650932312,
+            'test/(rwc_pop)onset_p_drum': 0.0,
+            'test/(rwc_pop)onset_r': 0.43698573112487793,
+            'test/(rwc_pop)onset_r_Bass': 0.3284376561641693,
+            'test/(rwc_pop)onset_r_drum': nan,
+            'test/macro_offset_f': 0.08935749530792236,
+            'test/macro_offset_f_Bass': 0.2769419252872467,
+            'test/macro_offset_p': 0.05388070270419121,
+            'test/macro_offset_p_Bass': 0.33313581347465515,
+            'test/macro_offset_r': 0.3093760907649994,
+            'test/macro_offset_r_Bass': 0.24953310191631317,
+            'test/macro_onset_f': 0.12388304620981216,
+            'test/macro_onset_f_Bass': 0.364982932806015,
+            'test/macro_onset_f_drum': nan,
+            'test/macro_onset_p': 0.07472005486488342,
+            'test/macro_onset_p_Bass': 0.438348650932312,
+            'test/macro_onset_p_drum': 0.0,
+            'test/macro_onset_r': 0.43698573112487793,
+            'test/macro_onset_r_Bass': 0.3284376561641693,
+            'test/macro_onset_r_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [{'Piano': array([0, 1, 2, 3, 4, 5, 6, 7])}],
+        'presets': ['maestro']},
+    [   {   'test/(maestro)offset_f': 0.8026146292686462,
+            'test/(maestro)offset_f_Piano': 0.8027480244636536,
+            'test/(maestro)offset_p': 0.8284508585929871,
+            'test/(maestro)offset_p_Piano': 0.8287417888641357,
+            'test/(maestro)offset_r': 0.7789899706840515,
+            'test/(maestro)offset_r_Piano': 0.7789827585220337,
+            'test/(maestro)onset_f': 0.9469380974769592,
+            'test/(maestro)onset_f_Piano': 0.9470942616462708,
+            'test/(maestro)onset_f_drum': nan,
+            'test/(maestro)onset_p': 0.9780700206756592,
+            'test/(maestro)onset_p_Piano': 0.9784316420555115,
+            'test/(maestro)onset_p_drum': 0.0,
+            'test/(maestro)onset_r': 0.9185109734535217,
+            'test/(maestro)onset_r_Piano': 0.9184830784797668,
+            'test/(maestro)onset_r_drum': nan,
+            'test/macro_offset_f': 0.8026146292686462,
+            'test/macro_offset_f_Piano': 0.8027480244636536,
+            'test/macro_offset_p': 0.8284508585929871,
+            'test/macro_offset_p_Piano': 0.8287417888641357,
+            'test/macro_offset_r': 0.7789899706840515,
+            'test/macro_offset_r_Piano': 0.7789827585220337,
+            'test/macro_onset_f': 0.9469380974769592,
+            'test/macro_onset_f_Piano': 0.9470942616462708,
+            'test/macro_onset_f_drum': nan,
+            'test/macro_onset_p': 0.9780700206756592,
+            'test/macro_onset_p_Piano': 0.9784316420555115,
+            'test/macro_onset_p_drum': 0.0,
+            'test/macro_onset_r': 0.9185109734535217,
+            'test/macro_onset_r_Piano': 0.9184830784797668,
+            'test/macro_onset_r_drum': nan}],
+    '-----------------------------------------------------------------',
+    {   'eval_drum_vocab': {   'Hi-Hat': [42, 44, 46, 22, 26],
+                               'Kick Drum': [36, 35],
+                               'Snare Drum': [38, 40]},
+        'eval_vocab': [   {   'Bass': array([32, 33, 34, 35, 36, 37, 38, 39]),
+                              'Brass': array([56, 57, 58, 59, 60, 61, 62, 63]),
+                              'Chromatic Percussion': array([ 8,  9, 10, 11, 12, 13, 14, 15]),
+                              'Guitar': array([24, 25, 26, 27, 28, 29, 30, 31]),
+                              'Organ': array([16, 17, 18, 19, 20, 21, 22, 23]),
+                              'Piano': array([0, 1, 2, 3, 4, 5, 6, 7]),
+                              'Pipe': array([72, 73, 74, 75, 76, 77, 78, 79]),
+                              'Reed': array([64, 65, 66, 67, 68, 69, 70, 71]),
+                              'Strings': array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55]),
+                              'Synth Lead': array([80, 81, 82, 83, 84, 85, 86, 87]),
+                              'Synth Pad': array([88, 89, 90, 91, 92, 93, 94, 95])}],
+        'presets': ['urmp']},
+    [   {   'test/(urmp)offset_f': 0.6520498991012573,
+            'test/(urmp)offset_f_Bass': nan,
+            'test/(urmp)offset_f_Brass': 0.6848000288009644,
+            'test/(urmp)offset_f_Chromatic Percussion': nan,
+            'test/(urmp)offset_f_Guitar': nan,
+            'test/(urmp)offset_f_Organ': nan,
+            'test/(urmp)offset_f_Piano': nan,
+            'test/(urmp)offset_f_Pipe': nan,
+            'test/(urmp)offset_f_Reed': 0.10385715961456299,
+            'test/(urmp)offset_f_Strings': 0.6481411457061768,
+            'test/(urmp)offset_f_Synth Lead': nan,
+            'test/(urmp)offset_f_Synth Pad': nan,
+            'test/(urmp)offset_p': 0.6840448975563049,
+            'test/(urmp)offset_p_Bass': nan,
+            'test/(urmp)offset_p_Brass': 0.17973124980926514,
+            'test/(urmp)offset_p_Chromatic Percussion': nan,
+            'test/(urmp)offset_p_Guitar': 0.0,
+            'test/(urmp)offset_p_Organ': nan,
+            'test/(urmp)offset_p_Piano': nan,
+            'test/(urmp)offset_p_Pipe': 0.0,
+            'test/(urmp)offset_p_Reed': 0.0595238134264946,
+            'test/(urmp)offset_p_Strings': 0.6781148910522461,
+            'test/(urmp)offset_p_Synth Lead': nan,
+            'test/(urmp)offset_p_Synth Pad': nan,
+            'test/(urmp)offset_r': 0.6238455176353455,
+            'test/(urmp)offset_r_Bass': nan,
+            'test/(urmp)offset_r_Brass': 0.6537678241729736,
+            'test/(urmp)offset_r_Chromatic Percussion': nan,
+            'test/(urmp)offset_r_Guitar': nan,
+            'test/(urmp)offset_r_Organ': nan,
+            'test/(urmp)offset_r_Piano': nan,
+            'test/(urmp)offset_r_Pipe': nan,
+            'test/(urmp)offset_r_Reed': 0.06984802335500717,
+            'test/(urmp)offset_r_Strings': 0.621437132358551,
+            'test/(urmp)offset_r_Synth Lead': nan,
+            'test/(urmp)offset_r_Synth Pad': nan,
+            'test/(urmp)onset_f': 0.8094742298126221,
+            'test/(urmp)onset_f_Bass': nan,
+            'test/(urmp)onset_f_Brass': 0.865066647529602,
+            'test/(urmp)onset_f_Chromatic Percussion': nan,
+            'test/(urmp)onset_f_Guitar': nan,
+            'test/(urmp)onset_f_Organ': nan,
+            'test/(urmp)onset_f_Piano': nan,
+            'test/(urmp)onset_f_Pipe': nan,
+            'test/(urmp)onset_f_Reed': 0.1948803812265396,
+            'test/(urmp)onset_f_Strings': 0.7926455736160278,
+            'test/(urmp)onset_f_Synth Lead': nan,
+            'test/(urmp)onset_f_Synth Pad': nan,
+            'test/(urmp)onset_f_drum': nan,
+            'test/(urmp)onset_p': 0.8502802848815918,
+            'test/(urmp)onset_p_Bass': nan,
+            'test/(urmp)onset_p_Brass': 0.22704367339611053,
+            'test/(urmp)onset_p_Chromatic Percussion': nan,
+            'test/(urmp)onset_p_Guitar': 0.0,
+            'test/(urmp)onset_p_Organ': nan,
+            'test/(urmp)onset_p_Piano': nan,
+            'test/(urmp)onset_p_Pipe': 0.0,
+            'test/(urmp)onset_p_Reed': 0.10924369841814041,
+            'test/(urmp)onset_p_Strings': 0.8278226852416992,
+            'test/(urmp)onset_p_Synth Lead': nan,
+            'test/(urmp)onset_p_Synth Pad': nan,
+            'test/(urmp)onset_p_drum': nan,
+            'test/(urmp)onset_r': 0.7737197875976562,
+            'test/(urmp)onset_r_Bass': nan,
+            'test/(urmp)onset_r_Brass': 0.8258655667304993,
+            'test/(urmp)onset_r_Chromatic Percussion': nan,
+            'test/(urmp)onset_r_Guitar': nan,
+            'test/(urmp)onset_r_Organ': nan,
+            'test/(urmp)onset_r_Piano': nan,
+            'test/(urmp)onset_r_Pipe': nan,
+            'test/(urmp)onset_r_Reed': 0.1319148987531662,
+            'test/(urmp)onset_r_Strings': 0.761354923248291,
+            'test/(urmp)onset_r_Synth Lead': nan,
+            'test/(urmp)onset_r_Synth Pad': nan,
+            'test/(urmp)onset_r_drum': nan,
+            'test/macro_offset_f': 0.6520498991012573,
+            'test/macro_offset_f_Bass': nan,
+            'test/macro_offset_f_Brass': 0.6848000288009644,
+            'test/macro_offset_f_Chromatic Percussion': nan,
+            'test/macro_offset_f_Guitar': nan,
+            'test/macro_offset_f_Organ': nan,
+            'test/macro_offset_f_Piano': nan,
+            'test/macro_offset_f_Pipe': nan,
+            'test/macro_offset_f_Reed': 0.10385715961456299,
+            'test/macro_offset_f_Strings': 0.6481411457061768,
+            'test/macro_offset_f_Synth Lead': nan,
+            'test/macro_offset_f_Synth Pad': nan,
+            'test/macro_offset_p': 0.6840448975563049,
+            'test/macro_offset_p_Bass': nan,
+            'test/macro_offset_p_Brass': 0.17973124980926514,
+            'test/macro_offset_p_Chromatic Percussion': nan,
+            'test/macro_offset_p_Guitar': 0.0,
+            'test/macro_offset_p_Organ': nan,
+            'test/macro_offset_p_Piano': nan,
+            'test/macro_offset_p_Pipe': 0.0,
+            'test/macro_offset_p_Reed': 0.0595238134264946,
+            'test/macro_offset_p_Strings': 0.6781148910522461,
+            'test/macro_offset_p_Synth Lead': nan,
+            'test/macro_offset_p_Synth Pad': nan,
+            'test/macro_offset_r': 0.6238455176353455,
+            'test/macro_offset_r_Bass': nan,
+            'test/macro_offset_r_Brass': 0.6537678241729736,
+            'test/macro_offset_r_Chromatic Percussion': nan,
+            'test/macro_offset_r_Guitar': nan,
+            'test/macro_offset_r_Organ': nan,
+            'test/macro_offset_r_Piano': nan,
+            'test/macro_offset_r_Pipe': nan,
+            'test/macro_offset_r_Reed': 0.06984802335500717,
+            'test/macro_offset_r_Strings': 0.621437132358551,
+            'test/macro_offset_r_Synth Lead': nan,
+            'test/macro_offset_r_Synth Pad': nan,
+            'test/macro_onset_f': 0.8094742298126221,
+            'test/macro_onset_f_Bass': nan,
+            'test/macro_onset_f_Brass': 0.865066647529602,
+            'test/macro_onset_f_Chromatic Percussion': nan,
+            'test/macro_onset_f_Guitar': nan,
+            'test/macro_onset_f_Organ': nan,
+            'test/macro_onset_f_Piano': nan,
+            'test/macro_onset_f_Pipe': nan,
+            'test/macro_onset_f_Reed': 0.1948803812265396,
+            'test/macro_onset_f_Strings': 0.7926455736160278,
+            'test/macro_onset_f_Synth Lead': nan,
+            'test/macro_onset_f_Synth Pad': nan,
+            'test/macro_onset_f_drum': nan,
+            'test/macro_onset_p': 0.8502802848815918,
+            'test/macro_onset_p_Bass': nan,
+            'test/macro_onset_p_Brass': 0.22704367339611053,
+            'test/macro_onset_p_Chromatic Percussion': nan,
+            'test/macro_onset_p_Guitar': 0.0,
+            'test/macro_onset_p_Organ': nan,
+            'test/macro_onset_p_Piano': nan,
+            'test/macro_onset_p_Pipe': 0.0,
+            'test/macro_onset_p_Reed': 0.10924369841814041,
+            'test/macro_onset_p_Strings': 0.8278226852416992,
+            'test/macro_onset_p_Synth Lead': nan,
+            'test/macro_onset_p_Synth Pad': nan,
+            'test/macro_onset_p_drum': nan,
+            'test/macro_onset_r': 0.7737197875976562,
+            'test/macro_onset_r_Bass': nan,
+            'test/macro_onset_r_Brass': 0.8258655667304993,
+            'test/macro_onset_r_Chromatic Percussion': nan,
+            'test/macro_onset_r_Guitar': nan,
+            'test/macro_onset_r_Organ': nan,
+            'test/macro_onset_r_Piano': nan,
+            'test/macro_onset_r_Pipe': nan,
+            'test/macro_onset_r_Reed': 0.1319148987531662,
+            'test/macro_onset_r_Strings': 0.761354923248291,
+            'test/macro_onset_r_Synth Lead': nan,
+            'test/macro_onset_r_Synth Pad': nan,
+            'test/macro_onset_r_drum': nan}]]

model/RoPE/RoPE.py

@@ -0,0 +1,306 @@
+"""rotary_embedding.py - Rotary Embedding based on https://github.com/lucidrains/rotary-embedding-torch"""
+from typing import Literal, Union, Optional
+from math import pi, log
+from einops import rearrange, repeat
+
+import torch
+from torch.nn import Module, ModuleList
+from torch.cuda.amp import autocast
+from torch import nn, einsum, broadcast_tensors, Tensor
+
+
+# helper functions
+def exists(val):
+    return val is not None
+
+
+def default(val, d):
+    return val if exists(val) else d
+
+
+# broadcat, as tortoise-tts was using it
+def broadcat(tensors, dim=-1):
+    broadcasted_tensors = broadcast_tensors(*tensors)
+    return torch.cat(broadcasted_tensors, dim=dim)
+
+
+# rotary embedding helper functions
+def rotate_half(x):
+    x = rearrange(x, '... (d r) -> ... d r', r=2)
+    x1, x2 = x.unbind(dim=-1)
+    x = torch.stack((-x2, x1), dim=-1)
+    return rearrange(x, '... d r -> ... (d r)')
+
+
+@autocast(enabled=False)
+def apply_rotary_emb(freqs, t, start_index=0, scale=1., seq_dim=-2):
+    """Applies rotary embedding for pixels."""
+    if t.ndim == 3:
+        seq_len = t.shape[seq_dim]
+        freqs = freqs[-seq_len:].to(t)
+
+    rot_dim = freqs.shape[-1]
+    end_index = start_index + rot_dim
+
+    assert rot_dim <= t.shape[
+        -1], f'feature dimension {t.shape[-1]} is not of sufficient size to rotate in all the positions {rot_dim}'
+
+    t_left, t, t_right = t[..., :start_index], t[..., start_index:end_index], t[..., end_index:]
+    t = (t * freqs.cos() * scale) + (rotate_half(t) * freqs.sin() * scale)
+    return torch.cat((t_left, t, t_right), dim=-1)
+
+
+# learned rotation helpers
+def apply_learned_rotations(rotations, t, start_index=0, freq_ranges=None):
+    if exists(freq_ranges):
+        rotations = einsum('..., f -> ... f', rotations, freq_ranges)
+        rotations = rearrange(rotations, '... r f -> ... (r f)')
+
+    rotations = repeat(rotations, '... n -> ... (n r)', r=2)
+    return apply_rotary_emb(rotations, t, start_index=start_index)
+
+
+# classes
+class RotaryEmbedding(Module):
+
+    def __init__(self,
+                 dim,
+                 custom_freqs: Optional[Tensor] = None,
+                 freqs_for: Union[Literal['lang'], Literal['pixel'], Literal['constant']] = 'lang',
+                 theta=10000,
+                 max_freq=10,
+                 num_freqs=1,
+                 learned_freq=False,
+                 use_xpos=False,
+                 xpos_scale_base=512,
+                 interpolate_factor=1.,
+                 theta_rescale_factor=1.,
+                 seq_before_head_dim=False,
+                 cache_if_possible=True):
+        super().__init__()
+        # proposed by reddit user bloc97, to rescale rotary embeddings to longer sequence length without fine-tuning
+        # has some connection to NTK literature
+        # https://www.reddit.com/r/LocalLLaMA/comments/14lz7j5/ntkaware_scaled_rope_allows_llama_models_to_have/
+
+        theta *= theta_rescale_factor**(dim / (dim - 2))
+
+        self.freqs_for = freqs_for
+
+        if exists(custom_freqs):
+            freqs = custom_freqs
+        elif freqs_for == 'lang':
+            freqs = 1. / (theta**(torch.arange(0, dim, 2)[:(dim // 2)].float() / dim))
+        elif freqs_for == 'pixel':
+            freqs = torch.linspace(1., max_freq / 2, dim // 2) * pi
+        elif freqs_for == 'constant':
+            freqs = torch.ones(num_freqs).float()
+
+        self.cache_if_possible = cache_if_possible
+
+        self.tmp_store('cached_freqs', None)
+        self.tmp_store('cached_scales', None)
+
+        self.freqs = nn.Parameter(freqs, requires_grad=learned_freq)
+
+        self.learned_freq = learned_freq
+
+        # dummy for device
+
+        self.tmp_store('dummy', torch.tensor(0))
+
+        # default sequence dimension
+
+        self.seq_before_head_dim = seq_before_head_dim
+        self.default_seq_dim = -3 if seq_before_head_dim else -2
+
+        # interpolation factors
+
+        assert interpolate_factor >= 1.
+        self.interpolate_factor = interpolate_factor
+
+        # xpos
+
+        self.use_xpos = use_xpos
+        if not use_xpos:
+            self.tmp_store('scale', None)
+            return
+
+        scale = (torch.arange(0, dim, 2) + 0.4 * dim) / (1.4 * dim)
+        self.scale_base = xpos_scale_base
+        self.tmp_store('scale', scale)
+
+    @property
+    def device(self):
+        return self.dummy.device
+
+    def tmp_store(self, key, value):
+        self.register_buffer(key, value, persistent=False)
+
+    def get_seq_pos(self, seq_len, device, dtype, offset=0):
+        return (torch.arange(seq_len, device=device, dtype=dtype) + offset) / self.interpolate_factor
+
+    def rotate_queries_or_keys(self, t, seq_dim=None, offset=0, freq_seq_len=None):
+        seq_dim = default(seq_dim, self.default_seq_dim)
+
+        assert not self.use_xpos, 'you must use `.rotate_queries_and_keys` method instead and pass in both queries and keys, for length extrapolatable rotary embeddings'
+
+        device, dtype, seq_len = t.device, t.dtype, t.shape[seq_dim]
+
+        if exists(freq_seq_len):
+            assert freq_seq_len >= seq_len
+            seq_len = freq_seq_len
+
+        freqs = self.forward(self.get_seq_pos(seq_len, device=device, dtype=dtype, offset=offset),
+                             seq_len=seq_len,
+                             offset=offset)
+
+        if seq_dim == -3:
+            freqs = rearrange(freqs, 'n d -> n 1 d')
+
+        return apply_rotary_emb(freqs, t, seq_dim=seq_dim)
+
+    def rotate_queries_with_cached_keys(self, q, k, seq_dim=None, offset=0):
+        seq_dim = default(seq_dim, self.default_seq_dim)
+
+        q_len, k_len = q.shape[seq_dim], k.shape[seq_dim]
+        assert q_len <= k_len
+        rotated_q = self.rotate_queries_or_keys(q, seq_dim=seq_dim, freq_seq_len=k_len)
+        rotated_k = self.rotate_queries_or_keys(k, seq_dim=seq_dim)
+
+        rotated_q = rotated_q.type(q.dtype)
+        rotated_k = rotated_k.type(k.dtype)
+
+        return rotated_q, rotated_k
+
+    def rotate_queries_and_keys(self, q, k, seq_dim=None):
+        seq_dim = default(seq_dim, self.default_seq_dim)
+
+        assert self.use_xpos
+        device, dtype, seq_len = q.device, q.dtype, q.shape[seq_dim]
+
+        seq = self.get_seq_pos(seq_len, dtype=dtype, device=device)
+
+        freqs = self.forward(seq, seq_len=seq_len)
+        scale = self.get_scale(seq, seq_len=seq_len).to(dtype)
+
+        if seq_dim == -3:
+            freqs = rearrange(freqs, 'n d -> n 1 d')
+            scale = rearrange(scale, 'n d -> n 1 d')
+
+        rotated_q = apply_rotary_emb(freqs, q, scale=scale, seq_dim=seq_dim)
+        rotated_k = apply_rotary_emb(freqs, k, scale=scale**-1, seq_dim=seq_dim)
+
+        rotated_q = rotated_q.type(q.dtype)
+        rotated_k = rotated_k.type(k.dtype)
+
+        return rotated_q, rotated_k
+
+    def get_scale(self, t: Tensor, seq_len: Optional[int] = None, offset=0):
+        assert self.use_xpos
+
+        should_cache = (self.cache_if_possible and exists(seq_len))
+
+        if (
+            should_cache and \
+            exists(self.cached_scales) and \
+            (seq_len + offset) <= self.cached_scales.shape[0]
+        ):
+            return self.cached_scales[offset:(offset + seq_len)]
+
+        scale = 1.
+        if self.use_xpos:
+            power = (t - len(t) // 2) / self.scale_base
+            scale = self.scale**rearrange(power, 'n -> n 1')
+            scale = torch.cat((scale, scale), dim=-1)
+
+        if should_cache:
+            self.tmp_store('cached_scales', scale)
+
+        return scale
+
+    def get_axial_freqs(self, *dims):
+        Colon = slice(None)
+        all_freqs = []
+
+        for ind, dim in enumerate(dims):
+            if self.freqs_for == 'pixel':
+                pos = torch.linspace(-1, 1, steps=dim, device=self.device)
+            else:
+                pos = torch.arange(dim, device=self.device)
+
+            freqs = self.forward(pos, seq_len=dim)
+
+            all_axis = [None] * len(dims)
+            all_axis[ind] = Colon
+
+            new_axis_slice = (Ellipsis, *all_axis, Colon)
+            all_freqs.append(freqs[new_axis_slice])
+
+        all_freqs = broadcast_tensors(*all_freqs)
+        return torch.cat(all_freqs, dim=-1)
+
+    @autocast(enabled=False)
+    def forward(self, t: Tensor, seq_len=None, offset=0):
+        should_cache = (
+            self.cache_if_possible and \
+            not self.learned_freq and \
+            exists(seq_len) and \
+            self.freqs_for != 'pixel'
+        )
+
+        if (
+            should_cache and \
+            exists(self.cached_freqs) and \
+            (offset + seq_len) <= self.cached_freqs.shape[0]
+        ):
+            return self.cached_freqs[offset:(offset + seq_len)].detach()
+
+        freqs = self.freqs
+
+        freqs = einsum('..., f -> ... f', t.type(freqs.dtype), freqs)
+        freqs = repeat(freqs, '... n -> ... (n r)', r=2)
+
+        if should_cache:
+            self.tmp_store('cached_freqs', freqs.detach())
+
+        return freqs
+
+    # custom method for applying rotary embeddings
+    @torch.compiler.disable
+    def apply_rotary_custom(self, t: torch.Tensor):
+        """Apply rotary embeddings to queries and keys, if k is None, only q is rotated.
+           Depending on the freqs type, the rotation will be different."""
+        if self.freqs_for == 'lang':
+            return self.rotate_queries_or_keys(t, seq_dim=-2)
+        elif self.freqs_for == 'pixel':
+            return apply_rotary_emb(self.get_axial_freqs(t.shape[-2]), t)
+        else:
+            raise ValueError(f"freqs_for must be 'lang' or 'pixel', but got {self.freqs_for}")
+
+
+def test_rotary_embedding_lang():
+    d = 32  # d by head
+    q = torch.ones(1, 4, 110, 32)  # (B, H, T, D) for multi-head attention
+    rdim = d // 2  # will do a partial rotation on half, or d
+
+    rotary = RotaryEmbedding(dim=rdim, freqs_for="lang")
+    q = rotary.rotate_queries_or_keys(q, seq_dim=-2)
+
+    # visualize
+    import matplotlib.pyplot as plt
+    plt.imshow(q[0, 0, :, :].numpy().T, origin='lower')
+
+
+def test_rotary_embedding_pixel():
+    d = 32  # d by head
+    q = torch.ones(1, 4, 128, 32)  # (B*T, H, F, C/H) for multi-head attention
+    rdim = d // 2  # will do a partial rotation on half
+
+    rotary = RotaryEmbedding(dim=rdim, freqs_for="pixel", max_freq=10)
+    freqs = rotary.get_axial_freqs(128)
+
+    q = apply_rotary_emb(freqs, q)  # also k, if needed
+
+    # visualize
+    import matplotlib.pyplot as plt
+    plt.imshow(q[0, 0, :, :].numpy().T, origin='lower')

model/conv_block.py

@@ -0,0 +1,217 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+from typing import Literal
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from einops import rearrange
+
+
+def init_layer(layer: nn.Module) -> None:
+    """Initialize a Linear or Convolutional layer."""
+    nn.init.xavier_uniform_(layer.weight)
+    if hasattr(layer, "bias") and layer.bias is not None:
+        layer.bias.data.zero_()
+
+
+def init_bn(bn: nn.Module) -> None:
+    """Initialize a Batchnorm layer."""
+    bn.bias.data.zero_()
+    bn.weight.data.fill_(1.0)
+    bn.running_mean.data.zero_()
+    bn.running_var.data.fill_(1.0)
+
+
+def act(x: torch.Tensor, activation: str) -> torch.Tensor:
+    """Activation function."""
+    funcs = {"relu": F.relu_, "leaky_relu": lambda x: F.leaky_relu_(x, 0.01), "swish": lambda x: x * torch.sigmoid(x)}
+    return funcs.get(activation, lambda x: Exception("Incorrect activation!"))(x)
+
+
+class Res2DAVPBlock(nn.Module):
+
+    def __init__(self, in_channels, out_channels, kernel_size, avp_kernel_size, activation):
+        """Convolutional residual block modified fromr bytedance/music_source_separation."""
+        super().__init__()
+
+        padding = kernel_size[0] // 2, kernel_size[1] // 2
+
+        self.activation = activation
+        self.bn1, self.bn2 = nn.BatchNorm2d(out_channels), nn.BatchNorm2d(out_channels)
+
+        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size, padding=padding, bias=False)
+        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size, padding=padding, bias=False)
+
+        self.is_shortcut = in_channels != out_channels
+        if self.is_shortcut:
+            self.shortcut = nn.Conv2d(in_channels, out_channels, kernel_size=(1, 1))
+
+        self.avp = nn.AvgPool2d(avp_kernel_size)
+        self.init_weights()
+
+    def init_weights(self):
+        for m in [self.conv1, self.conv2] + ([self.shortcut] if self.is_shortcut else []):
+            init_layer(m)
+        for m in [self.bn1, self.bn2]:
+            init_bn(m)
+
+    def forward(self, x):
+        origin = x
+        x = act(self.bn1(self.conv1(x)), self.activation)
+        x = self.bn2(self.conv2(x))
+        x += self.shortcut(origin) if self.is_shortcut else origin
+        x = act(x, self.activation)
+        return self.avp(x)
+
+
+class PreEncoderBlockRes3B(nn.Module):
+
+    def __init__(self, in_channels, out_channels, kernel_size=(3, 3), avp_kernerl_size=(1, 2), activation='relu'):
+        """Pre-Encoder with 3 Res2DAVPBlocks."""
+        super().__init__()
+
+        self.blocks = nn.ModuleList([
+            Res2DAVPBlock(in_channels if i == 0 else out_channels, out_channels, kernel_size, avp_kernerl_size,
+                          activation) for i in range(3)
+        ])
+
+    def forward(self, x):  # (B, T, F)
+        x = rearrange(x, 'b t f -> b 1 t f')
+        for block in self.blocks:
+            x = block(x)
+        return rearrange(x, 'b c t f -> b t f c')
+
+
+def test_res3b():
+    # mel-spec input
+    x = torch.randn(2, 256, 512)  # (B, T, F)
+    pre = PreEncoderBlockRes3B(in_channels=1, out_channels=128)
+    x = pre(x)  # (2, 256, 64, 128): B T,F,C
+
+    x = torch.randn(2, 110, 1024)  # (B, T, F)
+    pre = PreEncoderBlockRes3B(in_channels=1, out_channels=128)
+    x = pre(x)  # (2, 110, 128, 128): B,T,F,C
+
+
+# ====================================================================================================================
+# PreEncoderBlockHFTT: hFT-Transformer-like Pre-encoder
+# ====================================================================================================================
+class PreEncoderBlockHFTT(nn.Module):
+
+    def __init__(self, margin_pre=15, margin_post=16) -> None:
+        """Pre-Encoder with hFT-Transformer-like convolutions."""
+        super().__init__()
+
+        self.margin_pre, self.margin_post = margin_pre, margin_post
+        self.conv = nn.Conv2d(1, 4, kernel_size=(1, 5), padding='same', padding_mode='zeros')
+        self.emb_freq = nn.Linear(128, 128)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # x: (B, T, F)
+        x = rearrange(x, 'b t f -> b 1 f t')  # (B, 1, F, T) or (2, 1, 128, 110)
+        x = F.pad(x, (self.margin_pre, self.margin_post), value=1e-7)  # (B, 1, F, T+margin) or (2,1,128,141)
+        x = self.conv(x)  # (B, C, F, T+margin) or (2, 4, 128, 141)
+        x = x.unfold(dimension=3, size=32, step=1)  # (B, c1, T, F, c2) or (2, 4, 128, 110, 32)
+        x = rearrange(x, 'b c1 f t c2 -> b t f (c1 c2)')  # (B, T, F, C) or (2, 110, 128, 128)
+        return self.emb_freq(x)  # (B, T, F, C) or (2, 110, 128, 128)
+
+
+def test_hftt():
+    # from model.spectrogram import get_spectrogram_layer_from_audio_cfg
+    # from config.config import audio_cfg as default_audio_cfg
+    # audio_cfg = default_audio_cfg
+    # audio_cfg['codec'] = 'melspec'
+    # audio_cfg['hop_length'] = 300
+    # audio_cfg['n_mels'] = 128
+    # x = torch.randn(2, 1, 32767)
+    # mspec, _ = get_spectrogram_layer_from_audio_cfg(audio_cfg)
+    # x = mspec(x)
+    x = torch.randn(2, 110, 128)  # (B, T, F)
+    pre_enc_hftt = PreEncoderBlockHFTT()
+    y = pre_enc_hftt(x)  # (2, 110, 128, 128): B, T, F, C
+
+
+# ====================================================================================================================
+# PreEncoderBlockRes3BHFTT: hFT-Transformer-like Pre-encoder with Res2DAVPBlock and spec input
+# ====================================================================================================================
+class PreEncoderBlockRes3BHFTT(nn.Module):
+
+    def __init__(self, margin_pre: int = 15, margin_post: int = 16) -> None:
+        """Pre-Encoder with hFT-Transformer-like convolutions.
+        
+        Args:
+            margin_pre (int): padding before the input
+            margin_post (int): padding after the input
+            stack_dim (Literal['c', 'f']): stack dimension. channel or frequency
+
+        """
+        super().__init__()
+        self.margin_pre, self.margin_post = margin_pre, margin_post
+        self.res3b = PreEncoderBlockRes3B(in_channels=1, out_channels=4)
+        self.emb_freq = nn.Linear(128, 128)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # x: (B, T, F) or (2, 110, 1024), input spectrogram
+        x = rearrange(x, 'b t f -> b f t')  # (2, 1024, 110): B,F,T
+        x = F.pad(x, (self.margin_pre, self.margin_post), value=1e-7)  # (2, 1024, 141): B,F,T+margin
+        x = rearrange(x, 'b f t -> b t f')  # (2, 141, 1024): B,T+margin,F
+        x = self.res3b(x)  # (2, 141, 128, 4): B,T+margin,F,C
+        x = x.unfold(dimension=1, size=32, step=1)  # (B, T, F, C1, C2) or (2, 110, 128, 4, 32)
+        x = rearrange(x, 'b t f c1 c2 -> b t f (c1 c2)')  # (B, T, F, C) or (2, 110, 128, 128)
+        return self.emb_freq(x)  # (B, T, F, C) or (2, 110, 128, 128)
+
+
+def test_res3b_hftt():
+    # from model.spectrogram import get_spectrogram_layer_from_audio_cfg
+    # from config.config import audio_cfg as default_audio_cfg
+    # audio_cfg = default_audio_cfg
+    # audio_cfg['codec'] = 'spec'
+    # audio_cfg['hop_length'] = 300
+    # x = torch.randn(2, 1, 32767)
+    # spec, _ = get_spectrogram_layer_from_audio_cfg(audio_cfg)
+    # x = spec(x)  # (2, 110, 1024): B,T,F
+    x = torch.randn(2, 110, 1024)  # (B, T, F)
+    pre_enc_res3b_hftt = PreEncoderBlockRes3BHFTT()
+    y = pre_enc_res3b_hftt(x)  # (2, 110, 128, 128): B, T, F, C
+
+
+# # ====================================================================================================================
+# # PreEncoderBlockConv1D: Pre-encoder without activation, with Melspec input
+# # ====================================================================================================================
+# class PreEncoderBlockConv1D(nn.Module):
+
+#     def __init__(self,
+#                  in_channels,
+#                  out_channels,
+#                  kernel_size=3) -> None:
+#         """Pre-Encoder with 1D convolution."""
+#         super().__init__()
+#         self.conv1 = nn.Conv1d(in_channels, out_channels, kernel_size=kernel_size, stride=1)
+#         self.conv2 = nn.Conv1d(out_channels, out_channels, kernel_size=kernel_size, stride=1)
+
+#     def forward(self, x: torch.Tensor) -> torch.Tensor:
+#         # x: (B, T, F) or (2, 128, 256), input melspec
+#         x = rearrange(x, 'b t f -> b f t')  # (2, 256, 128): B,F,T
+#         x = self.conv1(x)  # (2, 128, 128): B,F,T
+#         return rearrange(x, 'b f t -> b t f')  # (2, 110, 128): B,T,F
+
+# def test_conv1d():
+#     # from model.spectrogram import get_spectrogram_layer_from_audio_cfg
+#     # from config.config import audio_cfg as default_audio_cfg
+#     # audio_cfg = default_audio_cfg
+#     # audio_cfg['codec'] = 'melspec'
+#     # audio_cfg['hop_length'] = 256
+#     # audio_cfg['n_mels'] = 512
+#     # x = torch.randn(2, 1, 32767)
+#     # mspec, _ = get_spectrogram_layer_from_audio_cfg(audio_cfg)
+#     # x = mspec(x)
+#     x = torch.randn(2, 128, 128)  # (B, T, F)
+#     pre_enc_conv1d = PreEncoderBlockConv1D(in_channels=1, out_channels=128)
+#     y = pre_enc_conv1d(x)  # (2, 110, 128, 128): B, T, F, C

model/lr_scheduler.py

@@ -0,0 +1,91 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+"""lr_schedule.py"""
+import torch
+from typing import Dict, Optional
+
+
+def get_lr_scheduler(optimizer: torch.optim.Optimizer, scheduler_name: str, base_lr: float, scheduler_cfg: Dict):
+
+    if scheduler_name.lower() == 'cosine':
+        from torch.optim.lr_scheduler import (
+            SequentialLR,
+            LinearLR,
+            CosineAnnealingLR,
+        )
+
+        scheduler1 = LinearLR(
+            optimizer,
+            start_factor=0.5,
+            end_factor=1,
+            total_iters=scheduler_cfg["warmup_steps"],
+            last_epoch=-1,
+        )
+
+        scheduler2 = CosineAnnealingLR(
+            optimizer,
+            T_max=scheduler_cfg["total_steps"] - scheduler_cfg["warmup_steps"],
+            eta_min=scheduler_cfg["final_cosine"],
+        )
+
+        lr_scheduler = SequentialLR(optimizer,
+                                    schedulers=[scheduler1, scheduler2],
+                                    milestones=[scheduler_cfg["warmup_steps"]])
+    elif scheduler_name.lower() == 'legacy':
+        import math
+        from torch.optim.lr_scheduler import (
+            SequentialLR,
+            LinearLR,
+            LambdaLR,
+        )
+
+        msg = "You are using T5 legacy LR Schedule, it's independent from the optim.base_lr"
+        print(msg)
+
+        num_steps_optimizer1 = math.ceil(scheduler_cfg["total_steps"] * 0.9)
+        iters_left_for_optimizer2 = scheduler_cfg["total_steps"] - num_steps_optimizer1
+
+        scheduler1 = LambdaLR(optimizer, lambda step: min(base_lr, 1.0 / math.sqrt(step)) / base_lr
+                              if step else base_lr / base_lr)
+
+        scheduler2 = LinearLR(optimizer,
+                              start_factor=(min(base_lr, 1.0 / math.sqrt(num_steps_optimizer1)) / base_lr),
+                              end_factor=0,
+                              total_iters=iters_left_for_optimizer2,
+                              last_epoch=-1)
+
+        lr_scheduler = SequentialLR(
+            optimizer,
+            schedulers=[scheduler1, scheduler2],
+            milestones=[num_steps_optimizer1],
+        )
+    elif scheduler_name.lower() == 'constant':
+        from transformers import get_scheduler
+        lr_scheduler = get_scheduler(
+            name=scheduler_name.lower(),
+            optimizer=optimizer,
+        )
+    else:
+        raise NotImplementedError
+
+    return lr_scheduler
+
+
+def extra_stats(args, model, optimizer):
+    stats = {}
+
+    if args.logging.weights_l2:
+        weights_l2 = sum(p.detach().norm(2).item()**2 for p in model.parameters())**0.5
+        stats['weights_l2'] = weights_l2
+
+    cur_lr = optimizer.param_groups[0]['lr']
+    stats['lr'] = cur_lr
+
+    return stats

model/optimizers.py

@@ -0,0 +1,218 @@
+""" optimizers.py 
+
+Code based on nanoT5 project:
+    https://github.com/PiotrNawrot/nanoT5/blob/main/nanoT5/utils/copied_utils.py
+
++ D-adapt Adam from https://github.com/facebookresearch/dadaptation
+"""
+import importlib
+import math
+import torch
+
+from typing import Iterable, Tuple
+from torch import nn
+from torch.optim import Optimizer
+from transformers import Adafactor
+from torch.optim import AdamW
+
+
+class AdamWScale(Optimizer):
+    """
+    This AdamW implementation is copied from Huggingface.
+    We modified it with Adagrad scaling by rms of a weight tensor
+
+    Implements Adam algorithm with weight decay fix as introduced in [Decoupled Weight Decay
+    Regularization](https://arxiv.org/abs/1711.05101).
+
+    Parameters:
+        params (`Iterable[nn.parameter.Parameter]`):
+            Iterable of parameters to optimize or dictionaries defining parameter groups.
+        lr (`float`, *optional*, defaults to 1e-3):
+            The learning rate to use.
+        betas (`Tuple[float,float]`, *optional*, defaults to (0.9, 0.999)):
+            Adam's betas parameters (b1, b2).
+        eps (`float`, *optional*, defaults to 1e-6):
+            Adam's epsilon for numerical stability.
+        weight_decay (`float`, *optional*, defaults to 0):
+            Decoupled weight decay to apply.
+        correct_bias (`bool`, *optional*, defaults to `True`):
+            Whether or not to correct bias in Adam (for instance, in Bert TF repository they use `False`).
+        no_deprecation_warning (`bool`, *optional*, defaults to `False`):
+            A flag used to disable the deprecation warning (set to `True` to disable the warning).
+    """
+
+    def __init__(
+        self,
+        params: Iterable[nn.parameter.Parameter],
+        lr: float = 1e-3,
+        betas: Tuple[float, float] = (0.9, 0.999),
+        eps: float = 1e-6,
+        weight_decay: float = 0.0,
+        correct_bias: bool = True,
+    ):
+        if lr < 0.0:
+            raise ValueError(f"Invalid learning rate: {lr} - should be >= 0.0")
+        if not 0.0 <= betas[0] < 1.0:
+            raise ValueError(f"Invalid beta parameter: {betas[0]} - should be in [0.0, 1.0)")
+        if not 0.0 <= betas[1] < 1.0:
+            raise ValueError(f"Invalid beta parameter: {betas[1]} - should be in [0.0, 1.0)")
+        if not 0.0 <= eps:
+            raise ValueError(f"Invalid epsilon value: {eps} - should be >= 0.0")
+        defaults = dict(
+            lr=lr, betas=betas, eps=eps, weight_decay=weight_decay, correct_bias=correct_bias)
+        super().__init__(params, defaults)
+
+    @staticmethod
+    def _rms(tensor):
+        return tensor.norm(2) / (tensor.numel()**0.5)
+
+    def step(self, closure=None):
+        """
+        Performs a single optimization step.
+
+        Arguments:
+            closure (`Callable`, *optional*): A closure that reevaluates the model and returns the loss.
+        """
+        loss = None
+        if closure is not None:
+            loss = closure()
+
+        for group in self.param_groups:
+            for p in group["params"]:
+                if p.grad is None:
+                    continue
+                grad = p.grad.data
+                if grad.is_sparse:
+                    raise RuntimeError(
+                        "Adam does not support sparse gradients, please consider SparseAdam instead"
+                    )
+
+                state = self.state[p]
+                beta1, beta2 = group["betas"]
+
+                # State initialization
+                if len(state) == 0:
+                    state["step"] = 0
+                    # Exponential moving average of gradient values
+                    state["exp_avg"] = torch.zeros_like(p.data)
+                    # Exponential moving average of squared gradient values
+                    state["exp_avg_sq"] = torch.zeros_like(p.data)
+
+                exp_avg, exp_avg_sq = state["exp_avg"], state["exp_avg_sq"]
+
+                state["step"] += 1
+
+                # Decay the first and second moment running average coefficient
+                # In-place operations to update the averages at the same time
+                exp_avg.mul_(beta1).add_(grad, alpha=(1.0 - beta1))
+                exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1.0 - beta2)
+                denom = exp_avg_sq.sqrt().add_(group["eps"])
+
+                step_size = group["lr"]
+                if group["correct_bias"]:  # No bias correction for Bert
+                    bias_correction1 = 1.0 - beta1**state["step"]
+                    bias_correction2 = 1.0 - beta2**state["step"]
+                    step_size = step_size * math.sqrt(bias_correction2) / bias_correction1
+
+                # /Adapt Step from Adagrad
+                step_size = step_size * max(1e-3, self._rms(p.data))
+                # /Adapt Step from Adagrad
+
+                p.data.addcdiv_(exp_avg, denom, value=-step_size)
+
+                # Just adding the square of the weights to the loss function is *not*
+                # the correct way of using L2 regularization/weight decay with Adam,
+                # since that will interact with the m and v parameters in strange ways.
+                #
+                # Instead we want to decay the weights in a manner that doesn't interact
+                # with the m/v parameters. This is equivalent to adding the square
+                # of the weights to the loss with plain (non-momentum) SGD.
+                # Add weight decay at the end (fixed version)
+                if group["weight_decay"] > 0.0:
+                    p.data.add_(p.data, alpha=(-group["lr"] * group["weight_decay"]))
+
+        return loss
+
+
+# def get_optimizer(models_dict: nn.ModuleDict,
+#                   optimizer_name: str,
+#                   base_lr: float,
+#                   weight_decay: float = 0.):
+
+#     no_decay = [
+#         "bias", "LayerNorm", "layernorm", "layer_norm", "ln", "BatchNorm", "bn", "batch_norm",
+#         "batchnorm"
+#     ]
+
+
+#     optimizer_grouped_parameters = []
+#     for name, current_model in models_dict.items():
+#         if current_model is None:
+#             continue
+#         optimizer_grouped_parameters += [
+#             {
+#                 "params": [
+#                     p for n, p in current_model.named_parameters()
+#                     if not any(nd in n for nd in no_decay)
+#                 ],
+#                 "weight_decay": weight_decay,
+#             },
+#             {
+#                 "params": [
+#                     p for n, p in current_model.named_parameters()
+#                     if any(nd in n for nd in no_decay)
+#                 ],
+#                 "weight_decay": 0.0,
+#             },
+#         ]
+def get_optimizer(models_dict: nn.ModuleDict,
+                  optimizer_name: str,
+                  base_lr: float,
+                  weight_decay: float = 0.):
+
+    no_decay = [
+        "bias", "LayerNorm", "layernorm", "layer_norm", "ln", "BatchNorm", "bn", "batch_norm",
+        "batchnorm"
+    ]
+    optimizer_grouped_parameters = []
+    for n, p in models_dict:
+        # drop pitch shifter
+        if 'pshifters' in n:
+            continue
+        # no decay
+        if n in no_decay:
+            optimizer_grouped_parameters.append({"params": [p], "weight_decay": 0.0})
+        else:
+            optimizer_grouped_parameters.append({"params": [p], "weight_decay": weight_decay})
+
+    if optimizer_name.lower() == 'adamw':
+        base_lr = 1e-03 if base_lr == None else float(base_lr)
+        opt = AdamW(optimizer_grouped_parameters, lr=base_lr)
+    elif optimizer_name.lower() == 'adafactor':
+        if base_lr == None:
+            opt = Adafactor(
+                optimizer_grouped_parameters,
+                lr=None,
+                scale_parameter=True,
+                relative_step=True,
+                warmup_init=True)
+        else:
+            opt = Adafactor(optimizer_grouped_parameters, lr=base_lr, relative_step=False)
+    elif optimizer_name.lower() == 'adamwscale':
+        base_lr = 1e-02 if base_lr == None else float(base_lr)
+        opt = AdamWScale(
+            optimizer_grouped_parameters,
+            lr=base_lr,
+        )
+    elif optimizer_name.lower() == 'cpuadam':
+        dspd = importlib.import_module('deepspeed')
+        base_lr = 1e-03 if base_lr == None else float(base_lr)
+        opt = dspd.ops.adam.cpu_adam.DeepSpeedCPUAdam(optimizer_grouped_parameters, lr=base_lr)
+    elif optimizer_name.lower() == 'dadaptadam':
+        dadaptation = importlib.import_module('dadaptation')
+        base_lr = 1.0 if base_lr == None else float(base_lr)
+        opt = dadaptation.DAdaptAdam(optimizer_grouped_parameters, lr=base_lr)
+    else:
+        raise NotImplementedError(optimizer_name)
+
+    return opt, base_lr

model/pitchshift_layer.py

@@ -0,0 +1,550 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+"""pitchshift.py"""
+# import math
+import numpy as np
+# from scipy import special
+from einops import rearrange
+from typing import Optional, Literal, Dict, List, Tuple, Callable
+
+import torch
+from torch import nn
+import torchaudio
+from torchaudio import transforms
+# from torchaudio import functional as F
+# from torchaudio.functional.functional import (
+#     _fix_waveform_shape,
+#     _stretch_waveform,
+# )
+# from model.ops import adjust_b_to_gcd, check_all_elements_equal
+
+
+class PitchShiftLayer(nn.Module):
+    """Applying batch-wise pitch-shift to time-domain audio signals.
+
+    Args:
+        pshift_range (List[int]): Range of pitch shift in semitones. Default: ``[-2, 2]``.
+        resample_source_fs (int): Default is 4000.
+        stretch_n_fft (int): Default is 2048.
+        window: (Optional[Literal['kaiser']]) Default is None.
+        beta: (Optional[float]): Parameter for 'kaiser' filter. Default: None.
+    """
+
+    def __init__(
+        self,
+        pshift_range: List[int] = [-2, 2],
+        resample_source_fs: int = 4000,
+        strecth_n_fft: int = 512,
+        win_length: Optional[int] = None,
+        hop_length: Optional[int] = None,
+        window: Optional[Literal['kaiser']] = None,
+        beta: Optional[float] = None,
+        expected_input_shape: Optional[Tuple[int]] = None,
+        device: Optional[torch.device] = None,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        self.pshift_range = pshift_range
+        self.resample_source_fs = resample_source_fs
+        self.strecth_n_fft = strecth_n_fft
+        self.win_length = win_length
+        self.hop_length = hop_length
+
+        if window is None:
+            self.window_fn = torch.hann_window
+            self.window_kwargs = None
+        elif 'kaiser' in window:
+
+            def custom_kaiser_window(window_length, beta, **kwargs):
+                return torch.kaiser_window(window_length, periodic=True, beta=beta, **kwargs)
+
+            self.window_fn = custom_kaiser_window
+            self.window_kwargs = {'beta': beta}
+
+        # Initialize pitch shifters for every semitone
+        self.pshifters = None
+        self.frame_gaps = None
+        self._initialize_pshifters(expected_input_shape, device=device)
+        self.requires_grad_(False)
+
+    def _initialize_pshifters(self,
+                              expected_input_shape: Optional[Tuple[int]] = None,
+                              device: Optional[torch.device] = None) -> None:
+        # DDP requires initializing parameters with a dummy input
+        if expected_input_shape is not None:
+            if device is not None:
+                dummy_input = torch.randn(expected_input_shape, requires_grad=False).to(device)
+            else:
+                dummy_input = torch.randn(expected_input_shape, requires_grad=False)
+        else:
+            dummy_input = None
+
+        pshifters = nn.ModuleDict()
+        for semitone in range(self.pshift_range[0], self.pshift_range[1] + 1):
+            if semitone == 0:
+                # No need to shift and resample
+                pshifters[str(semitone)] = None
+            else:
+                pshifter = transforms.PitchShift(self.resample_source_fs,
+                                                 n_steps=semitone,
+                                                 n_fft=self.strecth_n_fft,
+                                                 win_length=self.win_length,
+                                                 hop_length=self.hop_length,
+                                                 window_fn=self.window_fn,
+                                                 wkwargs=self.window_kwargs)
+                pshifters[str(semitone)] = pshifter
+                # Pass dummy input to initialize parameters
+                with torch.no_grad():
+                    if dummy_input is not None:
+                        _ = pshifter.initialize_parameters(dummy_input)
+        self.pshifters = pshifters
+
+    def calculate_frame_gaps(self) -> Dict[int, float]:
+        """Calculate the expected gap between the original and the stretched audio."""
+        frame_gaps = {}  # for debugging
+        for semitone in range(self.pshift_range[0], self.pshift_range[1] + 1):
+            if semitone == 0:
+                # No need to shift and resample
+                frame_gaps[semitone] = 0.
+            else:
+                pshifter = self.pshifters[str(semitone)]
+                gap_in_ms = 1000. * (pshifter.kernel.shape[2] -
+                                     pshifter.kernel.shape[0] / 2.0**(-float(semitone) / 12)) / self.resample_source_fs
+                frame_gaps[semitone] = gap_in_ms
+        return frame_gaps
+
+    @torch.no_grad()
+    def forward(self, x: torch.Tensor, semitone: int) -> torch.Tensor:
+        """
+        Args:
+            x (torch.Tensor): (B, 1, T) or (B, T)
+        Returns:
+            torch.Tensor: (B, 1, T) or (B, T)
+        """
+        if semitone == 0:
+            return x
+        elif semitone >= min(self.pshift_range) and semitone <= max(self.pshift_range):
+            return self.pshifters[str(semitone)](x)
+        else:
+            raise ValueError(f"semitone must be in range {self.pshift_range}")
+
+
+def test_resampler_sinewave():
+    # x: {440Hz, 220Hz} sine wave at 16kHz
+    t = torch.arange(0, 2, 1 / 16000)  # 2 seconds at 16kHz
+    x0 = torch.sin(2 * torch.pi * 440 * t) * 0.5
+    x1 = torch.sin(2 * torch.pi * 220 * t) * 0.5
+    x = torch.stack((x0, x1), dim=0)  # (2, 32000)
+
+    # Resample
+    psl = PitchShiftLayer(pshift_range=[-2, 2], resample_source_fs=4000)
+    y = psl(x, 2)  # (2, 24000)
+
+    # Export to wav
+    torchaudio.save("x.wav", x, 16000, bits_per_sample=16)
+    torchaudio.save("y.wav", y, 12000, bits_per_sample=16)
+
+
+# class Resampler(nn.Module):
+#     """
+#     Resampling using conv1d operations, more memory-efficient than torchaudio's resampler.
+
+#     Based on Dan Povey's resampler.py:
+#     https://github.com/danpovey/filtering/blob/master/lilfilter/resampler.py
+#     """
+
+#     def __init__(self,
+#                  input_sr: int,
+#                  output_sr: int,
+#                  dtype: torch.dtype = torch.float32,
+#                  filter_width: int = 16,
+#                  cutoff_ratio: float = 0.85,
+#                  filter: Literal['kaiser', 'kaiser_best', 'kaiser_fast', 'hann'] = 'kaiser_fast',
+#                  beta: float = 8.555504641634386) -> None:
+#         super().__init__()  # init the base class
+#         """
+#         Initialize the Resampler.
+
+#         Args:
+#         - input_sr (int): Input sampling rate.
+#         - output_sr (int): Output sampling rate.
+#         - dtype (torch.dtype): Computation data type. Default: torch.float32.
+#         - filter_width (int): Number of zeros per side in the sinc function. Default: 16.
+#         - cutoff_ratio (float): Filter rolloff point as a fraction of Nyquist freq. Default: 0.95.
+#         - filter (str): Filter type. One of ['kaiser', 'kaiser_best', 'kaiser_fast', 'hann']. Default: 'kaiser_fast'.
+#         - beta (float): Parameter for 'kaiser' filter. Default: 8.555504641634386.
+
+#         Note: Ratio between input_sr and output_sr should be reduced to simplest form.
+#         """
+#         assert isinstance(input_sr, int) and isinstance(output_sr, int)
+#         if input_sr == output_sr:
+#             self.resample_type = 'trivial'
+#             return
+
+#         d = math.gcd(input_sr, output_sr)
+#         input_sr, output_sr = input_sr // d, output_sr // d
+
+#         assert dtype in [torch.float32, torch.float64]
+#         assert filter_width > 3  # a reasonable bare minimum
+#         np_dtype = np.float32 if dtype == torch.float32 else np.float64
+
+#         assert filter in ['hann', 'kaiser', 'kaiser_best', 'kaiser_fast']
+
+#         if filter == 'kaiser_best':
+#             filter_width = 64
+#             beta = 14.769656459379492
+#             cutoff_ratio = 0.9475937167399596
+#             filter = 'kaiser'
+#         elif filter == 'kaiser_fast':
+#             filter_width = 16
+#             beta = 8.555504641634386
+#             cutoff_ratio = 0.85
+#             filter = 'kaiser'
+#         """
+#         - Define a sample 'block' correlating `input_sr` input samples to `output_sr` output samples.
+#         - Dividing samples into these blocks allows corresponding block alignment.
+#         - On average, `zeros_per_block` zeros per block are present in the sinc function.
+#         """
+#         zeros_per_block = min(input_sr, output_sr) * cutoff_ratio
+#         """
+#         - Define conv kernel size n = (blocks_per_side*2 + 1), adding blocks to each side of the center.
+#         - `blocks_per_side` blocks as window radius ensures each central block sample accesses its window.
+#         - `blocks_per_side` is determined, rounding up if needed, as 1 + int(filter_width / zeros_per_block).
+#         """
+#         blocks_per_side = int(np.ceil(filter_width / zeros_per_block))
+
+#         kernel_width = 2 * blocks_per_side + 1
+
+#         # Shape of conv1d weights: (out_channels, in_channels, kernel_width)
+#         """ Time computations are in units of 1 block, aligning with the `canonical` time axis,
+#         since each block has input_sr input samples, adhering to our time unit."""
+
+#         window_radius_in_blocks = blocks_per_side
+#         """`times` will be sinc function arguments, expanding to shape (output_sr, input_sr, kernel_width)
+#         via broadcasting. Ensuring t == 0 along the central block diagonal (when input_sr == output_sr)"""
+#         times = (
+#             np.arange(output_sr, dtype=np_dtype).reshape(
+#                 (output_sr, 1, 1)) / output_sr - np.arange(input_sr, dtype=np_dtype).reshape(
+#                     (1, input_sr, 1)) / input_sr - (np.arange(kernel_width, dtype=np_dtype).reshape(
+#                         (1, 1, kernel_width)) - blocks_per_side))
+
+#         def hann_window(a):
+#             """
+#             returning 0.5 + 0.5 cos(a*pi) on [-1,1] and 0 outside.
+#             """
+#             return np.heaviside(1 - np.abs(a), 0.0) * (0.5 + 0.5 * np.cos(a * np.pi))
+
+#         def kaiser_window(a, beta):
+#             w = special.i0(beta * np.sqrt(np.clip(1 - (
+#                 (a - 0.0) / 1.0)**2.0, 0.0, 1.0))) / special.i0(beta)
+#             return np.heaviside(1 - np.abs(a), 0.0) * w
+
+#         """The weights are computed as a sinc function times a Hann-window function, normalized by
+#         `zeros_per_block` (sinc) and `input_sr` (input function) to maintain integral and magnitude."""
+#         if filter == 'hann':
+#             weights = (
+#                 np.sinc(times * zeros_per_block) * hann_window(times / window_radius_in_blocks) *
+#                 zeros_per_block / input_sr)
+#         else:
+#             weights = (
+#                 np.sinc(times * zeros_per_block) *
+#                 kaiser_window(times / window_radius_in_blocks, beta) * zeros_per_block / input_sr)
+
+#         self.input_sr = input_sr
+#         self.output_sr = output_sr
+#         """If output_sr == 1, merge input_sr into kernel_width for weights (shape: output_sr, input_sr,
+#         kernel_width) to optimize convolution speed and avoid extra reshaping."""
+
+#         assert weights.shape == (output_sr, input_sr, kernel_width)
+#         if output_sr == 1:
+#             self.resample_type = 'integer_downsample'
+#             self.padding = input_sr * blocks_per_side
+#             weights = torch.tensor(weights, dtype=dtype, requires_grad=False)
+#             weights = weights.transpose(1, 2).contiguous().view(1, 1, input_sr * kernel_width)
+
+#         elif input_sr == 1:
+#             # For conv_transpose, use weights as if input_sr and output_sr were swapped, simulating downsampling.
+#             self.resample_type = 'integer_upsample'
+#             self.padding = output_sr * blocks_per_side
+#             weights = torch.tensor(weights, dtype=dtype, requires_grad=False)
+#             weights = weights.flip(2).transpose(0,
+#                                                 2).contiguous().view(1, 1, output_sr * kernel_width)
+#         else:
+#             self.resample_type = 'general'
+#             self.reshaped = False
+#             self.padding = blocks_per_side
+#             weights = torch.tensor(weights, dtype=dtype, requires_grad=False)
+
+#         self.weights = torch.nn.Parameter(weights, requires_grad=False)
+
+#     @torch.no_grad()
+#     def forward(self, x: torch.Tensor) -> torch.Tensor:
+#         """
+#         Parameters:
+#         - x: torch.Tensor, with shape (minibatch_size, sequence_length), dtype should match the instance's dtype.
+
+#         Returns:
+#         - A torch.Tensor with shape (minibatch_size, (sequence_length//input_sr)*output_sr), dtype matching the input,
+#           and content resampled.
+#         """
+#         if self.resample_type == 'trivial':
+#             return x
+#         elif self.resample_type == 'integer_downsample':
+#             (minibatch_size, seq_len) = x.shape  # (B, in_C, L) with in_C == 1
+#             x = x.unsqueeze(1)
+#             x = torch.nn.functional.conv1d(
+#                 x, self.weights, stride=self.input_sr, padding=self.padding)  # (B, out_C, L)
+#             return x.squeeze(1)  # (B, L)
+
+#         elif self.resample_type == 'integer_upsample':
+#             x = x.unsqueeze(1)
+#             x = torch.nn.functional.conv_transpose1d(
+#                 x, self.weights, stride=self.output_sr, padding=self.padding)
+
+#             return x.squeeze(1)
+#         else:
+#             assert self.resample_type == 'general'
+#             (minibatch_size, seq_len) = x.shape
+#             num_blocks = seq_len // self.input_sr
+#             if num_blocks == 0:
+#                 # TODO: pad with zeros.
+#                 raise RuntimeError("Signal is too short to resample")
+#             # Truncate input
+#             x = x[:, 0:(num_blocks * self.input_sr)].view(minibatch_size, num_blocks, self.input_sr)
+#         x = x.transpose(1, 2)  # (B, in_C, L)
+#         x = torch.nn.functional.conv1d(
+#             x, self.weights, padding=self.padding)  # (B, out_C, num_blocks)
+#         return x.transpose(1, 2).contiguous().view(minibatch_size, num_blocks * self.output_sr)
+
+# def test_resampler_sinewave():
+#     import torchaudio
+#     # x: {440Hz, 220Hz} sine wave at 16kHz
+#     t = torch.arange(0, 2, 1 / 16000)  # 2 seconds at 16kHz
+#     x0 = torch.sin(2 * torch.pi * 440 * t) * 0.5
+#     x1 = torch.sin(2 * torch.pi * 220 * t) * 0.5
+#     x = torch.stack((x0, x1), dim=0)  # (2, 32000)
+
+#     # Resample
+#     resampler = Resampler(input_sr=16000, output_sr=12000)
+#     y = resampler(x)  # (2, 24000)
+
+#     # Export to wav
+#     torchaudio.save("x.wav", x, 16000, bits_per_sample=16)
+#     torchaudio.save("y.wav", y, 12000, bits_per_sample=16)
+
+# def test_resampler_music():
+#     import torchaudio
+#     # x: music at 16kHz
+#     x, _ = torchaudio.load("music.wav")
+#     slice_length = 32000
+#     n_slices = 80
+#     slices = [x[0, i * slice_length:(i + 1) * slice_length] for i in range(n_slices)]
+#     x = torch.stack(slices)  # (80, 32000)
+
+#     # Resample
+#     filter_width = 32
+#     resampler = Resampler(16000, 12000, filter_width=filter_width)
+#     y = resampler(x)  # (80, 24000)
+#     y = y.reshape(1, -1)  # (1, 1920000)
+#     torchaudio.save(f"y_filter_width{filter_width}.wav", y, 12000, bits_per_sample=16)
+
+# class PitchShiftLayer(nn.Module):
+#     """Applying batch-wise pitch-shift to time-domain audio signals.
+
+#     Args:
+#         expected_input_length (int): Expected input length. Default: ``32767``.
+#         pshift_range (List[int]): Range of pitch shift in semitones. Default: ``[-2, 2]``.
+#         min_gcd (int): Minimum GCD of input and output sampling rates for resampling. Setting high value can save GPU memory. Default: ``16``.
+#         max_timing_error (float): Maximum allowed timing error in seconds. Default: ``0.002``.
+#         fs (int): Sample rate of input waveform, x. Default: 16000.
+#         bins_per_octave (int, optional): The number of steps per octave (Default : ``12``).
+#         n_fft (int, optional): Size of FFT, creates ``n_fft // 2 + 1`` bins (Default: ``512``).
+#         win_length (int or None, optional): Window size. If None, then ``n_fft`` is used. (Default: ``None``).
+#         hop_length (int or None, optional): Length of hop between STFT windows. If None, then ``win_length // 4``
+#             is used (Default: ``None``).
+#         window (Tensor or None, optional): Window tensor that is applied/multiplied to each frame/window.
+#             If None, then ``torch.hann_window(win_length)`` is used (Default: ``None``).
+
+#     """
+
+#     def __init__(
+#         self,
+#         expected_input_length: int = 32767,
+#         pshift_range: List[int] = [-2, 2],
+#         min_gcd: int = 16,
+#         max_timing_error: float = 0.002,
+#         fs: int = 16000,
+#         bins_per_octave: int = 12,
+#         n_fft: int = 2048,
+#         win_length: Optional[int] = None,
+#         hop_length: Optional[int] = None,
+#         window: Optional[torch.Tensor] = None,
+#         filter_width: int = 16,
+#         filter: Literal['kaiser', 'kaiser_best', 'kaiser_fast', 'hann'] = 'kaiser_fast',
+#         cutoff_ratio: float = 0.85,
+#         beta: float = 8.555504641634386,
+#         **kwargs,
+#     ):
+#         super().__init__()
+#         self.expected_input_length = expected_input_length
+#         self.pshift_range = pshift_range
+#         self.min_gcd = min_gcd
+#         self.max_timing_error = max_timing_error
+#         self.fs = fs
+#         self.bins_per_octave = bins_per_octave
+#         self.n_fft = n_fft
+#         self.win_length = win_length
+#         self.hop_length = hop_length
+#         self.window = window
+#         self.resample_args = {
+#             "filter_width": filter_width,
+#             "filter": filter,
+#             "cutoff_ratio": cutoff_ratio,
+#             "beta": beta,
+#         }
+
+#         # Initialize Resamplers
+#         self._initialize_resamplers()
+
+#     def _initialize_resamplers(self):
+#         resamplers = nn.ModuleDict()
+#         self.frame_gaps = {}  # for debugging
+#         for i in range(self.pshift_range[0], self.pshift_range[1] + 1):
+#             if i == 0:
+#                 # No need to shift and resample
+#                 resamplers[str(i)] = None
+#             else:
+#                 # Find optimal reconversion frames meeting the min_gcd
+#                 stretched_frames, recon_frames, gap = self._find_optimal_reconversion_frames(i)
+#                 self.frame_gaps[i] = gap
+#                 resamplers[str(i)] = Resampler(stretched_frames, recon_frames, **self.resample_args)
+#         self.resamplers = resamplers
+
+#     def _find_optimal_reconversion_frames(self, semitone: int):
+#         """
+#         Find the optimal reconversion frames for a given source sample rate, input length, and semitone for strech.
+
+#         Parameters:
+#         - sr (int): Input audio sample rate, which should be power of 2
+#         - n_step (int): The number of pitch-shift steps in semi-tone.
+#         - min_gcd (int): The minimum desired GCD, power of 2. Defaults to 16. 16 or 32 are good choices.
+#         - max_timing_error (float): The maximum allowed timing error, in seconds. Defaults to 5 ms
+
+#         Returns:
+#         - int: The optimal target sample rate
+#         """
+#         stretch_rate = 1 / 2.0**(-float(semitone) / self.bins_per_octave)
+#         stretched_frames = round(self.expected_input_length * stretch_rate)
+
+#         gcd = math.gcd(self.expected_input_length, stretched_frames)
+#         if gcd >= self.min_gcd:
+#             return stretched_frames, self.expected_input_length, 0
+#         else:
+#             reconversion_frames = adjust_b_to_gcd(stretched_frames, self.expected_input_length,
+#                                                   self.min_gcd)
+#             gap = reconversion_frames - self.expected_input_length
+#             gap_sec = gap / self.fs
+#             if gap_sec > self.max_timing_error:
+#                 # TODO: modifying vocoder of stretch_waveform to adjust pitch-shift rate in cents
+#                 raise ValueError(
+#                     gap_sec < self.max_timing_error,
+#                     f"gap_sec={gap_sec} > max_timing_error={self.max_timing_error} with semitone={semitone}, stretched_frames={stretched_frames}, recon_frames={reconversion_frames}. Try adjusting input lenght or decreasing min_gcd."
+#                 )
+#             else:
+#                 return stretched_frames, reconversion_frames, gap_sec
+
+#     @torch.no_grad()
+#     def forward(self,
+#                 x: torch.Tensor,
+#                 semitone: int,
+#                 resample: bool = True,
+#                 fix_shape: bool = True) -> torch.Tensor:
+#         """
+#         Args:
+#             x (torch.Tensor): (B, 1, T)
+#         Returns:
+#             torch.Tensor: (B, 1, T)
+#         """
+#         if semitone == 0:
+#             return x
+#         elif semitone >= min(self.pshift_range) and semitone <= max(self.pshift_range):
+#             x = x.squeeze(1)  # (B, T)
+#             original_x_size = x.size()
+#             x = _stretch_waveform(
+#                 x,
+#                 semitone,
+#                 self.bins_per_octave,
+#                 self.n_fft,
+#                 self.win_length,
+#                 self.hop_length,
+#                 self.window,
+#             )
+#             if resample:
+#                 x = self.resamplers[str(semitone)].forward(x)
+#             # Fix waveform shape
+#             if fix_shape:
+#                 if x.size(1) != original_x_size[1]:
+#                     # print(f"Warning: {x.size(1)} != {original_x_length}")
+#                     x = _fix_waveform_shape(x, original_x_size)
+#             return x.unsqueeze(1)  # (B, 1, T)
+#         else:
+#             raise ValueError(f"semitone must be in range {self.pshift_range}")
+
+# def test_pitchshift_layer():
+#     import torchaudio
+#     # music
+#     # x, _ = torchaudio.load("music.wav")
+#     # slice_length = 32767
+#     # n_slices = 80
+#     # slices = [x[0, i * slice_length:(i + 1) * slice_length] for i in range(n_slices)]
+#     # x = torch.stack(slices).unsqueeze(1)  # (80, 1, 32767)
+
+#     # sine wave
+#     t = torch.arange(0, 2.0479, 1 / 16000)  # 2.05 seconds at 16kHz
+#     x = torch.sin(2 * torch.pi * 440 * t) * 0.5
+#     x = x.reshape(1, 1, 32767).tile(80, 1, 1)
+
+#     # Resample
+#     pos = 0
+#     ps = PitchShiftLayer(
+#         pshift_range=[-3, 4],
+#         expected_input_length=32767,
+#         fs=16000,
+#         min_gcd=16,
+#         max_timing_error=0.002,
+#         # filter_width=64,
+#         filter='kaiser_fast',
+#         n_fft=2048)
+#     y = []
+#     for i in range(-3, 4):
+#         y.append(ps(x[[pos], :, :], i, resample=False, fix_shape=False)[0, 0, :])
+#     y = torch.cat(y).unsqueeze(0)  # (1, 32767 * 7)
+#     torchaudio.save("y_2048_kaiser_fast.wav", y, 16000, bits_per_sample=16)
+
+#     # TorchAudio PitchShifter fopr comparision
+#     y_ta = []
+#     for i in range(-3, 4):
+#         ta_transform = torchaudio.transforms.PitchShift(16000, n_steps=i)
+#         y_ta.append(ta_transform(x[[pos], :, :])[0, 0, :])
+#     y_ta = torch.cat(y_ta).unsqueeze(0)  # (1, 32767 * 7)
+#     torchaudio.save("y_ta.wav", y_ta, 16000, bits_per_sample=16)
+
+# def test_min_gcd_mem_usage():
+#     min_gcd = 16
+#     for i in range(-3, 4):
+#         stretched_frames = _stretch_waveform(x, i).shape[1]
+#         adjusted = adjust_b_to_gcd(stretched_frames, 32767, min_gcd)
+#         gcd_val = math.gcd(adjusted, stretched_frames)
+#         gap = adjusted - 32767
+#         gap_ms = (gap / 16000) * 1000
+#         mem_mb = (stretched_frames / gcd_val) * (adjusted / gcd_val) * 3 * 4 / 1000 / 1000
+#         print(f'\033[92mmin_gcd={min_gcd}\033[0m', f'ps={i}', f'frames={stretched_frames}',
+#               f'adjusted_frames={adjusted}', f'gap={gap}', f'\033[91mgap_ms={gap_ms}\033[0m',
+#               f'gcd={gcd_val}', f'mem_MB={mem_mb}')

model/positional_encoding.py

@@ -0,0 +1,288 @@
+"""positional_encoding.py """
+from typing import Optional, Literal
+from inspect import isfunction
+from math import log, log2, pi, floor
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import nn, einsum
+from einops import rearrange, repeat
+
+from model.RoPE.RoPE import RotaryEmbedding
+
+
+class AlibiPositionalBias(nn.Module):
+    """ 
+    Alibi Positional Bias for Transformer Attention
+    : modified to support trainalbe slope similar to "little bird" paper, based on 
+        https://github.com/lucidrains/x-transformers/ 
+        https://github.com/ofirpress/attention_with_linear_biases/issues/5
+
+    This is Alibi positional bias extension for:
+        - bi-directional self/cross attention
+        - supporting extrapolation.
+
+    References:
+        Ofir, Noah A. Smith, and Mike Lewis. "Train short, test long: Attention with linear
+          biases enables input length extrapolation." arXiv preprint arXiv:2108.12409 (2021).
+
+        Lee, Minchul, Kijong Han, and Myeong Cheol Shin. "LittleBird: Efficient Faster & Longer
+          Transformer for Question Answering." arXiv preprint arXiv:2210.11870 (2022).
+    """
+
+    def __init__(self,
+                 heads: int = 8,
+                 total_heads: int = 8,
+                 trainable_slope: bool = False,
+                 trainable_slope_init: Literal['random', 'log'] = 'random',
+                 **kwargs) -> None:
+        super().__init__()
+        self.heads = heads  # number of heads to be activated
+        self.total_heads = total_heads  # number of heads in attention module
+        self.trainable_slope = trainable_slope
+        self.trainable_slope_init = trainable_slope_init
+
+        if trainable_slope:
+            self.slopes = nn.Parameter(torch.Tensor(heads, 1, 1), requires_grad=True)
+        else:
+            slopes = torch.Tensor(self._get_slopes(heads))
+            slopes = rearrange(slopes, 'h -> h 1 1')
+            self.register_buffer('slopes', slopes, persistent=False)
+
+        self.register_buffer('bias', None, persistent=False)
+
+    def reset_parameters(self) -> None:
+        if self.trainable_slope:
+            if self.trainable_slope_init == 'random':
+                nn.init.normal_(self.slopes, -2, 1)
+            else:
+                raise NotImplementedError(f'Unknown trainable_slope_init: {self.trainable_slope_init}')
+
+    def get_bias(self, i, j, device):
+        i_arange = torch.arange(j - i, j, device=device)
+        j_arange = torch.arange(j, device=device)
+        bias = -torch.abs(rearrange(j_arange, 'j -> 1 1 j') - rearrange(i_arange, 'i -> 1 i 1'))
+        return bias
+
+    @staticmethod
+    def _get_slopes(heads):
+
+        def get_slopes_power_of_2(n):
+            start = (2**(-2**-(log2(n) - 3)))
+            ratio = start
+            return [start * ratio**i for i in range(n)]
+
+        if log2(heads).is_integer():
+            return get_slopes_power_of_2(heads)
+
+        closest_power_of_2 = 2**floor(log2(heads))
+        return get_slopes_power_of_2(closest_power_of_2) + get_slopes_power_of_2(
+            2 * closest_power_of_2)[0::2][:heads - closest_power_of_2]
+
+    @staticmethod
+    def pad_at_dim(t, pad, dim=-1, value=0.):
+        dims_from_right = (-dim - 1) if dim < 0 else (t.ndim - dim - 1)
+        zeros = ((0, 0) * dims_from_right)
+        return F.pad(t, (*zeros, *pad), value=value)
+
+    @property
+    def device(self):
+        if self.trainable_slope:
+            return self.slopes.device
+        else:
+            return next(self.buffers()).device
+
+    def forward(self, i, j):
+        """
+        Args:
+            i (int): end index of query
+            j (int): end index of key 
+
+        Returns:
+            torch.Tensor: (num_total_heads, i, j) positional bias for each head
+
+        Usage:
+            >>> alibi_bias = AlibiPositionalBias(heads=8, total_heads=8, trainable_slope=False)
+            >>> pos_bias = alibi_bias(len(q), len(k))
+            >>> q_dot_k = ...
+            >>> q_dot_k += pos_bias
+            >>> q_dot_k = q_dot_k.softmax(dim=-1)
+
+        """
+        h, device = self.total_heads, self.device
+        if self.trainable_slope:
+            if self.bias is not None and self.bias.shape[-1] >= j and self.bias.shape[-2] >= i:
+                bias = self.bias[..., :i, :j]
+            else:
+                bias = self.get_bias(i, j, device)
+                num_heads_unalibied = h - bias.shape[0]
+                bias = self.pad_at_dim(bias, (0, num_heads_unalibied), dim=0)
+                self.register_buffer('bias', bias, persistent=False)
+
+            return self.bias * torch.sigmoid(self.slopes)
+
+        else:
+            if self.bias is not None and self.bias.shape[-1] >= j and self.bias.shape[-2] >= i:
+                return self.bias[..., :i, :j]
+
+            bias = self.get_bias(i, j, device)
+            bias = bias * self.slopes
+
+            num_heads_unalibied = h - bias.shape[0]
+            bias = self.pad_at_dim(bias, (0, num_heads_unalibied), dim=0)
+            self.register_buffer('bias', bias, persistent=False)
+
+            return self.bias
+
+
+class FixedSinusoidalPositionalEmbedding(nn.Embedding):
+    """
+    Sinusoidal Absolute Positional Embeddings (APE) of any length.
+    
+    Adapted from transformers.models.marian.modeling_marian.MarianSinusoidalPositionalEmbedding
+    
+    """
+
+    def __init__(self, num_positions: int, embedding_dim: int, padding_idx: Optional[int] = None):
+        super().__init__(num_positions, embedding_dim)
+        self.weight = self._init_weight(self.weight)
+
+    @staticmethod
+    def _init_weight(out: nn.Parameter):
+        """
+        Identical to the XLM create_sinusoidal_embeddings except features are not interleaved. The cos features are in
+        the 2nd half of the vector. [dim // 2:]
+        """
+        n_pos, dim = out.shape
+        position_enc = np.array([[pos / np.power(10000, 2 * (j // 2) / dim) for j in range(dim)] for pos in range(n_pos)
+                                ])
+        out.requires_grad = False  # set early to avoid an error in pytorch-1.8+
+        sentinel = dim // 2 if dim % 2 == 0 else (dim // 2) + 1
+        out[:, 0:sentinel] = torch.FloatTensor(np.sin(position_enc[:, 0::2]))
+        out[:, sentinel:] = torch.FloatTensor(np.cos(position_enc[:, 1::2]))
+        out.detach_()
+        return out
+
+    @torch.no_grad()
+    def forward(self, seq_len: int, past_key_values_length: int = 0):
+        """`input_ids_shape` is expected to be [bsz x seqlen]."""
+        positions = torch.arange(past_key_values_length,
+                                 past_key_values_length + seq_len,
+                                 dtype=torch.long,
+                                 device=self.weight.device)
+        return super().forward(positions)
+
+
+class Wav2Vec2ConformerRotaryPositionalEmbedding(nn.Module):
+    """Rotary positional embedding
+    Reference : https://blog.eleuther.ai/rotary-embeddings/ Paper: https://arxiv.org/pdf/2104.09864.pdf
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        dim = config.d_model // config.num_heads
+        base = config.rotary_embedding_base
+
+        inv_freq = 1.0 / (base**(torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer("inv_freq", inv_freq)
+        self.cached_sequence_length = None
+        self.cached_rotary_positional_embedding = None
+
+    def forward(self, hidden_states):
+        sequence_length = hidden_states.shape[1]
+
+        if sequence_length == self.cached_sequence_length and self.cached_rotary_positional_embedding is not None:
+            return self.cached_rotary_positional_embedding
+
+        self.cached_sequence_length = sequence_length
+        time_stamps = torch.arange(sequence_length).type_as(self.inv_freq)
+        freqs = torch.einsum("i,j->ij", time_stamps, self.inv_freq)
+        embeddings = torch.cat((freqs, freqs), dim=-1)
+
+        cos_embeddings = embeddings.cos()[:, None, None, :]
+        sin_embeddings = embeddings.sin()[:, None, None, :]
+        self.cached_rotary_positional_embedding = torch.stack([cos_embeddings, sin_embeddings])
+        return self.cached_rotary_positional_embedding
+
+
+class Wav2Vec2ConformerRelPositionalEmbedding(nn.Module):
+    """Relative positional encoding module."""
+
+    def __init__(self, config):
+        super().__init__()
+        self.max_len = config.num_max_positions
+        self.d_model = config.d_model
+        self.pe = None
+        self.extend_pe(torch.tensor(0.0).expand(1, self.max_len))
+
+    def extend_pe(self, x):
+        # Reset the positional encodings
+        if self.pe is not None:
+            # self.pe contains both positive and negative parts
+            # the length of self.pe is 2 * input_len - 1
+            if self.pe.size(1) >= x.size(1) * 2 - 1:
+                if self.pe.dtype != x.dtype or self.pe.device != x.device:
+                    self.pe = self.pe.to(dtype=x.dtype, device=x.device)
+                return
+        # Suppose `i` is the position of query vector and `j` is the
+        # position of key vector. We use positive relative positions when keys
+        # are to the left (i>j) and negative relative positions otherwise (i<j).
+        pe_positive = torch.zeros(x.size(1), self.d_model)
+        pe_negative = torch.zeros(x.size(1), self.d_model)
+        position = torch.arange(0, x.size(1), dtype=torch.float32).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, self.d_model, 2, dtype=torch.float32) * -(log(10000.0) / self.d_model))
+        pe_positive[:, 0::2] = torch.sin(position * div_term)
+        pe_positive[:, 1::2] = torch.cos(position * div_term)
+        pe_negative[:, 0::2] = torch.sin(-1 * position * div_term)
+        pe_negative[:, 1::2] = torch.cos(-1 * position * div_term)
+
+        # Reverse the order of positive indices and concat both positive and
+        # negative indices. This is used to support the shifting trick
+        # as in https://arxiv.org/abs/1901.02860
+        pe_positive = torch.flip(pe_positive, [0]).unsqueeze(0)
+        pe_negative = pe_negative[1:].unsqueeze(0)
+        pe = torch.cat([pe_positive, pe_negative], dim=1)
+        self.pe = pe.to(device=x.device, dtype=x.dtype)
+
+    def forward(self, hidden_states: torch.Tensor):
+        self.extend_pe(hidden_states)
+        start_idx = self.pe.size(1) // 2 - hidden_states.size(1) + 1
+        end_idx = self.pe.size(1) // 2 + hidden_states.size(1)
+        relative_position_embeddings = self.pe[:, start_idx:end_idx]
+
+        return relative_position_embeddings
+
+
+#================================================================================================
+# Rotary Positional Embedding
+#================================================================================================
+def get_rotary_emb(d_by_head: int,
+                   freqs_for: Literal["l", "lang", "p", "pixel"],
+                   partial_pe: bool = False,
+                   learned_freq: bool = False):
+    if partial_pe is True:
+        rdim = d_by_head // 2
+    else:
+        rdim = d_by_head
+
+    if freqs_for in ["l", "lang"]:
+        freqs_for = "lang"
+    elif freqs_for in ["p", "pixel"]:
+        freqs_for = "pixel"
+    else:
+        raise ValueError(f"freqs_for must be 'l' or 'lang' or 'p' or 'pixel', but got {freqs_for}")
+    return RotaryEmbedding(dim=rdim, freqs_for=freqs_for, learned_freq=learned_freq)
+
+
+def test_rotary_embedding_lang():
+    d = 128
+    num_heads = 8
+    d_by_head = d // num_heads
+
+    rotary = get_rotary_emb(d_by_head, freqs_for="lang", partial_pe=False, learned_freq=False)
+    q = torch.ones(1, 8, 110, d_by_head)
+    q = rotary.apply_rotary_custom(q)
+
+    import matplotlib.pyplot as plt
+    plt.imshow(q[0, 0, :, :].detach().numpy().T, origin='lower')

model/spectrogram.py

@@ -0,0 +1,225 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+"""spectrogram.py"""
+import importlib
+from typing import Optional, Literal, Dict, Tuple
+from packaging.version import parse as VersionParse
+
+import torch
+import torch.nn as nn
+from einops import rearrange
+from model.ops import minmax_normalize
+from config.config import audio_cfg as default_audio_cfg
+"""
+Example usage:
+
+# MT3 setup
+>>> hop = 8 ms or 128 samples 
+>>> melspec = Melspectrogram(sample_rate=16000, n_fft=2048, hop_length=128,
+                            f_min=50, f_max=8000, n_mels=512)
+>>> x = torch.randn(2, 1, 32767) # (B, C=1, T): 2.048 s
+>>> y = melspec(x) # (2, 256, 512) (B, T, F)
+
+# PerceiverTF-like setup
+>>> hop = 18.75 ms or 300 samples
+>>> spec = Spectrogram(n_fft=2048, hop_length=300)
+                            )
+>>> x = torch.randn(2, 1, 95999) # (B, C=1, T): 6.000 s
+>>> y = spec(x) # (2, 320, 1024) (B, T, F)
+
+# Hybrid setup (2.048 seconds segment and spectrogram with hop=300)
+>>> hop = 18.75 ms or 300 samples
+>>> spec = Spectrogram(n_fft=2048, hop_length=300)
+>>> x = torch.randn(2, 1, 32767) # (B, C=1, T): 2.048 s
+>>> y = spec(x) # (2, 110, 1024) (B, T, F)
+
+# PerceiverTF-like setup, hop=256
+>>> hop = 16 ms or 256 samples
+>>> spec256 = Spectrogram(sample_rate=16000, n_fft=2048, hop_length=256,
+                                f_min=20, f_max=8000, n_mels=256)
+>>> x = torch.randn(2, 1, 32767) # (B, C=1, T): 2.048 s
+>>> y = spec256(x) # (2, 128, 1024) (B, T, F)
+"""
+
+
+def optional_compiler_disable(func):
+    if VersionParse(torch.__version__) >= VersionParse("2.1"):
+        # If the version is 2.1 or higher, apply the torch.compiler.disable decorator.
+        return torch.compiler.disable(func)
+    else:
+        # If the version is below 2.1, return the original function.
+        return func
+
+
+# -------------------------------------------------------------------------------------
+# Log-Mel spectrogram
+# -------------------------------------------------------------------------------------
+class Melspectrogram(nn.Module):
+
+    def __init__(
+        self,
+        audio_backend: Literal['torchaudio', 'nnaudio'] = 'torchaudio',
+        sample_rate: int = 16000,
+        n_fft: int = 2048,
+        hop_length: int = 128,
+        f_min: int = 50,  # 20 Hz in the MT3 paper, but we can only use 20 Hz with nnAudio
+        f_max: Optional[int] = 8000,
+        n_mels: int = 512,
+        eps: float = 1e-5,
+        **kwargs,
+    ):
+        """
+        Log-Melspectrogram
+
+        Args:
+            audio_backend (str): 'torchaudio' or 'nnaudio'
+            sample_rate (int): sample rate in Hz
+            n_fft (int): FFT window size
+            hop_length (int): hop length in samples
+            f_min (int): minimum frequency in Hz
+            f_max (int): maximum frequency in Hz
+            n_mels (int): number of mel frequency bins
+            eps (float): epsilon for numerical stability
+
+        """
+        super(Melspectrogram, self).__init__()
+        self.audio_backend = audio_backend.lower()
+
+        if audio_backend.lower() == 'torchaudio':
+            torchaudio = importlib.import_module('torchaudio')
+            self.mel_stft = torchaudio.transforms.MelSpectrogram(
+                sample_rate=sample_rate,
+                n_fft=n_fft,
+                hop_length=hop_length,
+                f_min=f_min,
+                f_max=f_max,
+                n_mels=n_mels,
+            )
+        elif audio_backend.lower() == 'nnaudio':
+            nnaudio = importlib.import_module('nnAudio.features')
+            self.mel_stft_nnaudio = nnaudio.mel.MelSpectrogram(
+                sr=sample_rate,
+                win_length=n_fft,
+                n_mels=n_mels,
+                hop_length=hop_length,
+                fmin=20,  #f_min,
+                fmax=f_max)
+        else:
+            raise NotImplementedError(audio_backend)
+        self.eps = eps
+
+    @optional_compiler_disable
+    def forward(self, x: torch.Tensor) -> torch.Tensor:  # (B, 1, T)
+        """
+        Args:
+            x (torch.Tensor): (B, 1, T)
+            
+        Returns:
+            torch.Tensor: (B, T, F)
+        
+        """
+        if self.audio_backend == 'torchaudio':
+            x = self.mel_stft(x)  # (B, 1, F, T)
+            x = rearrange(x, 'b 1 f t -> b t f')
+            x = minmax_normalize(torch.log(x + self.eps))
+            # some versions of torchaudio returns nan when input is all-zeros
+            return torch.nan_to_num(x)
+
+        elif self.audio_backend == 'nnaudio':
+            x = self.mel_stft_nnaudio(x)  # (B, F, T)
+            x = rearrange(x, 'b f t -> b t f')
+            x = minmax_normalize(torch.log(x + self.eps))
+            return x
+
+
+# -------------------------------------------------------------------------------------
+# Log-spectrogram
+# -------------------------------------------------------------------------------------
+class Spectrogram(nn.Module):
+
+    def __init__(
+        self,
+        audio_backend: Literal['torchaudio', 'nnaudio'] = 'torchaudio',
+        n_fft: int = 2048,
+        hop_length: int = 128,
+        eps: float = 1e-5,
+        **kwargs,
+    ):
+        """
+        Log-Magnitude Spectrogram 
+
+        Args:
+            audio_backend (str): 'torchaudio' or 'nnaudio'
+            n_fft (int): FFT window size, creates n_fft // 2 + 1 freq-bins
+            hop_length (int): hop length in samples
+            eps (float): epsilon for numerical stability
+
+        """
+        super(Spectrogram, self).__init__()
+        self.audio_backend = audio_backend.lower()
+
+        if audio_backend.lower() == 'torchaudio':
+            torchaudio = importlib.import_module('torchaudio')
+            self.stft = torchaudio.transforms.Spectrogram(n_fft=n_fft,
+                                                          hop_length=hop_length,
+                                                          window_fn=torch.hann_window,
+                                                          power=1.)  # (B, 1, F, T), remove DC component
+        elif audio_backend.lower() == 'nnaudio':
+            # TODO: nnAudio spectrogram
+            raise NotImplementedError(audio_backend)
+        else:
+            raise NotImplementedError(audio_backend)
+        self.eps = eps
+
+    @optional_compiler_disable
+    def forward(self, x: torch.Tensor) -> torch.Tensor:  # (B, 1, T)
+        """
+        Args:
+            x (torch.Tensor): (B, 1, T)
+            
+        Returns:
+            torch.Tensor: (B, T, F)
+        
+        """
+        if self.audio_backend == 'torchaudio':
+            x = self.stft(x)[:, :, 1:, :]  # (B, 1, F, T) remove DC component
+            x = rearrange(x, 'b 1 f t -> b t f')
+            x = minmax_normalize(torch.log(x + self.eps))
+            return torch.nan_to_num(x)  # some versions of torchaudio returns nan when input is all-zeros
+        elif self.audio_backend == 'nnaudio':
+            raise NotImplementedError(self.audio_backend)
+
+
+def get_spectrogram_layer_from_audio_cfg(audio_cfg: Optional[Dict] = None) -> Tuple[nn.Module, Tuple[int]]:
+    """Get mel-/spectrogram layer from config.
+    - Used by 'ymt3' to create a spectrogram layer.
+    - Returns output shape of spectrogram layer, which is used to determine input shape of model.
+    
+    Args:
+        audio_cfg (dict): see config/config.py
+
+    Returns:
+        layer (nn.Module): mel-/spectrogram layer
+        output_shape (tuple): inferred output shape of layer excluding batch dim. (T, F)
+    """
+    if audio_cfg is None:
+        audio_cfg = default_audio_cfg
+
+    if audio_cfg['codec'] == 'melspec':
+        layer = Melspectrogram(**audio_cfg)
+    elif audio_cfg['codec'] == 'spec':
+        layer = Spectrogram(**audio_cfg)
+    else:
+        raise NotImplementedError(audio_cfg['codec'])
+
+    # Infer output shape of the spectrogram layer
+    with torch.no_grad():
+        output_shape = layer(torch.randn(1, 1, audio_cfg['input_frames'])).shape[1:]
+    return layer, output_shape

model/t5mod.py

@@ -0,0 +1,687 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+# ==============================================================================
+# Copyright 2018 Mesh TensorFlow authors, T5 Authors and HuggingFace Inc. team.
+#
+# 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.
+import copy
+from typing import Optional, Tuple, Union, Dict
+from einops import rearrange
+from model.ops import count_parameters
+
+import torch
+from torch import nn
+from torch.utils.checkpoint import checkpoint
+from transformers.utils import logging
+from transformers.utils.model_parallel_utils import assert_device_map, get_device_map
+from transformers.models.t5.modeling_t5 import (T5LayerNorm, T5LayerSelfAttention, T5LayerCrossAttention, T5LayerFF)
+from transformers.modeling_outputs import (BaseModelOutput, BaseModelOutputWithPastAndCrossAttentions)
+from transformers import T5Config, T5PreTrainedModel
+from model.positional_encoding import FixedSinusoidalPositionalEmbedding
+from model.ff_layer import get_ff_layer
+
+logger = logging.get_logger(__name__)
+
+
+class T5BlockYMT3(nn.Module):
+    """T5 Block, modified to allow using different types of FF layers."""
+
+    def __init__(self, config, has_relative_attention_bias=False):
+        super().__init__()
+        self.is_decoder = config.is_decoder
+        self.layer = nn.ModuleList()
+        self.layer.append(T5LayerSelfAttention(config, has_relative_attention_bias=has_relative_attention_bias))
+        if self.is_decoder:
+            self.layer.append(T5LayerCrossAttention(config))
+
+        # FF layer
+        if config.ff_layer_type == 't5_gmlp':
+            self.layer.append(T5LayerFF(config))
+        elif config.ff_layer_type == 'moe':
+            config.moe_num_experts = 8
+            config.moe_topk = 2
+            config.hidden_act = 'silu'
+            moe = get_ff_layer(config, input_size=config.d_model, widening_factor=config.ff_widening_factor)
+            self.layer.append(moe)
+        else:
+            raise ValueError(f"Unknown FF layer type: {config.ff_layer_type}.")
+        self.ff_layer_type = config.ff_layer_type
+
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        position_bias=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        encoder_decoder_position_bias=None,
+        layer_head_mask=None,
+        cross_attn_layer_head_mask=None,
+        past_key_value=None,
+        use_cache=False,
+        output_attentions=False,
+        return_dict=True,
+    ):
+        if past_key_value is not None:
+            if not self.is_decoder:
+                logger.warning("`past_key_values` is passed to the encoder. Please make sure this is intended.")
+            expected_num_past_key_values = 2 if encoder_hidden_states is None else 4
+
+            if len(past_key_value) != expected_num_past_key_values:
+                raise ValueError(
+                    f"There should be {expected_num_past_key_values} past states. "
+                    f"{'2 (past / key) for cross attention. ' if expected_num_past_key_values == 4 else ''}"
+                    f"Got {len(past_key_value)} past key / value states")
+
+            self_attn_past_key_value = past_key_value[:2]
+            cross_attn_past_key_value = past_key_value[2:]
+        else:
+            self_attn_past_key_value, cross_attn_past_key_value = None, None
+
+        self_attention_outputs = self.layer[0](
+            hidden_states,
+            attention_mask=attention_mask,
+            position_bias=position_bias,
+            layer_head_mask=layer_head_mask,
+            past_key_value=self_attn_past_key_value,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+        )
+        hidden_states, present_key_value_state = self_attention_outputs[:2]
+        attention_outputs = self_attention_outputs[2:]  # Keep self-attention outputs and relative position weights
+
+        # clamp inf values to enable fp16 training
+        if hidden_states.dtype == torch.float16:
+            clamp_value = torch.where(
+                torch.isinf(hidden_states).any(),
+                torch.finfo(hidden_states.dtype).max - 1000,
+                torch.finfo(hidden_states.dtype).max,
+            )
+            hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+        do_cross_attention = self.is_decoder and encoder_hidden_states is not None
+        if do_cross_attention:
+            # the actual query length is unknown for cross attention
+            # if using past key value states. Need to inject it here
+            if present_key_value_state is not None:
+                query_length = present_key_value_state[0].shape[2]
+            else:
+                query_length = None
+
+            cross_attention_outputs = self.layer[1](
+                hidden_states,
+                key_value_states=encoder_hidden_states,
+                attention_mask=encoder_attention_mask,
+                position_bias=encoder_decoder_position_bias,
+                layer_head_mask=cross_attn_layer_head_mask,
+                past_key_value=cross_attn_past_key_value,
+                query_length=query_length,
+                use_cache=use_cache,
+                output_attentions=output_attentions,
+            )
+            hidden_states = cross_attention_outputs[0]
+
+            # clamp inf values to enable fp16 training
+            if hidden_states.dtype == torch.float16:
+                clamp_value = torch.where(
+                    torch.isinf(hidden_states).any(),
+                    torch.finfo(hidden_states.dtype).max - 1000,
+                    torch.finfo(hidden_states.dtype).max,
+                )
+                hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+            # Combine self attn and cross attn key value states
+            if present_key_value_state is not None:
+                present_key_value_state = present_key_value_state + cross_attention_outputs[1]
+
+            # Keep cross-attention outputs and relative position weights
+            attention_outputs = attention_outputs + cross_attention_outputs[2:]
+
+        # Apply Feed Forward layer - Modified for MoE
+        if self.ff_layer_type == 't5_gmlp':
+            hidden_states = self.layer[-1](hidden_states)
+        elif self.ff_layer_type == 'moe':
+            hidden_states = hidden_states + self.layer[-1](hidden_states)[0]  # residual connection outside the MoE
+        else:
+            raise ValueError(f"Unknown FF layer type: {self.ff_layer_type}.")
+
+        # clamp inf values to enable fp16 training
+        if hidden_states.dtype == torch.float16:
+            clamp_value = torch.where(
+                torch.isinf(hidden_states).any(),
+                torch.finfo(hidden_states.dtype).max - 1000,
+                torch.finfo(hidden_states.dtype).max,
+            )
+            hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+        outputs = (hidden_states,)
+
+        if use_cache:
+            outputs = outputs + (present_key_value_state,) + attention_outputs
+        else:
+            outputs = outputs + attention_outputs
+
+        return outputs  # hidden-states, present_key_value_states, (self-attention position bias), (self-attention weights), (cross-attention position bias), (cross-attention weights)
+
+
+class T5StackYMT3(T5PreTrainedModel):
+    """
+    T5Stack, modified for YMT3 with:
+    - absolute sinusoidal absolute positional encoding
+    """
+
+    def __init__(
+        self,
+        config,
+    ):
+        super().__init__(config)
+        self.is_decoder = config.is_decoder
+
+        # Positional encoding (modified)
+        self.use_t5_trainable_pe = False
+        self.additive_pe = None
+
+        pos_enc_type = getattr(config, 'position_encoding_type', 'sinusoidal')
+        if pos_enc_type in ['sinusoidal']:
+            self.additive_pe = FixedSinusoidalPositionalEmbedding(config.num_max_positions,
+                                                                  embedding_dim=config.d_model)
+            self.block = nn.ModuleList(
+                [T5BlockYMT3(config, has_relative_attention_bias=False) for i in range(config.num_layers)])
+        elif pos_enc_type == 'trainable':
+            self.use_t5_trainable_pe = True
+            # Stack blocks
+            self.block = nn.ModuleList(
+                [T5BlockYMT3(config, has_relative_attention_bias=bool(i == 0)) for i in range(config.num_layers)])
+
+        self.final_layer_norm = T5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
+        self.dropout = nn.Dropout(config.dropout_rate)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+        # Model parallel
+        self.gradient_checkpointing = False
+
+    def forward(
+        self,
+        # input_ids=None,
+        inputs_embeds=None,
+        attention_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        head_mask=None,
+        cross_attn_head_mask=None,
+        past_key_values=None,
+        use_cache=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+    ):
+        use_cache = use_cache if use_cache is not None else self.config.use_cache
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (output_hidden_states
+                                if output_hidden_states is not None else self.config.output_hidden_states)
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if inputs_embeds is not None:
+            input_shape = inputs_embeds.size()[:-1]
+        else:
+            err_msg_prefix = "decoder_" if self.is_decoder else ""
+            raise ValueError(f"You have to specify {err_msg_prefix}inputs_embeds")
+
+        batch_size, seq_length = input_shape
+
+        # required mask seq length can be calculated via length of past
+        mask_seq_length = past_key_values[0][0].shape[2] + seq_length if past_key_values is not None else seq_length
+
+        # mod: required for additive PE
+        past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
+
+        if use_cache is True:
+            assert self.is_decoder, f"`use_cache` can only be set to `True` if {self} is used as a decoder"
+
+        if attention_mask is None:
+            attention_mask = torch.ones(batch_size, mask_seq_length, device=inputs_embeds.device)
+        if self.is_decoder and encoder_attention_mask is None and encoder_hidden_states is not None:
+            encoder_seq_length = encoder_hidden_states.shape[1]
+            encoder_attention_mask = torch.ones(batch_size,
+                                                encoder_seq_length,
+                                                device=inputs_embeds.device,
+                                                dtype=torch.long)
+
+        # initialize past_key_values with `None` if past does not exist
+        if past_key_values is None:
+            past_key_values = [None] * len(self.block)
+
+        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
+        # ourselves in which case we just need to make it broadcastable to all heads.
+        extended_attention_mask = self.get_extended_attention_mask(attention_mask, input_shape)
+
+        # If a 2D or 3D attention mask is provided for the cross-attention
+        # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
+        if self.is_decoder and encoder_hidden_states is not None:
+            encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
+            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
+            if encoder_attention_mask is None:
+                encoder_attention_mask = torch.ones(encoder_hidden_shape, device=inputs_embeds.device)
+            encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
+        else:
+            encoder_extended_attention_mask = None
+
+        if self.gradient_checkpointing and self.training:
+            if use_cache:
+                logger.warning_once(
+                    "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`...")
+                use_cache = False
+
+        # Prepare head mask if needed
+        head_mask = self.get_head_mask(head_mask, self.config.num_layers)
+        cross_attn_head_mask = self.get_head_mask(cross_attn_head_mask, self.config.num_layers)
+        present_key_value_states = () if use_cache else None
+        all_hidden_states = () if output_hidden_states else None
+        all_attentions = () if output_attentions else None
+        all_cross_attentions = () if (output_attentions and self.is_decoder) else None
+        position_bias = None
+        encoder_decoder_position_bias = None
+
+        # mod: additive absolute PE (sinusoidal)
+        if self.additive_pe is not None:
+            inputs_embeds = inputs_embeds + self.additive_pe(inputs_embeds.shape[1], past_key_values_length)
+        else:
+            pass  # trinable PE is implemented in T5Block
+
+        hidden_states = self.dropout(inputs_embeds)
+
+        for i, (layer_module, past_key_value) in enumerate(zip(self.block, past_key_values)):
+            layer_head_mask = head_mask[i]
+            cross_attn_layer_head_mask = cross_attn_head_mask[i]
+
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            if self.gradient_checkpointing and self.training:
+
+                def create_custom_forward(module):
+
+                    def custom_forward(*inputs):
+                        return tuple(module(*inputs, use_cache, output_attentions))
+
+                    return custom_forward
+
+                layer_outputs = checkpoint(
+                    create_custom_forward(layer_module),
+                    hidden_states,
+                    extended_attention_mask,
+                    position_bias,
+                    encoder_hidden_states,
+                    encoder_extended_attention_mask,
+                    encoder_decoder_position_bias,
+                    layer_head_mask,
+                    cross_attn_layer_head_mask,
+                    None,  # past_key_value is always None with gradient checkpointing
+                )
+            else:
+                layer_outputs = layer_module(
+                    hidden_states,
+                    attention_mask=extended_attention_mask,
+                    position_bias=position_bias,
+                    encoder_hidden_states=encoder_hidden_states,
+                    encoder_attention_mask=encoder_extended_attention_mask,
+                    encoder_decoder_position_bias=encoder_decoder_position_bias,
+                    layer_head_mask=layer_head_mask,
+                    cross_attn_layer_head_mask=cross_attn_layer_head_mask,
+                    past_key_value=past_key_value,
+                    use_cache=use_cache,
+                    output_attentions=output_attentions,
+                )
+
+            # layer_outputs is a tuple with:
+            # hidden-states, key-value-states, (self-attention position bias), (self-attention weights), (cross-attention position bias), (cross-attention weights)
+            if use_cache is False:
+                layer_outputs = layer_outputs[:1] + (None,) + layer_outputs[1:]
+
+            hidden_states, present_key_value_state = layer_outputs[:2]
+
+            # We share the position biases between the layers - the first layer store them
+            # layer_outputs = hidden-states, key-value-states (self-attention position bias), (self-attention weights),
+            # (cross-attention position bias), (cross-attention weights)
+            position_bias = layer_outputs[2]
+            if self.is_decoder and encoder_hidden_states is not None:
+                encoder_decoder_position_bias = layer_outputs[4 if output_attentions else 3]
+            # append next layer key value states
+            if use_cache:
+                present_key_value_states = present_key_value_states + (present_key_value_state,)
+
+            if output_attentions:
+                all_attentions = all_attentions + (layer_outputs[3],)
+                if self.is_decoder:
+                    all_cross_attentions = all_cross_attentions + (layer_outputs[5],)
+
+        hidden_states = self.final_layer_norm(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+
+        # Add last layer
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(v for v in [
+                hidden_states,
+                present_key_value_states,
+                all_hidden_states,
+                all_attentions,
+                all_cross_attentions,
+            ] if v is not None)
+        return BaseModelOutputWithPastAndCrossAttentions(
+            last_hidden_state=hidden_states,
+            past_key_values=present_key_value_states,
+            hidden_states=all_hidden_states,
+            attentions=all_attentions,
+            cross_attentions=all_cross_attentions,
+        )
+
+
+class T5EncoderYMT3(T5PreTrainedModel):
+    # _keys_to_ignore_on_load_missing = [r"encoder.embed_tokens.weight"]
+
+    def __init__(self, encoder_config: Optional[Dict] = None, config: Optional[T5Config] = None):
+        if config is None:
+            config = T5Config()
+        if encoder_config is not None:
+            config = copy.deepcopy(config)
+            config.update(encoder_config)
+
+        if hasattr(config, "ff_widening_factor"):
+            config.d_ff = int(config.d_model) * int(config.ff_widening_factor)
+
+        config.is_decoder = False
+        config.use_cache = False
+        config.is_encoder_decoder = False
+
+        super().__init__(config)
+        self.model_dim = config.d_model
+
+        self.encoder = T5StackYMT3(config)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    """temporary fix for torch.compile issue"""
+
+    def forward(self, **kwargs):
+        if self.training is True:
+            return self._forward_compile(**kwargs)
+        else:
+            return self._forward_no_compile(**kwargs)
+
+    def _forward_no_compile(self, **kwargs):
+        return self._forward(**kwargs)
+
+    @torch.compile
+    def _forward_compile(self, **kwargs):
+        return self._forward(**kwargs)
+
+    def _forward(
+        self,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple[torch.FloatTensor], BaseModelOutput]:
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        # Encode
+        encoder_outputs = self.encoder(
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            head_mask=head_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        if not return_dict:
+            return encoder_outputs
+        else:
+            return BaseModelOutput(
+                last_hidden_state=encoder_outputs[0],
+                hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+                attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+            )
+
+
+class T5DecoderYMT3(T5PreTrainedModel):
+
+    def __init__(self, decoder_config: Optional[Dict] = None, config: Optional[T5Config] = None):
+        if config is None:
+            config = T5Config()
+        if decoder_config is not None:
+            config = copy.deepcopy(config)
+            config.update(decoder_config)
+
+        if hasattr(config, "ff_widening_factor"):
+            config.d_ff = int(config.d_model) * int(config.ff_widening_factor)
+
+        config.is_decoder = True
+        config.is_encoder_decoder = False
+
+        super().__init__(config)
+        self.model_dim = config.d_model
+
+        self.decoder = T5StackYMT3(config)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    """temporary fix for torch.compile issue"""
+
+    def forward(self, **kwargs):
+        if self.training is True:
+            return self._forward_compile(**kwargs)
+        else:
+            return self._forward_no_compile(**kwargs)
+
+    def _forward_no_compile(self, **kwargs):
+        return self._forward(**kwargs)
+
+    @torch.compile
+    def _forward_compile(self, **kwargs):
+        return self._forward(**kwargs)
+
+    def _forward(
+        self,
+        # input_ids: torch.LongTensor, # removed since embed_tokens is outside the decoder
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        attention_mask: Optional[torch.FloatTensor] = None,  # decoder_attention_mask
+        encoder_attention_mask: Optional[torch.FloatTensor] = None,
+        cross_attn_head_mask: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        encoder_hidden_states: Optional[torch.FloatTensor] = None,
+        past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple[torch.FloatTensor], BaseModelOutputWithPastAndCrossAttentions]:
+        use_cache = use_cache if use_cache is not None else self.config.use_cache
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if isinstance(encoder_hidden_states, BaseModelOutput):
+            encoder_hidden_states = encoder_hidden_states.last_hidden_state
+
+        # Decode
+        decoder_outputs = self.decoder(
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            past_key_values=past_key_values,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_attention_mask,
+            head_mask=head_mask,
+            cross_attn_head_mask=cross_attn_head_mask,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        if not return_dict:
+            return decoder_outputs
+        else:
+            return BaseModelOutputWithPastAndCrossAttentions(
+                last_hidden_state=decoder_outputs[0],
+                past_key_values=decoder_outputs[1],
+                hidden_states=decoder_outputs[2] if len(decoder_outputs) > 2 else None,
+                attentions=decoder_outputs[3] if len(decoder_outputs) > 3 else None,
+                cross_attentions=decoder_outputs[4] if len(decoder_outputs) > 4 else None,
+            )
+
+
+class MultiChannelT5Decoder(T5PreTrainedModel):
+
+    def __init__(self, decoder_config: Optional[Dict] = None, config: Optional[T5Config] = None):
+        if config is None:
+            config = T5Config()
+        if decoder_config is not None:
+            config = copy.deepcopy(config)
+            config.update(decoder_config)
+
+        if hasattr(config, "ff_widening_factor"):
+            config.d_ff = int(config.d_model) * int(config.ff_widening_factor)
+
+        config.is_decoder = True
+        config.is_encoder_decoder = False
+
+        super().__init__(config)
+        self.model_dim = config.d_model
+        self.decoder = T5StackYMT3(config)
+
+        # Multi-channel parameters
+        self.num_channels = config.num_channels
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    """temporary fix for torch.compile issue"""
+
+    def forward(self, **kwargs):
+        if self.training is True:
+            return self._forward_compile(**kwargs)
+        else:
+            return self._forward_no_compile(**kwargs)
+
+    def _forward_no_compile(self, **kwargs):
+        return self._forward(**kwargs)
+
+    @torch.compile
+    def _forward_compile(self, **kwargs):
+        return self._forward(**kwargs)
+
+    def _forward(
+        self,
+        # input_ids: torch.LongTensor, # removed since embed_tokens is outside the decoder
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        attention_mask: Optional[torch.FloatTensor] = None,  # decoder_attention_mask
+        encoder_attention_mask: Optional[torch.FloatTensor] = None,
+        cross_attn_head_mask: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        encoder_hidden_states: Optional[torch.FloatTensor] = None,
+        past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple[torch.FloatTensor], BaseModelOutputWithPastAndCrossAttentions]:
+        use_cache = use_cache if use_cache is not None else self.config.use_cache
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        """
+        Args:
+            inputs_embeds: torch.FloatTensor (B, K, T, D), where K is the number of channels
+            encoder_hidden_states: torch.FloatTensor (B, K, T, D), where K is the number of channels
+        
+        Returns:
+            decoder_outputs: BaseModelOutputWithPastAndCrossAttentions
+                last_hidden_state: torch.FloatTensor (B, K, T, D), where K is the number of channels
+                past_key_values: Tuple[Tuple[torch.Tensor]]
+                hidden_states: Tuple[torch.FloatTensor]
+                attentions: Tuple[torch.FloatTensor]
+                cross_attentions: Tuple[torch.FloatTensor]
+
+        """
+        if isinstance(encoder_hidden_states, BaseModelOutput):
+            encoder_hidden_states = encoder_hidden_states.last_hidden_state
+
+        # Reshape input_embeds and encoder_hidden_states
+        b, k, t, d = inputs_embeds.size()
+        inputs_embeds = rearrange(inputs_embeds, 'b k t d -> (b k) t d')
+        encoder_hidden_states = rearrange(encoder_hidden_states, 'b k t d -> (b k) t d')
+
+        # K-channel Decoding
+        decoder_outputs = self.decoder(
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            past_key_values=past_key_values,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_attention_mask,
+            head_mask=head_mask,
+            cross_attn_head_mask=cross_attn_head_mask,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=True,
+        )
+
+        # Reshape decoder_outputs
+        decoder_outputs['last_hidden_state'] = rearrange(decoder_outputs['last_hidden_state'],
+                                                         '(b k) t d -> b k t d',
+                                                         b=b,
+                                                         k=k)
+
+        if not return_dict:
+            # Collecting values from decoder_outputs in a specific order
+            outputs = (
+                decoder_outputs['last_hidden_state'],
+                decoder_outputs.get('past_key_values', None),
+                decoder_outputs.get('hidden_states', None),
+                decoder_outputs.get('attentions', None),
+                decoder_outputs.get('cross_attentions', None),
+            )
+            return tuple(v for v in outputs if v is not None)
+        else:
+            return decoder_outputs  # ['last_hidden_state']: (B, K, T, D)
+
+
+def test_multi_channel_t5_decoder():
+    # Test multi-channel decoder
+    config = T5Config()
+    config.num_channels = 4
+    config.d_model = 32
+    config.num_layers = 2
+    config.num_heads = 2
+    config.num_max_positions = 64  # for positional encoding
+
+    decoder = MultiChannelT5Decoder(decoder_config=None, config=config)
+    decoder.eval()
+
+    input_emb = torch.rand(2, 4, 64, 32)  # (B, K, T, D)
+    enc_hs = torch.rand(2, 4, 64, 32)  # (B, K, T, D)
+    out = decoder(inputs_embeds=input_emb, encoder_hidden_states=enc_hs, return_dict=True)
+    # out['last_hidden_state']: (B, K, T, D)
+    # out['past_key_values']: Tuple[Tuple[torch.Tensor]]

model/t5mod_helper.py

@@ -0,0 +1,133 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+"""t5mod_helper.py"""
+import torch
+from torch import nn
+from model.t5mod import T5DecoderYMT3, MultiChannelT5Decoder
+from typing import Optional, Callable, Union, Literal
+
+
+@torch.no_grad()
+def task_cond_dec_generate(decoder: Union[T5DecoderYMT3, MultiChannelT5Decoder],
+                           decoder_type: Literal["t5", "multi-t5"],
+                           embed_tokens: nn.Embedding,
+                           lm_head: nn.Module,
+                           encoder_hidden_states: torch.FloatTensor,
+                           shift_right_fn: Callable,
+                           prefix_ids: Optional[torch.LongTensor] = None,
+                           max_length: int = 1024,
+                           stop_at_eos: bool = True,
+                           eos_id: Optional[int] = 1,
+                           pad_id: Optional[int] = 0,
+                           decoder_start_token_id: Optional[int] = 0,
+                           debug: bool = False) -> torch.LongTensor:
+    """
+    Generate sequence by task conditioning on the decoder side
+    :An extension of transofrmers.generate() function for the model with 
+    conditioning only on the decoder side. 
+    
+    Args:
+        decoder: T5DecoderYMT3 or MultiChannelT5Decoder, any decoder model with T5Stack architecture
+        decoder_type: Literal["t5", "multi-t5"], type of decoder
+        embed_tokens: nn.Embedding, embedding layer for the decoder
+        lm_head: nn.Module, language model head
+        encoder_hidden_states: torch.FloatTensor, (B, T, D) or (B, K, T, D) last hidden states
+        shift_right_fn: Callable, shift_right function of the decoder
+        prefix_ids: torch.LongTensor, (B, prefix_len) prefix ids typically used as task conditioning to decoder.
+        max_length: int, max token length to generate (default is 1024)
+        stop_at_eos: bool, whether to early-stop when all predictions in the batch are the <eos> token.
+        eos_id: int, the id of the <eos> token (default is 1)
+        pad_id: int, the id of the <pad> token (default is 0)
+        decoder_start_token_id: int, the id of the <bos> token (default is 0)
+        debug: bool, whether to print debug information
+
+    Returns:
+        pred_ids: torch.LongTensor, (B, task_len + N) or (B, C, task_len + N) predicted token ids
+    """
+    bsz = encoder_hidden_states.shape[0]
+    device = encoder_hidden_states.device
+
+    # Prepare dec_input_shape: (B, 1) or (B, C, 1)
+    if decoder_type == "t5":
+        dec_input_shape = (bsz, 1)
+    elif decoder_type == "multi-t5":
+        dec_input_shape = (bsz, decoder.num_channels, 1)
+    else:
+        raise ValueError(f"decoder_type {decoder_type} is not supported.")
+
+    # Prepare dec_input_ids: <bos> + task_prefix_token (B, prefix_len + 1) or (B, C, prefix_len + 1)
+    if prefix_ids is not None and prefix_ids.numel() > 0:
+        dec_input_ids = shift_right_fn(prefix_ids)
+        prefix_length = prefix_ids.shape[-1]
+    else:
+        # if prefix_ids is None, use <bos> as initial inSput
+        dec_input_ids = torch.tile(torch.LongTensor([decoder_start_token_id]).to(device), dec_input_shape)
+        prefix_length = 0
+    dec_inputs_embeds = embed_tokens(dec_input_ids)  # (B, L, D) or (B, C, L, D)
+
+    # Generate decoder hidden state and past_key_values using prefix:
+    """
+    - initial inputs_embeds can be a sequence, without using past_key_values
+    - dec_hs: (B, 1, D)
+    - past_key_values: Tuple of length M for M layers of decoder
+    - pred_ids: (B, prefix_len) where N is the length of prefix_ids 
+    """
+    dec_hs, past_key_values = decoder(inputs_embeds=dec_inputs_embeds,
+                                      encoder_hidden_states=encoder_hidden_states,
+                                      return_dict=False)
+    logits = lm_head(dec_hs)  # (b, T=1, vocab_size) or (b, C, T=1, vocab_size)
+    pred_ids = logits.argmax(-1)  # (B, prefix_len + 1) or (B, C, prefix_len + 1)
+
+    # keep track of which sequences are already finished
+    unfinished_sequences = torch.ones(dec_input_shape, dtype=torch.long, device=device)
+
+    # Fast generation with past_key_values for the rest of the sequence
+    if decoder_type == "t5":
+        dec_input_ids = pred_ids[:, -1].unsqueeze(-1)  # (B, 1)
+    elif decoder_type == "multi-t5":
+        dec_input_ids = pred_ids[:, :, -1].unsqueeze(-1)  # (B, C, 1)
+    for i in range(max_length - prefix_length - 1):  # -1 for <eos> token
+        if debug:
+            past_key_values_length = past_key_values[0][0].shape[
+                2]  # past_key_values_length determines the positional embedding
+            print(f'i = {i}, past_key_values_length = {past_key_values_length}, pred_ids.shape = {pred_ids.shape}')
+
+        # when past_key_values is provided, we use only the last token as input_ids
+        dec_inputs_embeds = embed_tokens(dec_input_ids)  # (B, 1, D) or (B, C, 1, D)
+        dec_hs, _past_key_values = decoder(inputs_embeds=dec_inputs_embeds,
+                                           encoder_hidden_states=encoder_hidden_states,
+                                           past_key_values=past_key_values,
+                                           return_dict=False)
+        logits = lm_head(dec_hs)  # (b, 1, vocab_size) or (b, K, 1, vocab_size)
+        _pred_ids = logits.argmax(-1)  # (B, 1) or (B, K, 1)
+
+        # update input_ids and past_key_values for next iteration
+        dec_input_ids = _pred_ids.clone(
+        )  # (B, 1) or (B, C, 1), deepcopy of _pred_ids because _pred_ids will be modified for finished sentences
+        past_key_values = _past_key_values
+
+        # finished sentences should have their next token be a padding token
+        if eos_id is not None:
+            if pad_id is None:
+                raise ValueError("If `eos_token_id` is defined, make sure that `pad_token_id` is defined.")
+            _pred_ids = _pred_ids * unfinished_sequences + pad_id * (1 - unfinished_sequences)
+
+        # update pred_ids
+        pred_ids = torch.cat((pred_ids, _pred_ids), dim=-1)  # (B, T') or (B, C, T') with increasing T'
+
+        # update state of unfinished_sequences
+        if eos_id is not None:
+            unfinished_sequences = unfinished_sequences * _pred_ids.ne(eos_id).long()
+
+            # early-stop when each sentence is finished
+            if stop_at_eos is True and unfinished_sequences.max() == 0:
+                break
+
+    return pred_ids  # (B, L) or (B, C, L)

pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+pythonpath = .

requirements.txt

@@ -0,0 +1,16 @@
+mirdata
+mido
+matplotlib
+lightning>=2.2.1
+pytest-timeout
+pytest
+deprecated
+librosa
+einops
+transformers==4.45
+wandb
+smart-open
+git+https://github.com/craffel/mir_eval.git
+git+https://github.com/katsura-jp/pytorch-cosine-annealing-with-warmup.git
+torchaudio
+huggingface_hub

test.py

@@ -0,0 +1,183 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+""" test.py """
+import os
+import pprint
+import argparse
+import torch
+
+from utils.data_modules import AMTDataModule
+from utils.task_manager import TaskManager
+from model.init_train import initialize_trainer, update_config
+from model.ymt3 import YourMT3
+from config.data_presets import data_preset_single_cfg, data_preset_multi_cfg
+from config.vocabulary import drum_vocab_presets
+from utils.utils import str2bool
+
+# yapf: disable
+parser = argparse.ArgumentParser(description="YourMT3")
+# General
+parser.add_argument('exp_id', type=str, help='A unique identifier for the experiment is used to resume training. The "@" symbol can be used to load a specific checkpoint.')
+parser.add_argument('-p', '--project', type=str, default='ymt3', help='project name')
+parser.add_argument('-d', '--data-preset', type=str, default='musicnet_thickstun_ext_em', help='dataset preset (default=musicnet_thickstun_ext_em). See config/data.py for more options.')
+# Audio configurations
+parser.add_argument('-ac', '--audio-codec', type=str, default=None, help='audio codec (default=None). {"spec", "melspec"}. If None, default value defined in config.py will be used.')
+parser.add_argument('-hop', '--hop-length', type=int, default=None, help='hop length in frames (default=None). {128, 300} 128 for MT3, 300 for PerceiverTFIf None, default value defined in config.py will be used.')
+parser.add_argument('-nmel', '--n-mels', type=int, default=None, help='number of mel bins (default=None). If None, default value defined in config.py will be used.')
+parser.add_argument('-if', '--input-frames', type=int, default=None, help='number of audio frames for input segment (default=None). If None, default value defined in config.py will be used.')
+# Model configurations
+parser.add_argument('-sqr', '--sca-use-query-residual', type=str2bool, default=None, help='sca use query residual flag. Default follows config.py')
+parser.add_argument('-enc', '--encoder-type', type=str, default=None, help="Encoder type. 't5' or 'perceiver-tf' or 'conformer'. Default is 't5', following config.py.")
+parser.add_argument('-dec', '--decoder-type', type=str, default=None, help="Decoder type. 't5' or 'multi-t5'. Default is 't5', following config.py.")
+parser.add_argument('-preenc', '--pre-encoder-type', type=str, default='default', help="Pre-encoder type. None or 'conv' or 'default'. By default, t5_enc:None, perceiver_tf_enc:conv, conformer:None")
+parser.add_argument('-predec', '--pre-decoder-type', type=str, default='default', help="Pre-decoder type. {None, 'linear', 'conv1', 'mlp', 'group_linear'} or 'default'. Default is {'t5': None, 'perceiver-tf': 'linear', 'conformer': None}.")
+parser.add_argument('-cout', '--conv-out-channels', type=int, default=None, help='Number of filters for pre-encoder conv layer. Default follows "model_cfg" of config.py.')
+parser.add_argument('-tenc', '--task-cond-encoder', type=str2bool, default=True, help='task conditional encoder (default=True). True or False')
+parser.add_argument('-tdec', '--task-cond-decoder', type=str2bool, default=True, help='task conditional decoder (default=True). True or False')
+parser.add_argument('-df', '--d-feat', type=int, default=None, help='Audio feature will be projected to this dimension for Q,K,V of T5 or K,V of Perceiver (default=None). If None, default value defined in config.py will be used.')
+parser.add_argument('-pt', '--pretrained', type=str2bool, default=False, help='pretrained T5(default=False). True or False')
+parser.add_argument('-b', '--base-name', type=str, default="google/t5-v1_1-small", help='base model name (default="google/t5-v1_1-small")')
+parser.add_argument('-epe', '--encoder-position-encoding-type', type=str, default='default', help="Positional encoding type of encoder. By default, pre-defined PE for T5 or Perceiver-TF encoder in config.py. For T5: {'sinusoidal', 'trainable'}, conformer: {'rotary', 'trainable'}, Perceiver-TF: {'trainable', 'rope', 'alibi', 'alibit', 'None', '0', 'none', 'tkd', 'td', 'tk', 'kdt'}.")
+parser.add_argument('-dpe', '--decoder-position-encoding-type', type=str, default='default', help="Positional encoding type of decoder. By default, pre-defined PE for T5 in config.py. {'sinusoidal', 'trainable'}.")
+parser.add_argument('-twe', '--tie-word-embedding', type=str2bool, default=None, help='tie word embedding (default=None). If None, default value defined in config.py will be used.')
+parser.add_argument('-el', '--event-length', type=int, default=None, help='event length (default=None). If None, default value defined in model cfg of config.py will be used.')
+# Perceiver-TF configurations
+parser.add_argument('-dl', '--d-latent', type=int, default=None, help='Latent dimension of Perceiver. On T5, this will be ignored (default=None). If None, default value defined in config.py will be used.')
+parser.add_argument('-nl', '--num-latents', type=int, default=None, help='Number of latents of Perceiver. On T5, this will be ignored (default=None). If None, default value defined in config.py will be used.')
+parser.add_argument('-dpm', '--perceiver-tf-d-model', type=int, default=None, help='Perceiver-TF d_model (default=None). If None, default value defined in config.py will be used.')
+parser.add_argument('-npb', '--num-perceiver-tf-blocks', type=int, default=None, help='Number of blocks of Perceiver-TF. On T5, this will be ignored (default=None). If None, default value defined in config.py.')
+parser.add_argument('-npl', '--num-perceiver-tf-local-transformers-per-block', type=int, default=None, help='Number of local layers per block of Perceiver-TF. On T5, this will be ignored (default=None). If None, default value defined in config.py will be used.')
+parser.add_argument('-npt', '--num-perceiver-tf-temporal-transformers-per-block', type=int, default=None, help='Number of temporal layers per block of Perceiver-TF. On T5, this will be ignored (default=None). If None, default value defined in config.py will be used.')
+parser.add_argument('-atc', '--attention-to-channel', type=str2bool, default=None, help='Attention to channel flag of Perceiver-TF. On T5, this will be ignored (default=None). If None, default value defined in config.py will be used.')
+parser.add_argument('-ln', '--layer-norm-type', type=str, default=None, help='Layer normalization type (default=None). {"layer_norm", "rms_norm"}. If None, default value defined in config.py will be used.')
+parser.add_argument('-ff', '--ff-layer-type', type=str, default=None, help='Feed forward layer type (default=None). {"mlp", "moe", "gmlp"}. If None, default value defined in config.py will be used.')
+parser.add_argument('-wf', '--ff-widening-factor', type=int, default=None, help='Feed forward layer widening factor for MLP/MoE/gMLP (default=None). If None, default value defined in config.py will be used.')
+parser.add_argument('-nmoe', '--moe-num-experts', type=int, default=None, help='Number of experts for MoE (default=None). If None, default value defined in config.py will be used.')
+parser.add_argument('-kmoe', '--moe-topk', type=int, default=None, help='Top-k for MoE (default=None). If None, default value defined in config.py will be used.')
+parser.add_argument('-act', '--hidden-act', type=str, default=None, help='Hidden activation function (default=None). {"gelu", "silu", "relu", "tanh"}. If None, default value defined in config.py will be used.')
+parser.add_argument('-rt', '--rotary-type', type=str, default=None, help='Rotary embedding type expressed in three letters. e.g. ppl: "pixel" for SCA and latents, "lang" for temporal transformer. If None, use config.')
+parser.add_argument('-rk', '--rope-apply-to-keys', type=str2bool, default=None, help='Apply rope to keys (default=None). If None, use config.')
+parser.add_argument('-rp', '--rope-partial-pe', type=str2bool, default=None, help='Whether to apply RoPE to partial positions (default=None). If None, use config.')
+# Decoder configurations
+parser.add_argument('-dff', '--decoder-ff-layer-type', type=str, default=None, help='Feed forward layer type of decoder (default=None). {"mlp", "moe", "gmlp"}. If None, default value defined in config.py will be used.')
+parser.add_argument('-dwf', '--decoder-ff-widening-factor', type=int, default=None, help='Feed forward layer widening factor for decoder MLP/MoE/gMLP (default=None). If None, default value defined in config.py will be used.')
+# Task and Evaluation configurations
+parser.add_argument('-tk', '--task', type=str, default='mt3_full_plus', help='tokenizer type (default=mt3_full_plus). See config/task.py for more options.')
+parser.add_argument('-epv', '--eval-program-vocab', type=str, default=None, help='evaluation vocabulary (default=None). If None, default vocabulary of the data preset will be used.')
+parser.add_argument('-edv', '--eval-drum-vocab', type=str, default=None, help='evaluation vocabulary for drum (default=None). If None, default vocabulary of the data preset will be used.')
+parser.add_argument('-etk', '--eval-subtask-key', type=str, default='default', help='evaluation subtask key (default=default). See config/task.py for more options.')
+parser.add_argument('-t', '--onset-tolerance', type=float, default=0.05, help='onset tolerance (default=0.05).')
+parser.add_argument('-os', '--test-octave-shift', type=str2bool, default=False, help='test optimal octave shift (default=False). True or False')
+parser.add_argument('-w', '--write-model-output', type=str2bool, default=False, help='write model test output to file (default=False). True or False')
+# Trainer configurations
+parser.add_argument('-pr','--precision', type=str, default="bf16-mixed", help='precision (default="bf16-mixed") {32, 16, bf16, bf16-mixed}')
+parser.add_argument('-st', '--strategy', type=str, default='auto', help='strategy (default=auto). auto or deepspeed or ddp')
+parser.add_argument('-n', '--num-nodes', type=int, default=1, help='number of nodes (default=1)')
+parser.add_argument('-g', '--num-gpus', type=str, default='auto', help='number of gpus (default="auto")')
+parser.add_argument('-wb', '--wandb-mode', type=str, default=None, help='wandb mode for logging (default=None). "disabled" or "online" or "offline". If None, default value defined in config.py will be used.')
+# Debug
+parser.add_argument('-debug', '--debug-mode', type=str2bool, default=False, help='debug mode (default=False). True or False')
+parser.add_argument('-tps', '--test-pitch-shift', type=int, default=None, help='use pitch shift when testing. debug-purpose only. (default=None). semitone in int.')
+args = parser.parse_args()
+# yapf: enable
+if torch.__version__ >= "1.13":
+    torch.set_float32_matmul_precision("high")
+args.epochs = None
+
+# Initialize trainer
+trainer, wandb_logger, dir_info, shared_cfg = initialize_trainer(args, stage='test')
+
+# Update config with args, including augmentation settings
+shared_cfg, audio_cfg, model_cfg = update_config(args, shared_cfg, stage='test')
+
+
+def main():
+    # Data preset
+    if args.data_preset in data_preset_single_cfg:
+        # convert single preset into multi preset format
+        data_preset = {
+            "presets": [args.data_preset],
+            "eval_vocab": data_preset_single_cfg[args.data_preset]["eval_vocab"],
+        }
+        for k in data_preset_single_cfg[args.data_preset].keys():
+            if k in ["eval_drum_vocab", "add_pitch_class_metric"]:
+                data_preset[k] = data_preset_single_cfg[args.data_preset][k]
+    elif args.data_preset in data_preset_multi_cfg:
+        data_preset = data_preset_multi_cfg[args.data_preset]
+    else:
+        raise ValueError("Invalid data preset")
+    eval_drum_vocab = data_preset.get("eval_drum_vocab", None)
+
+    if args.eval_drum_vocab != None:  # override eval_drum_vocab
+        eval_drum_vocab = drum_vocab_presets[args.eval_drum_vocab]
+
+    # Task manager
+    tm = TaskManager(task_name=args.task,
+                     max_shift_steps=int(shared_cfg["TOKENIZER"]["max_shift_steps"]),
+                     debug_mode=args.debug_mode)
+    print(f"Task: {tm.task_name}, Max Shift Steps: {tm.max_shift_steps}")
+
+    results = []
+    for i, preset in enumerate(data_preset["presets"]):
+        # sdp: unpacking multi preset as a list of single presets
+        sdp = {
+            "presets": [preset],
+            "eval_vocab": [data_preset["eval_vocab"][i]],
+            "eval_drum_vocab": eval_drum_vocab,
+        }
+        for k in data_preset.keys():
+            if k not in ["presets", "eval_vocab"]:
+                sdp[k] = data_preset[k]
+
+        dm = AMTDataModule(data_preset_multi=sdp, task_manager=tm, audio_cfg=audio_cfg)
+
+        model = YourMT3(
+            audio_cfg=audio_cfg,
+            model_cfg=model_cfg,
+            shared_cfg=shared_cfg,
+            optimizer=None,
+            task_manager=tm,  # tokenizer is a member of task_manager
+            eval_subtask_key=args.eval_subtask_key,
+            eval_vocab=args.eval_program_vocab if args.eval_program_vocab != None else sdp["eval_vocab"],
+            eval_drum_vocab=sdp["eval_drum_vocab"],
+            write_output_dir=dir_info["lightning_dir"] if args.write_model_output or args.test_octave_shift else None,
+            onset_tolerance=float(args.onset_tolerance),
+            add_pitch_class_metric=sdp.get("add_pitch_class_metric", None),
+            test_optimal_octave_shift=args.test_octave_shift,
+            test_pitch_shift_layer=args.test_pitch_shift)
+
+        # load checkpoint & drop pitchshift from state_dict
+        checkpoint = torch.load(dir_info["last_ckpt_path"])
+        state_dict = checkpoint['state_dict']
+        new_state_dict = {k: v for k, v in state_dict.items() if 'pitchshift' not in k}
+        model.load_state_dict(new_state_dict, strict=False)
+        # if args.test_pitch_shift is None:
+        #     new_state_dict = {k: v for k, v in state_dict.items() if 'pitchshift' not in k}
+        #     model.load_state_dict(new_state_dict, strict=False)
+        # else:
+        #     model.load_state_dict(state_dict, strict=False)
+
+        results.append("-----------------------------------------------------------------")
+        results.append(sdp)
+        results.append(trainer.test(model, datamodule=dm))
+        # TODO: directly load checkpoint including hyperparmeters https://lightning.ai/docs/pytorch/1.6.2/common/hyperparameters.html
+
+    # save result
+    pp = pprint.PrettyPrinter(indent=4)
+    results_str = pp.pformat(results)
+    result_file = os.path.join(dir_info["lightning_dir"],
+                               f"result_{args.task}_{args.eval_subtask_key}_{args.data_preset}.json")
+    with open(result_file, 'w') as f:
+        f.write(results_str)
+    print(f"Result is saved to {result_file}")
+
+
+if __name__ == "__main__":
+    main()

tests/assert_fns.py

@@ -0,0 +1,55 @@
+""" assert_fn.py """
+import numpy as np
+
+
+def assert_notes_almost_equal(actual_notes, predicted_notes, delta=5e-3):
+    """
+    Asserts that the given lists of Note instances are equal up to a small
+    floating-point tolerance, similar to `assertAlmostEqual` of `unittest`.
+    Tolerance is 5e-3 by default, which is 5 ms for 100 ticks-per-second.
+    """
+    assert len(actual_notes) == len(predicted_notes)
+    for actual_note, predicted_note in zip(actual_notes, predicted_notes):
+        assert abs(actual_note.onset - predicted_note.onset) < delta
+        assert abs(actual_note.offset - predicted_note.offset) < delta
+        assert actual_note.pitch == predicted_note.pitch
+        if actual_note.is_drum is False and predicted_note.is_drum is False:
+            assert actual_note.program == predicted_note.program
+        assert actual_note.is_drum == predicted_note.is_drum
+        assert actual_note.velocity == predicted_note.velocity
+
+
+def assert_note_events_almost_equal(actual_note_events,
+                                    predicted_note_events,
+                                    ignore_time=False,
+                                    ignore_activity=True,
+                                    delta=5.1e-3):
+    """
+    Asserts that the given lists of Note instances are equal up to a small
+    floating-point tolerance, similar to `assertAlmostEqual` of `unittest`.
+    Tolerance is 5e-3 by default, which is 5 ms for 100 ticks-per-second.
+
+    If `ignore_time` is True, then the time field is ignored. (useful for 
+    comparing tie note events, default is False)
+
+    If `ignore_activity` is True, then the activity field is ignored (default
+    is True).
+    """
+    assert len(actual_note_events) == len(predicted_note_events)
+    for j, (actual_note_event,
+            predicted_note_event) in enumerate(zip(actual_note_events, predicted_note_events)):
+        if ignore_time is False:
+            assert abs(actual_note_event.time - predicted_note_event.time) <= delta
+        assert actual_note_event.is_drum == predicted_note_event.is_drum
+        if actual_note_event.is_drum is False and predicted_note_event.is_drum is False:
+            assert actual_note_event.program == predicted_note_event.program
+        assert actual_note_event.pitch == predicted_note_event.pitch
+        assert actual_note_event.velocity == predicted_note_event.velocity
+        if ignore_activity is False:
+            assert actual_note_event.activity == predicted_note_event.activity
+
+
+def assert_track_metrics_score1(metrics) -> None:
+    for k, v in metrics.items():
+        if np.isnan(v) is False:
+            assert v == 1.0

tests/audio_test.py

@@ -0,0 +1,144 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+"""audio_test.py"""
+import unittest
+import os
+import numpy as np
+import wave
+import tempfile
+from utils.audio import load_audio_file
+from utils.audio import get_audio_file_info
+from utils.audio import slice_padded_array
+from utils.audio import slice_padded_array_for_subbatch
+from utils.audio import write_wav_file
+
+
+class TestLoadAudioFile(unittest.TestCase):
+
+    def create_temp_wav_file(self, duration: float, fs: int = 16000) -> str:
+        n_samples = int(duration * fs)
+        temp_file = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
+        temp_filename = temp_file.name
+
+        data = np.random.randint(-2**15, 2**15, n_samples, dtype=np.int16)
+
+        with wave.open(temp_filename, 'wb') as f:
+            f.setnchannels(1)
+            f.setsampwidth(2)
+            f.setframerate(fs)
+            f.writeframes(data.tobytes())
+
+        return temp_filename
+
+    def test_load_audio_file(self):
+        duration = 3.0
+        fs = 16000
+        temp_filename = self.create_temp_wav_file(duration, fs)
+
+        # Test load entire file
+        audio_data = load_audio_file(temp_filename, dtype=np.int16)
+        file_fs, n_frames, n_channels = get_audio_file_info(temp_filename)
+
+        self.assertEqual(len(audio_data), n_frames)
+        self.assertEqual(file_fs, fs)
+        self.assertEqual(n_channels, 1)
+
+        # Test load specific segment
+        seg_start_sec = 1.0
+        seg_length_sec = 1.0
+        audio_data = load_audio_file(temp_filename, seg_start_sec, seg_length_sec, dtype=np.int16)
+
+        self.assertEqual(len(audio_data), int(seg_length_sec * fs))
+
+        # Test unsupported file extension
+        with self.assertRaises(NotImplementedError):
+            load_audio_file("unsupported.xyz")
+
+
+class TestSliceArray(unittest.TestCase):
+
+    def setUp(self):
+        self.x = np.random.randint(0, 10, size=(1, 10000))
+
+    def test_without_padding(self):
+        sliced_x = slice_padded_array(self.x, slice_length=100, slice_hop=50, pad=False)
+        self.assertEqual(sliced_x.shape, (199, 100))
+
+    def test_with_padding(self):
+        sliced_x = slice_padded_array(self.x, slice_length=100, slice_hop=50, pad=True)
+        self.assertEqual(sliced_x.shape, (199, 100))
+
+    def test_content(self):
+        sliced_x = slice_padded_array(self.x, slice_length=100, slice_hop=50, pad=True)
+        for i in range(sliced_x.shape[0] - 1):
+            np.testing.assert_array_equal(sliced_x[i, :], self.x[:, i * 50:i * 50 + 100].flatten())
+        # Test the last slice separately to account for potential padding
+        last_slice = sliced_x[-1, :]
+        last_slice_no_padding = self.x[:, -100:].flatten()
+        np.testing.assert_array_equal(last_slice[:len(last_slice_no_padding)], last_slice_no_padding)
+
+
+class TestSlicePadForSubbatch(unittest.TestCase):
+
+    def test_slice_padded_array_for_subbatch(self):
+        input_array = np.random.randn(6, 10)
+        slice_length = 4
+        slice_hop = 2
+        pad = True
+        sub_batch_size = 4
+
+        expected_output_shape = (4, 4)
+
+        # Call the slice_pad_for_subbatch function
+        result = slice_padded_array_for_subbatch(input_array, slice_length, slice_hop, pad, sub_batch_size)
+
+        # Check if the output shape is correct
+        self.assertEqual(result.shape, expected_output_shape)
+
+        # Check if the number of slices is divisible by sub_batch_size
+        self.assertEqual(result.shape[0] % sub_batch_size, 0)
+
+
+class TestWriteWavFile(unittest.TestCase):
+
+    def test_write_wav_file_z(self):
+        # Generate some test audio data
+        samplerate = 16000
+        duration = 1  # 1 second
+        t = np.linspace(0, duration, int(samplerate * duration), endpoint=False)
+        x = np.sin(2 * np.pi * 440 * t)
+
+        # Write the test audio data to a WAV file
+        filename = "extras/test.wav"
+        write_wav_file(filename, x, samplerate)
+
+        # Read the written WAV file and check its contents
+        with wave.open(filename, "rb") as wav_file:
+            # Check the WAV file parameters
+            self.assertEqual(wav_file.getnchannels(), 1)
+            self.assertEqual(wav_file.getsampwidth(), 2)
+            self.assertEqual(wav_file.getframerate(), samplerate)
+            self.assertEqual(wav_file.getnframes(), len(x))
+
+            # Read the audio samples from the WAV file
+            data = wav_file.readframes(len(x))
+
+        # Convert the audio sample byte string to a NumPy array and normalize it to the range [-1, 1]
+        x_read = np.frombuffer(data, dtype=np.int16) / 32767.0
+
+        # Check that the audio samples read from the WAV file are equal to the original audio samples
+        np.testing.assert_allclose(x_read, x, atol=1e-4)
+
+        # Delete the written WAV file
+        os.remove(filename)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/event2note_test.py

@@ -0,0 +1,187 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+"""event2midi_test.py:
+
+This file contains tests for the following classes:
+• event2note_event
+• note_event2note
+
+"""
+import unittest
+import pytest
+from numpy import random
+from assert_fns import assert_notes_almost_equal
+from utils.note_event_dataclasses import Event, Note, NoteEvent
+from utils.event2note import event2note_event
+from utils.event2note import note_event2note
+
+
+# yapf: disable
+class TestEvent2NoteEvent(unittest.TestCase):
+    def test_event2note_event(self):
+        events = [
+            Event('program', 33), Event('pitch', 60),
+            Event('program', 52), Event('pitch', 40),
+            Event('tie', 0),
+            Event('shift', 20), Event('velocity', 1), Event('drum', 36),
+            Event('shift', 150), Event('program', 33), Event('velocity', 0), Event('pitch', 60),
+            Event('shift', 160), Event('velocity', 1), Event('pitch', 62), Event('program', 100),
+                                Event('pitch', 77),
+            Event('shift', 200), Event('velocity', 0), Event('pitch', 77),
+            Event('shift', 250), Event('velocity', 1), Event('drum', 38),
+            Event('shift', 300), Event('velocity', 0), Event('program', 33), Event('pitch', 62)
+        ]
+
+        note_events, tie_note_events, last_activity, err_cnt = event2note_event(events, start_time=0, sort=False, tps=100)
+        self.assertEqual(len(err_cnt), 0)
+        expected_note_events = [NoteEvent(True, 128, 0.2, 1, 36),
+                                NoteEvent(False, 33, 1.5, 0, 60),
+                                NoteEvent(False, 33, 1.6, 1, 62),
+                                NoteEvent(False, 100, 1.6, 1, 77),
+                                NoteEvent(False, 100, 2.0, 0, 77),
+                                NoteEvent(True, 128, 2.5, 1, 38),
+                                NoteEvent(False, 33, 3.0, 0, 62)]
+        expected_tie_note_events = [NoteEvent(False, 33, None, 1, 60),
+                                    NoteEvent(False, 52, None, 1, 40)]
+        expected_last_activity = [(52, 40)]
+        self.assertSequenceEqual(note_events, expected_note_events)
+        self.assertSequenceEqual(tie_note_events, expected_tie_note_events)
+        self.assertSequenceEqual(last_activity, expected_last_activity)
+
+class TestEvent2NoteEventInvalidInputWarn(unittest.TestCase):
+    def test_event2note_event_with_invalid_shift_value(self):
+        events = [Event('tie', 0), Event('shift', 0), Event('shift', 1050)] # shift: 0 <= value <= 1000
+        _, _, _, err_cnt = event2note_event(events, start_time=0, sort=True, tps=100)
+        self.assertEqual(err_cnt['Err/Shift out of range'], 2)
+
+    def test_event2note_event_with_invalid_pitch_event(self):
+        events = [Event('pitch', 60), Event('tie', 0)] # pitch event must follow a program event
+        _, _, _, err_cnt = event2note_event(events, start_time=0, sort=True, tps=100)
+        self.assertEqual(err_cnt['Err/Missing prg in tie'], 1)
+
+    def test_event2note_event_with_invalid_tie_event(self):
+        events = [Event('shift', 10)]
+        _, _, _, err_cnt = event2note_event(events, start_time=0, sort=True, tps=100)
+        self.assertEqual(err_cnt['Err/Missing tie'], 1)
+
+class TestEvent2NoteEventSpecialEvent(unittest.TestCase):
+    def test_note_event2note_special_events(self):
+        events = [Event('program', 33), Event('pitch', 60),
+                  Event('tie', 0),
+                  Event('shift', 10), Event('program', 33), Event('velocity', 0), Event('pitch', 60),
+                  Event('EOS', 0), Event('PAD', 0), # <- will stop decoding at this point...
+                  Event('shift', 20), Event('velocity', 1), Event('pitch', 20),
+                  Event('shift', 30), Event('velocity', 1), Event('pitch', 20),]
+        note_events, tie_note_events, _, err_cnt = event2note_event(events, start_time=0)
+        print(note_events)
+        self.assertEqual(len(note_events), 1)
+        self.assertEqual(len(tie_note_events), 1)
+        self.assertEqual(len(err_cnt), 0)
+
+
+class TestNoteEvent2Note(unittest.TestCase):
+
+    def test_note_event2note(self):
+
+        note_events = [NoteEvent(is_drum=False, program=33, time=0, velocity=1, pitch=60),
+        NoteEvent(is_drum=False, program=33, time=1.5, velocity=0, pitch=60),
+        NoteEvent(is_drum=False, program=33, time=1.6, velocity=1, pitch=62),
+        NoteEvent(is_drum=False, program=33, time=3.0, velocity=0, pitch=62),
+        NoteEvent(is_drum=False, program=100, time=1.6, velocity=1, pitch=77),
+        NoteEvent(is_drum=False, program=100, time=2.0, velocity=0, pitch=77),
+        NoteEvent(is_drum=True, program=128, time=0.2, velocity=1, pitch=36),
+        NoteEvent(is_drum=True, program=128, time=2.5, velocity=1, pitch=38)
+        ]
+        notes, err_cnt = note_event2note(note_events, sort=True)
+
+        expected_notes = [
+            Note(is_drum=False, program=33, onset=0, offset=1.5, pitch=60, velocity=1),
+            Note(is_drum=True, program=128, onset=0.2, offset=0.21, pitch=36, velocity=1),
+            Note(is_drum=False, program=33, onset=1.6, offset=3.0, pitch=62, velocity=1),
+            Note(is_drum=False, program=100, onset=1.6, offset=2.0, pitch=77, velocity=1),
+            Note(is_drum=True, program=128, onset=2.5, offset=2.51, pitch=38, velocity=1)
+            ]
+        self.assertEqual(len(err_cnt), 0)
+        assert_notes_almost_equal(notes, expected_notes, delta=5e-3)
+
+
+    def test_note_event2note_simple_cases(self):
+        # Case 1: Basic test case with two notes
+        note_events = [
+            NoteEvent(is_drum=False, program=0, time=0.1, velocity=1, pitch=60),
+            NoteEvent(is_drum=False, program=0, time=0.5, velocity=0, pitch=60),
+            NoteEvent(is_drum=False, program=0, time=0.7, velocity=1, pitch=62),
+            NoteEvent(is_drum=False, program=0, time=1.5, velocity=0, pitch=62),
+        ]
+
+        expected_notes = [
+            Note(is_drum=False, program=0, onset=0.1, offset=0.5, pitch=60, velocity=1),
+            Note(is_drum=False, program=0, onset=0.7, offset=1.5, pitch=62, velocity=1),
+        ]
+        notes, err_cnt = note_event2note(note_events)
+        self.assertEqual(len(err_cnt), 0)
+        self.assertSequenceEqual(notes, expected_notes)
+
+        # Case 2: Test with drum notes
+        note_events = [
+            NoteEvent(is_drum=True, program=128, time=0.2, velocity=1, pitch=36),
+            NoteEvent(is_drum=True, program=128, time=0.3, velocity=1, pitch=38),
+            NoteEvent(is_drum=True, program=128, time=0.4, velocity=0, pitch=36),
+            NoteEvent(is_drum=True, program=128, time=0.5, velocity=0, pitch=38),
+        ]
+
+        expected_notes = [
+            Note(is_drum=True, program=128, onset=0.2, offset=0.21, pitch=36, velocity=1),
+            Note(is_drum=True, program=128, onset=0.3, offset=0.31, pitch=38, velocity=1),
+        ]
+        notes, err_cnt = note_event2note(note_events)
+        self.assertEqual(len(err_cnt), 0)
+        assert_notes_almost_equal(notes, expected_notes, delta=5.1e-3)
+
+
+    def test_note_event2note_multiple_overlapping_notes(self):
+
+        note_events = [
+            NoteEvent(is_drum=False, program=1, time=0.0, velocity=1, pitch=60),
+            NoteEvent(is_drum=False, program=1, time=0.5, velocity=0, pitch=60),
+            NoteEvent(is_drum=False, program=1, time=1.0, velocity=1, pitch=62),
+            NoteEvent(is_drum=False, program=1, time=1.5, velocity=0, pitch=62),
+            NoteEvent(is_drum=False, program=2, time=0.25, velocity=1, pitch=60),
+            NoteEvent(is_drum=False, program=2, time=0.75, velocity=0, pitch=60),
+            NoteEvent(is_drum=False, program=2, time=1.25, velocity=1, pitch=62),
+            NoteEvent(is_drum=False, program=2, time=1.75, velocity=0, pitch=62),
+            NoteEvent(is_drum=False, program=3, time=0.0, velocity=1, pitch=64),
+            NoteEvent(is_drum=False, program=3, time=1.0, velocity=0, pitch=64),
+            NoteEvent(is_drum=False, program=4, time=0.5, velocity=1, pitch=66),
+            NoteEvent(is_drum=False, program=4, time=1.5, velocity=0, pitch=66),
+            NoteEvent(is_drum=False, program=4, time=0.75, velocity=1, pitch=67),
+            NoteEvent(is_drum=False, program=4, time=1.75, velocity=0, pitch=67),
+            NoteEvent(is_drum=False, program=4, time=1.0, velocity=1, pitch=69),
+            NoteEvent(is_drum=False, program=4, time=2.0, velocity=0, pitch=69)
+        ]
+
+        expected_notes = [
+            Note(is_drum=False, program=1, onset=0.0, offset=0.5, pitch=60, velocity=1),
+            Note(is_drum=False, program=3, onset=0.0, offset=1.0, pitch=64, velocity=1),
+            Note(is_drum=False, program=2, onset=0.25, offset=0.75, pitch=60, velocity=1),
+            Note(is_drum=False, program=4, onset=0.5, offset=1.5, pitch=66, velocity=1),
+            Note(is_drum=False, program=4, onset=0.75, offset=1.75, pitch=67, velocity=1),
+            Note(is_drum=False, program=1, onset=1.0, offset=1.5, pitch=62, velocity=1),
+            Note(is_drum=False, program=4, onset=1.0, offset=2.0, pitch=69, velocity=1),
+            Note(is_drum=False, program=2, onset=1.25, offset=1.75, pitch=62, velocity=1)
+        ]
+
+        notes, err_cnt = note_event2note(note_events)
+        self.assertEqual(len(err_cnt), 0)
+        assert_notes_almost_equal(notes, expected_notes, delta=5e-3)
+
+# yapf: enable
+if __name__ == '__main__':
+    unittest.main()

tests/event_codec_test.py

@@ -0,0 +1,158 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+"""event_codec_test.py:
+
+This file contains tests for the following classes:
+• Event
+• EventRange
+• FastCodec equivalent to MT3 author's Codec
+
+See tokenizer_test.py for the FastCodec performance benchmark
+
+"""
+import unittest
+from utils.note_event_dataclasses import Event, EventRange
+from utils.event_codec import FastCodec as Codec
+# from utils.event_codec import Codec
+
+
+class TestEvent(unittest.TestCase):
+
+    def test_Event(self):
+        e = Event(type='shift', value=0)
+        self.assertEqual(e.type, 'shift')
+        self.assertEqual(e.value, 0)
+
+
+class TestEventRange(unittest.TestCase):
+
+    def test_EventRange(self):
+        er = EventRange('abc', min_value=0, max_value=500)
+        self.assertEqual(er.type, 'abc')
+        self.assertEqual(er.min_value, 0)
+        self.assertEqual(er.max_value, 500)
+
+
+class TestEventCodec(unittest.TestCase):
+
+    def test_event_codec(self):
+        ec = Codec(
+            special_tokens=['asd'],
+            max_shift_steps=1001,
+            event_ranges=[
+                EventRange('pitch', min_value=0, max_value=127),
+                EventRange('velocity', min_value=0, max_value=1),
+                EventRange('tie', min_value=0, max_value=0),
+                EventRange('program', min_value=0, max_value=127),
+                EventRange('drum', min_value=0, max_value=127),
+            ],
+        )
+
+        events = [
+            Event(type='shift', value=0),  # actually not needed
+            Event(type='shift', value=1),  # 10 ms shift
+            Event(type='shift', value=1000),  # 10 s shift
+            Event(type='pitch', value=0),  # lowest pitch 8.18 Hz
+            Event(type='pitch', value=60),  # C4 or 261.63 Hz
+            Event(type='pitch', value=127),  # highest pitch G9 or 12543.85 Hz
+            Event(type='velocity', value=0),  # lowest velocity)
+            Event(type='velocity', value=1),  # lowest velocity)
+            Event(type='tie', value=0),  # tie
+            Event(type='program', value=0),  # program
+            Event(type='program', value=127),  # program
+            Event(type='drum', value=0),  # drum
+            Event(type='drum', value=127),  # drum
+        ]
+
+        encoded = [ec.encode_event(e) for e in events]
+        decoded = [ec.decode_event_index(idx) for idx in encoded]
+        self.assertSequenceEqual(events, decoded)
+
+
+class TestEventCodecErrorCases(unittest.TestCase):
+
+    def setUp(self):
+        self.event_ranges = [
+            EventRange("program", 0, 127),
+            EventRange("pitch", 0, 127),
+            EventRange("velocity", 0, 3),
+            EventRange("drum", 0, 127),
+            EventRange("tie", 0, 1),
+        ]
+        self.ec = Codec([], 1000, self.event_ranges)
+
+    def test_encode_event_with_invalid_event_type(self):
+        with self.assertRaises(ValueError):
+            self.ec.encode_event(Event("unknown_event_type", 50))
+
+    def test_encode_event_with_invalid_event_value(self):
+        with self.assertRaises(ValueError):
+            self.ec.encode_event(Event("program", 200))
+
+    def test_event_type_range_with_invalid_event_type(self):
+        with self.assertRaises(ValueError):
+            self.ec.event_type_range("unknown_event_type")
+
+    def test_decode_event_index_with_invalid_index(self):
+        with self.assertRaises(ValueError):
+            self.ec.decode_event_index(1000000)
+
+
+class TestEventCodecVocabulary(unittest.TestCase):
+
+    def test_encode_event_using_program_vocabulary(self):
+        prog_vocab = {"Piano": [0, 1, 2, 3, 4, 5, 6, 7], "xxx": [50, 30, 120]}
+        ec = Codec(special_tokens=['asd'],
+                   max_shift_steps=1001,
+                   event_ranges=[
+                       EventRange('pitch', min_value=0, max_value=127),
+                       EventRange('velocity', min_value=0, max_value=1),
+                       EventRange('tie', min_value=0, max_value=0),
+                       EventRange('program', min_value=0, max_value=127),
+                       EventRange('drum', min_value=0, max_value=127),
+                   ],
+                   program_vocabulary=prog_vocab)
+
+        events = [
+            Event(type='program', value=0),  # 0 --> 0
+            Event(type='program', value=7),  # 7 --> 0
+            Event(type='program', value=111),  # 111 --> 111
+            Event(type='program', value=30),  # 30 --> 50
+        ]
+        encoded = [ec.encode_event(e) for e in events]
+        expected = [1133, 1133, 1244, 1183]
+        self.assertSequenceEqual(encoded, expected)
+
+    def test_encode_event_using_drum_vocabulary(self):
+        drum_vocab = {"Kick": [50, 51, 52], "Snare": [53, 54]}
+        ec = Codec(special_tokens=['asd'],
+                   max_shift_steps=1001,
+                   event_ranges=[
+                       EventRange('pitch', min_value=0, max_value=127),
+                       EventRange('velocity', min_value=0, max_value=1),
+                       EventRange('tie', min_value=0, max_value=0),
+                       EventRange('program', min_value=0, max_value=127),
+                       EventRange('drum', min_value=0, max_value=127),
+                   ],
+                   drum_vocabulary=drum_vocab)
+
+        events = [
+            Event(type='drum', value=50),
+            Event(type='drum', value=51),
+            Event(type='drum', value=53),
+            Event(type='drum', value=54),
+        ]
+        encoded = [ec.encode_event(e) for e in events]
+        self.assertEqual(encoded[0], encoded[1])
+        self.assertEqual(encoded[2], encoded[3])
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/metrics_test.py

@@ -0,0 +1,118 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# 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
+#
+# Please see the details in the LICENSE file.
+"""metrics_test.py:
+
+This file contains tests for the following classes:
+• AMTMetrics
+
+"""
+import unittest
+import warnings
+import torch
+import numpy as np
+from utils.metrics import AMTMetrics
+from utils.metrics import compute_track_metrics
+
+
+class TestAMTMetrics(unittest.TestCase):
+
+    def test_individual_attributes(self):
+        metric = AMTMetrics()
+
+        # Test updating the metric using .update() method
+        metric.onset_f.update(0.5)
+
+        # Test updating the metric using __call__() method
+        metric.onset_f(0.5)
+
+        # Test updating the metric with a weight
+        metric.onset_f(0, weight=1.0)
+
+        # Test computing the average value of the metric
+        computed_value = metric.onset_f.compute()
+        self.assertAlmostEqual(computed_value, 0.3333333333333333)
+
+        # Test resetting the metric
+        metric.onset_f.reset()
+        with self.assertWarns(UserWarning):
+            torch._assert(metric.onset_f.compute(), torch.nan)
+
+        # Test bulk_compute
+        with self.assertWarns(UserWarning):
+            computed_metrics = metric.bulk_compute()
+
+    def test_bulk_update_and_compute(self):
+        metric = AMTMetrics()
+
+        # Test bulk_update with values only
+        d1 = {'onset_f': 0.5, 'offset_f': 0.5}
+        metric.bulk_update(d1)
+
+        # Test bulk_update with values and weights
+        d2 = {'onset_f': {'value': 0.5, 'weight': 1.0}, 'offset_f': {'value': 0.5, 'weight': 1.0}}
+        metric.bulk_update(d2)
+
+        # Test bulk_compute
+        computed_metrics = metric.bulk_compute()
+
+        # Ensure the 'onset_f' and 'offset_f' keys exist in the computed_metrics dictionary
+        self.assertIn('onset_f', computed_metrics)
+        self.assertIn('offset_f', computed_metrics)
+
+        # Check the computed values
+        self.assertAlmostEqual(computed_metrics['onset_f'], 0.5)
+        self.assertAlmostEqual(computed_metrics['offset_f'], 0.5)
+
+    def test_compute_track_metrics_singing(self):
+        from config.vocabulary import SINGING_SOLO_CLASS, GM_INSTR_CLASS_PLUS
+        from utils.event2note import note_event2note
+
+        ref_notes_dict = np.load('extras/examples/singing_notes.npy', allow_pickle=True).tolist()
+        ref_note_events_dict = np.load('extras/examples/singing_note_events.npy', allow_pickle=True).tolist()
+        est_notes, _ = note_event2note(ref_note_events_dict['note_events'])
+        ref_notes = ref_notes_dict['notes']
+
+        metric = AMTMetrics(prefix=f'test/', extra_classes=[k for k in SINGING_SOLO_CLASS.keys()])
+        drum_metric, non_drum_metric, instr_metric = compute_track_metrics(est_notes,
+                                                                           ref_notes,
+                                                                           eval_vocab=SINGING_SOLO_CLASS,
+                                                                           eval_drum_vocab=None,
+                                                                           onset_tolerance=0.05)
+        metric.bulk_update(drum_metric)
+        metric.bulk_update(non_drum_metric)
+        metric.bulk_update(instr_metric)
+        computed_metrics = metric.bulk_compute()
+        cnt = 0
+        for k, v in computed_metrics.items():
+            if 'Singing Voice' in k:
+                self.assertEqual(v, 1.0)
+                cnt += 1
+        self.assertEqual(cnt, 6)
+
+        metric = AMTMetrics(prefix=f'test/', extra_classes=[k for k in GM_INSTR_CLASS_PLUS.keys()])
+        drum_metric, non_drum_metric, instr_metric = compute_track_metrics(est_notes,
+                                                                           ref_notes,
+                                                                           eval_vocab=GM_INSTR_CLASS_PLUS,
+                                                                           eval_drum_vocab=None,
+                                                                           onset_tolerance=0.05)
+        metric.bulk_update(drum_metric)
+        metric.bulk_update(non_drum_metric)
+        metric.bulk_update(instr_metric)
+        computed_metrics = metric.bulk_compute()
+        cnt = 0
+        for k, v in computed_metrics.items():
+            if 'Singing Voice' in k:
+                self.assertEqual(v, 1.0)
+                cnt += 1
+        self.assertEqual(cnt, 6)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/midi_test.py

@@ -0,0 +1,65 @@
+import unittest
+from typing import List
+from tempfile import NamedTemporaryFile
+from assert_fns import assert_notes_almost_equal
+from utils.note_event_dataclasses import Note
+
+from utils.midi import note_event2midi
+from utils.midi import midi2note
+from utils.note2event import note2note_event
+# yapf: disable
+
+class TestNoteMidiConversion(unittest.TestCase):
+
+    def test_note2midi2note_z(self):
+        original_notes = [
+            Note(is_drum=False, program=3, onset=0., offset=1., pitch=60, velocity=1),
+            Note(is_drum=False, program=3, onset=1., offset=2., pitch=64, velocity=1),
+        ]
+
+        with NamedTemporaryFile(suffix=".mid", delete=True) as temp_file:
+            # Convert original_notes to MIDI and save it to the temporary file
+            note_events = note2note_event(notes=original_notes, sort=True)
+            note_event2midi(note_events, temp_file.name, velocity=100)
+
+            # Convert the MIDI back to notes
+            converted_notes, _ = midi2note(temp_file.name)
+
+            # Compare original notes and converted notes
+            assert_notes_almost_equal(original_notes, converted_notes)
+
+    def test_midi2note2midi2note_piano_z(self):
+        file = 'extras/examples/piano.mid'
+        # This MIDI file is missing the program change event, so we force it to be 0
+        notes, _ = midi2note(file, quantize=False, force_all_program_to=0)[:1000]
+        note_events = note2note_event(notes=notes, sort=True)
+        note_event2midi(note_events, 'extras/examples/piano_converted.mid', velocity=100)
+        reconverted_notes, _ = midi2note('extras/examples/piano_converted.mid', quantize=False)
+        assert_notes_almost_equal(notes, reconverted_notes, delta=0.01)
+
+    def test_midi2note2midi2note_force_drum_z(self):
+        file = 'extras/examples/drum.mid'
+        conv_file = 'extras/examples/drum_converted.mid'
+        # This MIDI file is missing the program change event, so we force it to be 0
+        notes, _ = midi2note(file, quantize=True, force_all_drum=True)[:100]
+        note_events = note2note_event(notes=notes, sort=True)
+        note_event2midi(note_events, conv_file, velocity=100, ticks_per_beat=960)
+        reconverted_notes, _ = midi2note(conv_file, quantize=True, force_all_drum=True)
+        assert_notes_almost_equal(notes, reconverted_notes, delta=0.005)
+
+        # In drum, this is very inaccurate. We should fix this in the future.
+        # Even for the first 100 notes, the timing is off by 170 ms.
+
+    def test_midi2note_ignore_pedal_true_z(self):
+        file = 'extras/examples/piano.mid'
+        notes, _ = midi2note(file, quantize=False, ignore_pedal=True, force_all_program_to=0)
+        note_events = note2note_event(notes=notes, sort=True)
+        note_event2midi(note_events, 'extras/examples/piano_converted.mid', velocity=100)
+        reconverted_notes, _ = midi2note('extras/examples/piano_converted.mid', quantize=False)
+        assert_notes_almost_equal(notes, reconverted_notes, delta=0.01)
+
+
+# yapf: enable
+
+if __name__ == '__main__':
+    unittest.main()