Dynamic Accent Pro v1.1 (experimental prompt-controlled Nigerian TTS); Flash-DPO default, Pro via --instruct

.gitattributes

@@ -33,3 +33,19 @@ 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
+assets/dynamic_accent_banner.jpg filter=lfs diff=lfs merge=lfs -text
+prompts/clip0_waxal_yor_yor_1258.wav filter=lfs diff=lfs merge=lfs -text
+prompts/clip1_waxal_yor_yor_1205.wav filter=lfs diff=lfs merge=lfs -text
+prompts/clip2_waxal_yor_yor_1263.wav filter=lfs diff=lfs merge=lfs -text
+prompts/clip3_waxal_yor_yor_1218.wav filter=lfs diff=lfs merge=lfs -text
+prompts/voice_waxal_ibo_5.wav filter=lfs diff=lfs merge=lfs -text
+prompts/voice_waxal_yor_5.wav filter=lfs diff=lfs merge=lfs -text
+samples/flash_ibo_waxal_ibo_5_default.mp3 filter=lfs diff=lfs merge=lfs -text
+samples/pro_cs_anchor_default.mp3 filter=lfs diff=lfs merge=lfs -text
+samples/pro_cs_anchor_many_pauses.mp3 filter=lfs diff=lfs merge=lfs -text
+samples/pro_cs_anchor_slow.mp3 filter=lfs diff=lfs merge=lfs -text
+samples/pro_cs_waxal_ibo_5_many_pauses.mp3 filter=lfs diff=lfs merge=lfs -text
+samples/pro_ibo_anchor_many_pauses.mp3 filter=lfs diff=lfs merge=lfs -text
+samples/pro_ibo_anchor_slow.mp3 filter=lfs diff=lfs merge=lfs -text
+samples/pro_ibo_waxal_ibo_5_default.mp3 filter=lfs diff=lfs merge=lfs -text
+samples/pro_ibo_waxal_ibo_5_many_pauses.mp3 filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,428 @@
+Attribution-ShareAlike 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution-ShareAlike 4.0 International Public
+License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution-ShareAlike 4.0 International Public License ("Public
+License"). To the extent this Public License may be interpreted as a
+contract, You are granted the Licensed Rights in consideration of Your
+acceptance of these terms and conditions, and the Licensor grants You
+such rights in consideration of benefits the Licensor receives from
+making the Licensed Material available under these terms and
+conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. BY-SA Compatible License means a license listed at
+     creativecommons.org/compatiblelicenses, approved by Creative
+     Commons as essentially the equivalent of this Public License.
+
+  d. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  e. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  f. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  g. License Elements means the license attributes listed in the name
+     of a Creative Commons Public License. The License Elements of this
+     Public License are Attribution and ShareAlike.
+
+  h. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  i. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  j. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  k. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  l. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  m. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+
+            b. produce, reproduce, and Share Adapted Material.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. Additional offer from the Licensor -- Adapted Material.
+               Every recipient of Adapted Material from You
+               automatically receives an offer from the Licensor to
+               exercise the Licensed Rights in the Adapted Material
+               under the conditions of the Adapter's License You apply.
+
+            c. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+  b. ShareAlike.
+
+     In addition to the conditions in Section 3(a), if You Share
+     Adapted Material You produce, the following conditions also apply.
+
+       1. The Adapter's License You apply must be a Creative Commons
+          license with the same License Elements, this version or
+          later, or a BY-SA Compatible License.
+
+       2. You must include the text of, or the URI or hyperlink to, the
+          Adapter's License You apply. You may satisfy this condition
+          in any reasonable manner based on the medium, means, and
+          context in which You Share Adapted Material.
+
+       3. You may not offer or impose any additional or different terms
+          or conditions on, or apply any Effective Technological
+          Measures to, Adapted Material that restrict exercise of the
+          rights granted under the Adapter's License You apply.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material,
+     including for purposes of Section 3(b); and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.
+

LICENSE-CODE

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

README.md

@@ -0,0 +1,247 @@
+---
+license: cc-by-sa-4.0
+language:
+  - en
+  - pcm
+  - yo
+  - ig
+  - ha
+base_model:
+  - FunAudioLLM/Fun-CosyVoice3-0.5B-2512
+pipeline_tag: text-to-speech
+library_name: pytorch
+tags:
+  - text-to-speech
+  - code-switching
+  - nigerian-languages
+  - igbo
+  - yoruba
+  - hausa
+  - nigerian-pidgin
+  - cosyvoice3
+  - instruction-tts
+  - dpo
+  - experimental
+datasets:
+  - google/WaxalNLP
+  - McGill-NLP/NaijaS2ST
+  - AfriSpeech/open-bible-speech-african
+  - nkowaokwu/ibo-dict
+  - google/fleurs
+---
+
+<p align="center"><img src="assets/dynamic_accent_banner.jpg" width="600"/></p>
+
+# Dynamic Accent Pro v1.1
+
+**Experimental prompt-controlled Nigerian TTS and code-switching technology** by Modular. English, Nigerian Pidgin, Igbo, Yoruba and Hausa, mixed inside one sentence and spoken by one consistent voice, with a plain-English **style instruction** (`--instruct`) that steers pace and pausing.
+
+Pro v1.1 is a research release, not a production system. It is the Flash recipe (CosyVoice3 LM fine-tuned on licensed Nigerian-language speech, then DPO) with a new instruction layer on top. Read **What works and what does not** before using it.
+
+## What works and what does not
+
+| control | status | how |
+|---|---|---|
+| **Pace** ("speak slowly", "speak fast") | **works** | read by the LM from the instruction, sharpened by classifier-free guidance (`--guidance 2`, the default). Slow vs fast is ordered correctly on 18/18 held-out items; slow ≈ 0.89× and fast ≈ 1.15× the default articulation rate |
+| **Pauses** ("plenty of pauses", "hardly any pauses") | **works through a text step** | the instruction also edits the text before synthesis (`pause_text.py`: inserts the model's learned `[pause]` tag for "many", strips commas and pause tags for "few"). Many ≈ 1.28× default pause rate; few ≈ 0.91×. The LM alone barely moves pauses, so `--no_text_pauses` mostly turns this off |
+| Calm / lively tone | **not advertised** | trained, but indistinguishable from chance in our measurements. The words are accepted and ignored in effect |
+| Emotion (happy, sad, angry, …) | **no** | not trained, no data |
+| Code-switching from **tags** (`<ibo>…</ibo> <eng>…</eng>`) | works (the core Dynamic Accent capability) | language embeddings + a speaker token keep one voice across switches |
+| Code-switching from a **request** (`--codeswitch_prompt "mostly English, Igbo greetings"`) | **experimental, separate step** | a text LLM ([Qwen/Qwen3-32B](https://huggingface.co/Qwen/Qwen3-32B), Apache-2.0, not bundled) rewrites plain text into tagged code-switched text *before* synthesis. It is not a TTS capability. Its Pidgin and Hausa are usable; **its Igbo and Yoruba beyond simple greetings are weak and often wrong**, so always read the printed tagged text and fix it |
+
+Without `--instruct`, `infer.py` uses Flash-DPO (the default version). Passing `--instruct` switches to Pro automatically unless you set `--version`; `--version pro` without an instruction uses Pro's default prompt, trained on native-like clips.
+
+## Versions and voices
+
+| version | LM | notes |
+|---|---|---|
+| `pro` (used automatically with `--instruct`) | `checkpoints/pro/flash_instruct` | Pro v1.1: Flash-DPO → instruction SFT → DPO polish. Instruction control, CFG 2.0 on the instruction, text pause step |
+| `flash` (**default**) | `checkpoints/flash/flash_dpo` | Flash-DPO (no instruction control), the default when no `--instruct` is given: it sounds more natural on plain code-switched text. A/B: `--compare` renders the same text with both |
+
+Both use the stock Fun-CosyVoice3-0.5B-2512 flow and vocoder, zero-shot from the voice clip, and the same text front-end (numbers verbalised; missing Yoruba/Igbo diacritics restored by `checkpoints/flash/diacritics_byt5`).
+
+| voice (`--voice`) | who |
+|---|---|
+| `anchor_male` (default) | WAXAL Media Trust Yoruba speaker 4 (male), the voice both models were trained around |
+| `waxal_ibo_5_female` | WAXAL Igbo speaker 5 (female), zero-shot from a 6.6 s clip |
+| `waxal_yor_5_female` | WAXAL Yoruba speaker 5 (female), zero-shot; short prompt, so short pauses and more clipped endings |
+
+## Setup (single CUDA GPU)
+
+```bash
+git clone --recursive https://github.com/FunAudioLLM/CosyVoice.git
+cd CosyVoice && git checkout 074ca6dc9e80a2f424f1f74b48bdd7d3fea531cc && git submodule update --init --recursive && cd ..
+huggingface-cli download Modularcomputing/dynamic-accent-pro-v1.1 --local-dir dynamic-accent-pro
+pip install -r dynamic-accent-pro/requirements.txt
+```
+
+Fun-CosyVoice3-0.5B-2512 downloads on first run (`--cv3_dir` / `CV3_DIR` to reuse a copy). Tested on an H100 in bf16; a 16 GB GPU is enough for TTS. The optional code-switch step needs a GPU that holds Qwen3-32B in bf16 (~65 GB); `--cs_llm Qwen/Qwen3-14B` is lighter and worse.
+
+## Usage
+
+```bash
+cd dynamic-accent-pro
+# default prompt (native-like pace and pauses)
+python infer.py --cosyvoice_dir ../CosyVoice --text "<ibo>Ndewo nụ, ụmụnna m.</ibo> <eng>Tonight we will talk about the new market road.</eng>" --out out.wav
+
+# pace
+python infer.py --cosyvoice_dir ../CosyVoice --instruct "Please speak slowly and take your time." --text "..." --out slow.wav
+python infer.py --cosyvoice_dir ../CosyVoice --instruct "Speak fast, like a quick everyday conversation." --text "..." --out fast.wav
+
+# pauses (text step + instruction)
+python infer.py --cosyvoice_dir ../CosyVoice --instruct "Speak with plenty of pauses between phrases." --text "..." --out many.wav
+python infer.py --cosyvoice_dir ../CosyVoice --instruct "Say it in one smooth flow with hardly any pauses." --text "..." --out few.wav
+
+# female Igbo voice
+python infer.py --cosyvoice_dir ../CosyVoice --voice waxal_ibo_5_female --text "<ibo>Kedu ka ị mere?</ibo> <pcm>Abeg no vex, I go call you for evening.</pcm>" --out ibo_f.wav
+
+# experimental: plain text + a code-switch request -> Qwen3-32B writes the tagged text (check it!) -> TTS
+python infer.py --cosyvoice_dir ../CosyVoice --codeswitch_prompt "Nigerian Pidgin with an Igbo greeting" \
+  --text "My brother, the work is too much today, but we will finish it." --out cs.wav
+
+# A/B the same text, seed and voice with Flash and Pro -> cmp_flash.wav, cmp_pro.wav
+python infer.py --cosyvoice_dir ../CosyVoice --compare --compare_versions flash,pro --text "..." --out cmp.wav
+```
+
+| flag | what it does |
+|---|---|
+| `--instruct "..."` | `pro`: natural-language style instruction. Reliable: slow / fast; plenty of / hardly any pauses. Phrasings close to the examples above work best |
+| `--guidance G` | `pro`: classifier-free guidance strength on the instruction (default 2.0; 0 = off, weaker pace control) |
+| `--no_text_pauses` | `pro`: do not edit the text for pause instructions |
+| `--codeswitch_prompt "..."` | optional text-LLM step before synthesis (see above); output is validated (tags, length, loops, back-translation meaning check) and falls back to the input text |
+| `--cs_llm` | the LLM for that step (default `Qwen/Qwen3-32B`) |
+| `--version pro\|flash`, `--compare`, `--compare_versions` | model version / A/B rendering |
+| `--voice`, `--list_voices` | voice selection |
+| `--auto_tag`, `--tag_only`, `--force_lang`, `--lang_map` | language tagging of untagged text (see `tagger.py`) |
+| `--frontend codeswitch\|native\|accent`, `--frontend_lang`, `--no_diacritics` | text front-end |
+| `--seed N` | sampling seed (default 0). Try 2–3 seeds and keep the best take |
+| `--tail_pad N` | append N silence speech tokens before the vocoder so the last syllable is not clipped (opt-in; 6 tested) |
+
+Text: wrap each language span in `<eng>`, `<pcm>`, `<yor>`, `<ibo>` or `<hau>`; untagged text is read as English unless `--auto_tag` / `--force_lang` is given. Write Yoruba and Igbo with diacritics where you can. GPU generation is not bit-reproducible (bf16 near-ties).
+
+## Samples
+
+`samples/` holds MP3 renders for all five languages and a code-switched sentence, both main voices, with the default prompt and the slow / fast / few-pauses / many-pauses instructions, plus a Flash-DPO render of the same text and seed for A/B (`samples/meta.json` lists text, voice and instruction per file). `samples/codeswitch_frontend/` shows the experimental Qwen3-32B step: input text, request, the tagged text it produced, and the audio. The Igbo and Yoruba demo sentences have **not yet been checked by a native speaker**.
+
+## Results
+
+Automatic regression set: 197 held-out sentences per voice (30 each of Igbo, Yoruba, Hausa, Pidgin, English; 24 code-switched; 23 paragraphs), default prompt, seed 0. CER from automatic ASR judges (per language, same judges for every system), pace and pause rate relative to native recordings of the same languages, clipped ending = less than 0.1 s of trailing silence, SIM = speaker similarity to the prompt clip, UTMOSv2 = predicted naturalness.
+
+| voice | group | system | CER | CER no-tone | pace × native | pauses × native | clipped endings | SIM | UTMOSv2 |
+|---|---|---|---|---|---|---|---|---|---|
+| anchor_male | all | Flash-DPO | 0.162 | 0.135 | 0.99 | 0.75 | 7% | 0.784 | 3.17 |
+| anchor_male | all | **Pro v1.1** | 0.167 | 0.141 | 0.99 | 1.02 | 8% | 0.789 | 3.16 |
+| anchor_male | ibo | Flash-DPO | 0.189 | 0.158 | 1.06 | 0.40 | 7% | 0.762 | 3.06 |
+| anchor_male | ibo | **Pro v1.1** | 0.216 | 0.181 | 1.02 | 0.62 | 3% | 0.779 | 3.01 |
+| anchor_male | yor | Flash-DPO | 0.230 | 0.144 | 1.08 | 0.30 | 3% | 0.762 | 2.99 |
+| anchor_male | yor | **Pro v1.1** | 0.218 | 0.141 | 1.06 | 0.68 | 3% | 0.770 | 3.02 |
+| anchor_male | hau | Flash-DPO | 0.123 | 0.123 | 0.83 | 0.77 | 0% | 0.788 | 3.26 |
+| anchor_male | hau | **Pro v1.1** | 0.147 | 0.147 | 0.81 | 1.19 | 3% | 0.796 | 3.19 |
+| anchor_male | pcm | Flash-DPO | 0.227 | 0.227 | 0.97 | 0.72 | 10% | 0.782 | 3.26 |
+| anchor_male | pcm | **Pro v1.1** | 0.199 | 0.199 | 1.01 | 0.97 | 3% | 0.779 | 3.25 |
+| anchor_male | eng | Flash-DPO | 0.026 | 0.026 | 0.94 | 1.85 | 17% | 0.790 | 3.26 |
+| anchor_male | eng | **Pro v1.1** | 0.031 | 0.031 | 0.94 | 1.89 | 7% | 0.796 | 3.26 |
+| anchor_male | cs | Flash-DPO | 0.208 | 0.159 | 1.02 | 1.00 | 12% | 0.773 | 3.09 |
+| anchor_male | cs | **Pro v1.1** | 0.213 | 0.162 | 1.05 | 1.27 | 25% | 0.766 | 3.22 |
+| anchor_male | para | Flash-DPO | 0.131 | 0.106 | 1.06 | 1.08 | 0% | 0.843 | 3.28 |
+| anchor_male | para | **Pro v1.1** | 0.149 | 0.126 | 1.05 | 1.29 | 13% | 0.843 | 3.16 |
+| waxal_ibo_5_female | all | Flash-DPO | 0.165 | 0.134 | 1.03 | 0.95 | 11% | 0.700 | 3.51 |
+| waxal_ibo_5_female | all | **Pro v1.1** | 0.152 | 0.123 | 1.01 | 0.84 | 12% | 0.698 | 3.45 |
+| waxal_ibo_5_female | ibo | Flash-DPO | 0.215 | 0.171 | 1.09 | 0.52 | 7% | 0.697 | 3.41 |
+| waxal_ibo_5_female | ibo | **Pro v1.1** | 0.178 | 0.145 | 1.07 | 0.58 | 0% | 0.682 | 3.40 |
+| waxal_ibo_5_female | yor | Flash-DPO | 0.251 | 0.150 | 1.18 | 0.86 | 7% | 0.661 | 3.45 |
+| waxal_ibo_5_female | yor | **Pro v1.1** | 0.224 | 0.118 | 1.11 | 0.38 | 10% | 0.671 | 3.36 |
+| waxal_ibo_5_female | hau | Flash-DPO | 0.117 | 0.117 | 0.86 | 1.20 | 7% | 0.700 | 3.51 |
+| waxal_ibo_5_female | hau | **Pro v1.1** | 0.132 | 0.132 | 0.85 | 0.74 | 13% | 0.676 | 3.47 |
+| waxal_ibo_5_female | pcm | Flash-DPO | 0.184 | 0.183 | 1.02 | 0.92 | 13% | 0.674 | 3.63 |
+| waxal_ibo_5_female | pcm | **Pro v1.1** | 0.152 | 0.151 | 1.02 | 0.83 | 20% | 0.690 | 3.48 |
+| waxal_ibo_5_female | eng | Flash-DPO | 0.031 | 0.031 | 0.99 | 1.34 | 10% | 0.726 | 3.60 |
+| waxal_ibo_5_female | eng | **Pro v1.1** | 0.031 | 0.031 | 0.93 | 1.62 | 13% | 0.745 | 3.52 |
+| waxal_ibo_5_female | cs | Flash-DPO | 0.230 | 0.179 | 1.01 | 1.32 | 29% | 0.682 | 3.50 |
+| waxal_ibo_5_female | cs | **Pro v1.1** | 0.220 | 0.174 | 1.07 | 1.22 | 17% | 0.660 | 3.40 |
+| waxal_ibo_5_female | para | Flash-DPO | 0.133 | 0.106 | 1.07 | 0.99 | 4% | 0.773 | 3.44 |
+| waxal_ibo_5_female | para | **Pro v1.1** | 0.141 | 0.114 | 1.05 | 1.20 | 9% | 0.772 | 3.50 |
+
+Native-speaker reference: pace 1.00 / pauses 1.00 by definition. Summary: Pro v1.1 matches Flash-DPO on overall CER for the anchor voice (0.167 vs 0.162) and beats it for the female Igbo voice (0.152 vs 0.165); it pauses much closer to native in Igbo and Yoruba on the anchor voice (0.62× / 0.68× vs 0.40× / 0.30×); it is worse than Flash-DPO on anchor Igbo CER (0.216 vs 0.189) and on Hausa for both voices.
+
+Instruction adherence (anchor voice, 18 held-out Igbo/Yoruba/Hausa/Pidgin/English/code-switch items, CFG 2, text pause step on; "direction" = share of items moving the requested way vs the default prompt):
+
+| instruction | articulation rate × default | pause rate × default | direction correct |
+|---|---|---|---|
+| Please speak slowly and take your time. | 0.89 | 1.16 | 89% |
+| Speak fast, like a quick everyday conversation. | 1.15 | 0.87 | 94% |
+| Say it in one smooth flow with hardly any pauses. | 0.92 | 0.91 | 56% |
+| Speak with plenty of pauses between phrases. | 0.90 | 1.28 | 78% |
+| Use a calm, gentle, even tone. *(not advertised)* | 0.98 | 1.02 | 50% |
+| Sound lively and expressive. *(not advertised)* | 0.96 | 0.94 | 44% |
+
+Slow vs fast on the same item: correct order on 100% of items; many vs few pauses: 67%; lively vs calm: 50% (chance). Note that "slow" also adds pauses (1.16× pause rate). 18 items is a small set; treat these as indicative.
+
+## Limitations
+
+- **Experimental.** Pace control is real; pause control depends on the text step; calm/lively and emotion are not available.
+- **Anchor Igbo** CER is still higher than Flash-DPO (0.216 vs 0.189); **Hausa** CER is worse than Flash-DPO for both voices. Flash-DPO remains available as `--version flash`.
+- English stays over-paused relative to native English (about 1.9× native pause rate on the anchor voice, the same as Flash-DPO).
+- Clipped endings remain on code-switched sentences and paragraphs (13–25% on the anchor voice). `--tail_pad 6` (six silence tokens appended before the vocoder, inference-only) removed every measured clipped ending in testing with no consistent CER change (+0.005 overall, within seed noise); it is opt-in until it has been checked by ear.
+- The code-switch request step (Qwen3-32B) is a separate text model: weak Igbo/Yoruba beyond greetings, sometimes refuses to switch and falls back to the input text.
+- Pidgin has little training data and no reliable ASR judge; Yoruba tone quality needs native listening.
+- Female voices are zero-shot. Not evaluated for numbers, abbreviations or URLs.
+- Do not use it to impersonate real people. The voices are WAXAL Media Trust speakers, released under CC-BY-SA-4.0 for speech technology.
+
+## Training
+
+1. **Flash-DPO** (the `flash` version): CosyVoice3 LM fine-tuned on the licensed set below (language embeddings, speaker token, adversarial speaker classifier, rate embedding), then DPO on 1,206 preference pairs.
+2. **Instruction SFT** (3,000 steps): ~100.9k licensed clips labelled from the audio (articulation rate, pause rate, energy/F0 variation); each training item gets a natural-language instruction built from its labels in the CosyVoice3 system-prompt slot, plus explicit pause/energy control embeddings; 18% of items keep the default prompt, drawn from native-like clips.
+3. **DPO polish** (134 steps, β 0.1, lr 1e-6, SFT weight 0.1): 700 prompts × 4 samples from the SFT model, 564 preference pairs; reward = CER + pace and pause-rate match to native + a clipped-ending penalty + a small UTMOS guard.
+
+Inference: classifier-free guidance on the instruction (conditional = instruction + controls, unconditional = default prompt), g = 2.
+
+## What is in the repo
+
+| path | what it is | licence |
+|---|---|---|
+| `checkpoints/pro/flash_instruct/` | Pro v1.1 LM (`best.pt`, sha256 `87c3a7e9…4cab3db`), `config.json`, `spk2id.json`, DPO `args.json`, `log.jsonl` | CC-BY-SA-4.0 |
+| `checkpoints/flash/flash_dpo/` | Flash-DPO LM (`best.pt`, sha256 `f59a6fc0…7e3a307`) | CC-BY-SA-4.0 |
+| `checkpoints/flash/diacritics_byt5/` | Yoruba/Igbo diacritic restoration (fine-tune of google/byt5-small) | CC-BY-SA-4.0 |
+| `prompts/` | voice clips and transcripts (WAXAL) | CC-BY-SA-4.0 |
+| `samples/` | demo renders | CC-BY-SA-4.0 |
+| `config.json` | repo-level manifest (also lets the Hub count downloads) | Apache-2.0 |
+| `settings.json` | versions, voices, defaults | Apache-2.0 |
+| `infer.py`, `flash_lm.py`, `flash_instruct.py`, `instruct_text.py`, `pause_text.py`, `cs_frontend.py`, `tagger.py`, `frontend/`, `code/` | inference, model, instruction, text pause step, code-switch step, tagger, front-end, reference training code | Apache-2.0 |
+
+## Training data and attribution
+
+Licensed data only. The weights are trained on, and the voice prompts taken from:
+
+| dataset | licence | attribution |
+|---|---|---|
+| [WAXAL](https://huggingface.co/datasets/google/WaxalNLP), Media Trust TTS subsets (Igbo, Yoruba, Hausa, Nigerian Pidgin); all voice prompts | CC-BY-SA-4.0 | Google and Media Trust, WAXAL (arXiv:2602.02734) |
+| [Open.Bible Igbo](https://huggingface.co/datasets/AfriSpeech/open-bible-speech-african) | CC-BY-SA-4.0 | Biblica, Inc. via open.bible |
+| [NaijaS2ST](https://huggingface.co/datasets/McGill-NLP/NaijaS2ST) (Igbo) | CC-BY-4.0 | McGill-NLP (arXiv:2604.16287) |
+| [IgboAPI](https://huggingface.co/datasets/nkowaokwu/ibo-dict) | CC-BY-4.0 | Nkọwa okwu / IgboAPI contributors |
+| [IgboSynCorp](https://doi.org/10.7910/dvn/yb9fwk) (+ pseudo-transcripts) | CC0-1.0 | University of Ibadan and Afe Babalola University (Lacuna Fund) |
+| [FLEURS](https://huggingface.co/datasets/google/fleurs) | CC-BY-4.0 | Google (Conneau et al., 2022) |
+| [BibleTTS](https://masakhane-io.github.io/bibleTTS/) (Yoruba, Hausa) | CC-BY-SA-4.0 | Meyer et al. (2022) |
+| [OpenSLR SLR70](https://openslr.org/70/), [SLR86](https://openslr.org/86/) | CC-BY-SA-4.0 | Google |
+| synthetic code-switch pairs (concatenated clips from the sets above) | follows the sources | after Zhang et al. (2019) |
+| base model [Fun-CosyVoice3-0.5B-2512](https://huggingface.co/FunAudioLLM/Fun-CosyVoice3-0.5B-2512) | Apache-2.0 | FunAudioLLM / Alibaba Tongyi Lab |
+| optional [Qwen3-32B](https://huggingface.co/Qwen/Qwen3-32B) (not bundled; code-switch step only) | Apache-2.0 | Qwen team, Alibaba |
+
+DPO preference pairs are the model's own renders, scored automatically. Excluded on licence grounds: African Voices / WaZoBiaSpeech (cards ban TTS use), NaijaVoices (non-commercial), and non-commercial TTS weights.
+
+## Licence
+
+- **Model weights, voice prompts and samples** (`checkpoints/`, `prompts/`, `samples/`): **[CC-BY-SA-4.0](LICENSE)**. Commercial use is allowed; credit Modular and the datasets above; derivatives of the weights must be shared under CC-BY-SA-4.0.
+- **Code** (`*.py`, `frontend/`, `code/`, `settings.json`, `config.json`): **[Apache-2.0](LICENSE-CODE)**.
+- Fun-CosyVoice3-0.5B-2512, byt5-small and Qwen3 are Apache-2.0; their notices apply to the parts they contribute.
+
+## Citation
+
+```bibtex
+@misc{dynamicaccentpro2026,
+  title  = {Dynamic Accent Pro v1.1: prompt-controlled code-switching TTS for Nigerian languages},
+  author = {Modular},
+  year   = {2026},
+  url    = {https://huggingface.co/Modularcomputing/dynamic-accent-pro-v1.1}
+}
+```

checkpoints/flash/diacritics_byt5/added_tokens.json

@@ -0,0 +1,127 @@
+{
+  "<extra_id_0>": 259,
+  "<extra_id_100>": 359,
+  "<extra_id_101>": 360,
+  "<extra_id_102>": 361,
+  "<extra_id_103>": 362,
+  "<extra_id_104>": 363,
+  "<extra_id_105>": 364,
+  "<extra_id_106>": 365,
+  "<extra_id_107>": 366,
+  "<extra_id_108>": 367,
+  "<extra_id_109>": 368,
+  "<extra_id_10>": 269,
+  "<extra_id_110>": 369,
+  "<extra_id_111>": 370,
+  "<extra_id_112>": 371,
+  "<extra_id_113>": 372,
+  "<extra_id_114>": 373,
+  "<extra_id_115>": 374,
+  "<extra_id_116>": 375,
+  "<extra_id_117>": 376,
+  "<extra_id_118>": 377,
+  "<extra_id_119>": 378,
+  "<extra_id_11>": 270,
+  "<extra_id_120>": 379,
+  "<extra_id_121>": 380,
+  "<extra_id_122>": 381,
+  "<extra_id_123>": 382,
+  "<extra_id_124>": 383,
+  "<extra_id_12>": 271,
+  "<extra_id_13>": 272,
+  "<extra_id_14>": 273,
+  "<extra_id_15>": 274,
+  "<extra_id_16>": 275,
+  "<extra_id_17>": 276,
+  "<extra_id_18>": 277,
+  "<extra_id_19>": 278,
+  "<extra_id_1>": 260,
+  "<extra_id_20>": 279,
+  "<extra_id_21>": 280,
+  "<extra_id_22>": 281,
+  "<extra_id_23>": 282,
+  "<extra_id_24>": 283,
+  "<extra_id_25>": 284,
+  "<extra_id_26>": 285,
+  "<extra_id_27>": 286,
+  "<extra_id_28>": 287,
+  "<extra_id_29>": 288,
+  "<extra_id_2>": 261,
+  "<extra_id_30>": 289,
+  "<extra_id_31>": 290,
+  "<extra_id_32>": 291,
+  "<extra_id_33>": 292,
+  "<extra_id_34>": 293,
+  "<extra_id_35>": 294,
+  "<extra_id_36>": 295,
+  "<extra_id_37>": 296,
+  "<extra_id_38>": 297,
+  "<extra_id_39>": 298,
+  "<extra_id_3>": 262,
+  "<extra_id_40>": 299,
+  "<extra_id_41>": 300,
+  "<extra_id_42>": 301,
+  "<extra_id_43>": 302,
+  "<extra_id_44>": 303,
+  "<extra_id_45>": 304,
+  "<extra_id_46>": 305,
+  "<extra_id_47>": 306,
+  "<extra_id_48>": 307,
+  "<extra_id_49>": 308,
+  "<extra_id_4>": 263,
+  "<extra_id_50>": 309,
+  "<extra_id_51>": 310,
+  "<extra_id_52>": 311,
+  "<extra_id_53>": 312,
+  "<extra_id_54>": 313,
+  "<extra_id_55>": 314,
+  "<extra_id_56>": 315,
+  "<extra_id_57>": 316,
+  "<extra_id_58>": 317,
+  "<extra_id_59>": 318,
+  "<extra_id_5>": 264,
+  "<extra_id_60>": 319,
+  "<extra_id_61>": 320,
+  "<extra_id_62>": 321,
+  "<extra_id_63>": 322,
+  "<extra_id_64>": 323,
+  "<extra_id_65>": 324,
+  "<extra_id_66>": 325,
+  "<extra_id_67>": 326,
+  "<extra_id_68>": 327,
+  "<extra_id_69>": 328,
+  "<extra_id_6>": 265,
+  "<extra_id_70>": 329,
+  "<extra_id_71>": 330,
+  "<extra_id_72>": 331,
+  "<extra_id_73>": 332,
+  "<extra_id_74>": 333,
+  "<extra_id_75>": 334,
+  "<extra_id_76>": 335,
+  "<extra_id_77>": 336,
+  "<extra_id_78>": 337,
+  "<extra_id_79>": 338,
+  "<extra_id_7>": 266,
+  "<extra_id_80>": 339,
+  "<extra_id_81>": 340,
+  "<extra_id_82>": 341,
+  "<extra_id_83>": 342,
+  "<extra_id_84>": 343,
+  "<extra_id_85>": 344,
+  "<extra_id_86>": 345,
+  "<extra_id_87>": 346,
+  "<extra_id_88>": 347,
+  "<extra_id_89>": 348,
+  "<extra_id_8>": 267,
+  "<extra_id_90>": 349,
+  "<extra_id_91>": 350,
+  "<extra_id_92>": 351,
+  "<extra_id_93>": 352,
+  "<extra_id_94>": 353,
+  "<extra_id_95>": 354,
+  "<extra_id_96>": 355,
+  "<extra_id_97>": 356,
+  "<extra_id_98>": 357,
+  "<extra_id_99>": 358,
+  "<extra_id_9>": 268
+}

checkpoints/flash/diacritics_byt5/config.json

@@ -0,0 +1,32 @@
+{
+  "architectures": [
+    "T5ForConditionalGeneration"
+  ],
+  "classifier_dropout": 0.0,
+  "d_ff": 3584,
+  "d_kv": 64,
+  "d_model": 1472,
+  "decoder_start_token_id": 0,
+  "dense_act_fn": "gelu_new",
+  "dropout_rate": 0.1,
+  "eos_token_id": 1,
+  "feed_forward_proj": "gated-gelu",
+  "gradient_checkpointing": false,
+  "initializer_factor": 1.0,
+  "is_encoder_decoder": true,
+  "is_gated_act": true,
+  "layer_norm_epsilon": 1e-06,
+  "model_type": "t5",
+  "num_decoder_layers": 4,
+  "num_heads": 6,
+  "num_layers": 12,
+  "pad_token_id": 0,
+  "relative_attention_max_distance": 128,
+  "relative_attention_num_buckets": 32,
+  "tie_word_embeddings": false,
+  "tokenizer_class": "ByT5Tokenizer",
+  "torch_dtype": "float32",
+  "transformers_version": "4.51.3",
+  "use_cache": true,
+  "vocab_size": 384
+}

checkpoints/flash/diacritics_byt5/generation_config.json

@@ -0,0 +1,7 @@
+{
+  "_from_model_config": true,
+  "decoder_start_token_id": 0,
+  "eos_token_id": 1,
+  "pad_token_id": 0,
+  "transformers_version": "4.51.3"
+}

checkpoints/flash/diacritics_byt5/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27c2f5f06306a51af9f6107c38aebff2606d7589cd4f870a4478c7b7047f789e
+size 1198571496

checkpoints/flash/diacritics_byt5/special_tokens_map.json

@@ -0,0 +1,150 @@
+{
+  "additional_special_tokens": [
+    "<extra_id_0>",
+    "<extra_id_1>",
+    "<extra_id_2>",
+    "<extra_id_3>",
+    "<extra_id_4>",
+    "<extra_id_5>",
+    "<extra_id_6>",
+    "<extra_id_7>",
+    "<extra_id_8>",
+    "<extra_id_9>",
+    "<extra_id_10>",
+    "<extra_id_11>",
+    "<extra_id_12>",
+    "<extra_id_13>",
+    "<extra_id_14>",
+    "<extra_id_15>",
+    "<extra_id_16>",
+    "<extra_id_17>",
+    "<extra_id_18>",
+    "<extra_id_19>",
+    "<extra_id_20>",
+    "<extra_id_21>",
+    "<extra_id_22>",
+    "<extra_id_23>",
+    "<extra_id_24>",
+    "<extra_id_25>",
+    "<extra_id_26>",
+    "<extra_id_27>",
+    "<extra_id_28>",
+    "<extra_id_29>",
+    "<extra_id_30>",
+    "<extra_id_31>",
+    "<extra_id_32>",
+    "<extra_id_33>",
+    "<extra_id_34>",
+    "<extra_id_35>",
+    "<extra_id_36>",
+    "<extra_id_37>",
+    "<extra_id_38>",
+    "<extra_id_39>",
+    "<extra_id_40>",
+    "<extra_id_41>",
+    "<extra_id_42>",
+    "<extra_id_43>",
+    "<extra_id_44>",
+    "<extra_id_45>",
+    "<extra_id_46>",
+    "<extra_id_47>",
+    "<extra_id_48>",
+    "<extra_id_49>",
+    "<extra_id_50>",
+    "<extra_id_51>",
+    "<extra_id_52>",
+    "<extra_id_53>",
+    "<extra_id_54>",
+    "<extra_id_55>",
+    "<extra_id_56>",
+    "<extra_id_57>",
+    "<extra_id_58>",
+    "<extra_id_59>",
+    "<extra_id_60>",
+    "<extra_id_61>",
+    "<extra_id_62>",
+    "<extra_id_63>",
+    "<extra_id_64>",
+    "<extra_id_65>",
+    "<extra_id_66>",
+    "<extra_id_67>",
+    "<extra_id_68>",
+    "<extra_id_69>",
+    "<extra_id_70>",
+    "<extra_id_71>",
+    "<extra_id_72>",
+    "<extra_id_73>",
+    "<extra_id_74>",
+    "<extra_id_75>",
+    "<extra_id_76>",
+    "<extra_id_77>",
+    "<extra_id_78>",
+    "<extra_id_79>",
+    "<extra_id_80>",
+    "<extra_id_81>",
+    "<extra_id_82>",
+    "<extra_id_83>",
+    "<extra_id_84>",
+    "<extra_id_85>",
+    "<extra_id_86>",
+    "<extra_id_87>",
+    "<extra_id_88>",
+    "<extra_id_89>",
+    "<extra_id_90>",
+    "<extra_id_91>",
+    "<extra_id_92>",
+    "<extra_id_93>",
+    "<extra_id_94>",
+    "<extra_id_95>",
+    "<extra_id_96>",
+    "<extra_id_97>",
+    "<extra_id_98>",
+    "<extra_id_99>",
+    "<extra_id_100>",
+    "<extra_id_101>",
+    "<extra_id_102>",
+    "<extra_id_103>",
+    "<extra_id_104>",
+    "<extra_id_105>",
+    "<extra_id_106>",
+    "<extra_id_107>",
+    "<extra_id_108>",
+    "<extra_id_109>",
+    "<extra_id_110>",
+    "<extra_id_111>",
+    "<extra_id_112>",
+    "<extra_id_113>",
+    "<extra_id_114>",
+    "<extra_id_115>",
+    "<extra_id_116>",
+    "<extra_id_117>",
+    "<extra_id_118>",
+    "<extra_id_119>",
+    "<extra_id_120>",
+    "<extra_id_121>",
+    "<extra_id_122>",
+    "<extra_id_123>",
+    "<extra_id_124>"
+  ],
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<pad>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  }
+}

checkpoints/flash/diacritics_byt5/tokenizer_config.json

@@ -0,0 +1,1163 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<pad>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "259": {
+      "content": "<extra_id_0>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "260": {
+      "content": "<extra_id_1>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "261": {
+      "content": "<extra_id_2>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "262": {
+      "content": "<extra_id_3>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "263": {
+      "content": "<extra_id_4>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "264": {
+      "content": "<extra_id_5>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "265": {
+      "content": "<extra_id_6>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "266": {
+      "content": "<extra_id_7>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "267": {
+      "content": "<extra_id_8>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "268": {
+      "content": "<extra_id_9>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "269": {
+      "content": "<extra_id_10>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "270": {
+      "content": "<extra_id_11>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "271": {
+      "content": "<extra_id_12>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "272": {
+      "content": "<extra_id_13>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "273": {
+      "content": "<extra_id_14>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "274": {
+      "content": "<extra_id_15>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "275": {
+      "content": "<extra_id_16>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "276": {
+      "content": "<extra_id_17>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "277": {
+      "content": "<extra_id_18>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "278": {
+      "content": "<extra_id_19>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "279": {
+      "content": "<extra_id_20>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "280": {
+      "content": "<extra_id_21>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "281": {
+      "content": "<extra_id_22>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "282": {
+      "content": "<extra_id_23>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "283": {
+      "content": "<extra_id_24>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "284": {
+      "content": "<extra_id_25>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "285": {
+      "content": "<extra_id_26>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "286": {
+      "content": "<extra_id_27>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "287": {
+      "content": "<extra_id_28>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "288": {
+      "content": "<extra_id_29>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "289": {
+      "content": "<extra_id_30>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "290": {
+      "content": "<extra_id_31>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "291": {
+      "content": "<extra_id_32>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "292": {
+      "content": "<extra_id_33>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "293": {
+      "content": "<extra_id_34>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "294": {
+      "content": "<extra_id_35>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "295": {
+      "content": "<extra_id_36>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "296": {
+      "content": "<extra_id_37>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "297": {
+      "content": "<extra_id_38>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "298": {
+      "content": "<extra_id_39>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "299": {
+      "content": "<extra_id_40>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "300": {
+      "content": "<extra_id_41>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "301": {
+      "content": "<extra_id_42>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "302": {
+      "content": "<extra_id_43>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "303": {
+      "content": "<extra_id_44>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "304": {
+      "content": "<extra_id_45>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "305": {
+      "content": "<extra_id_46>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "306": {
+      "content": "<extra_id_47>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "307": {
+      "content": "<extra_id_48>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "308": {
+      "content": "<extra_id_49>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "309": {
+      "content": "<extra_id_50>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "310": {
+      "content": "<extra_id_51>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "311": {
+      "content": "<extra_id_52>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "312": {
+      "content": "<extra_id_53>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "313": {
+      "content": "<extra_id_54>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "314": {
+      "content": "<extra_id_55>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "315": {
+      "content": "<extra_id_56>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "316": {
+      "content": "<extra_id_57>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "317": {
+      "content": "<extra_id_58>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "318": {
+      "content": "<extra_id_59>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "319": {
+      "content": "<extra_id_60>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "320": {
+      "content": "<extra_id_61>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "321": {
+      "content": "<extra_id_62>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "322": {
+      "content": "<extra_id_63>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "323": {
+      "content": "<extra_id_64>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "324": {
+      "content": "<extra_id_65>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "325": {
+      "content": "<extra_id_66>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "326": {
+      "content": "<extra_id_67>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "327": {
+      "content": "<extra_id_68>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "328": {
+      "content": "<extra_id_69>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "329": {
+      "content": "<extra_id_70>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "330": {
+      "content": "<extra_id_71>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "331": {
+      "content": "<extra_id_72>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "332": {
+      "content": "<extra_id_73>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "333": {
+      "content": "<extra_id_74>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "334": {
+      "content": "<extra_id_75>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "335": {
+      "content": "<extra_id_76>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "336": {
+      "content": "<extra_id_77>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "337": {
+      "content": "<extra_id_78>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "338": {
+      "content": "<extra_id_79>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "339": {
+      "content": "<extra_id_80>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "340": {
+      "content": "<extra_id_81>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "341": {
+      "content": "<extra_id_82>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "342": {
+      "content": "<extra_id_83>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "343": {
+      "content": "<extra_id_84>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "344": {
+      "content": "<extra_id_85>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "345": {
+      "content": "<extra_id_86>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "346": {
+      "content": "<extra_id_87>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "347": {
+      "content": "<extra_id_88>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "348": {
+      "content": "<extra_id_89>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "349": {
+      "content": "<extra_id_90>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "350": {
+      "content": "<extra_id_91>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "351": {
+      "content": "<extra_id_92>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "352": {
+      "content": "<extra_id_93>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "353": {
+      "content": "<extra_id_94>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "354": {
+      "content": "<extra_id_95>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "355": {
+      "content": "<extra_id_96>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "356": {
+      "content": "<extra_id_97>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "357": {
+      "content": "<extra_id_98>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "358": {
+      "content": "<extra_id_99>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "359": {
+      "content": "<extra_id_100>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "360": {
+      "content": "<extra_id_101>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "361": {
+      "content": "<extra_id_102>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "362": {
+      "content": "<extra_id_103>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "363": {
+      "content": "<extra_id_104>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "364": {
+      "content": "<extra_id_105>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "365": {
+      "content": "<extra_id_106>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "366": {
+      "content": "<extra_id_107>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "367": {
+      "content": "<extra_id_108>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "368": {
+      "content": "<extra_id_109>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "369": {
+      "content": "<extra_id_110>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "370": {
+      "content": "<extra_id_111>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "371": {
+      "content": "<extra_id_112>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "372": {
+      "content": "<extra_id_113>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "373": {
+      "content": "<extra_id_114>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "374": {
+      "content": "<extra_id_115>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "375": {
+      "content": "<extra_id_116>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "376": {
+      "content": "<extra_id_117>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "377": {
+      "content": "<extra_id_118>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "378": {
+      "content": "<extra_id_119>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "379": {
+      "content": "<extra_id_120>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "380": {
+      "content": "<extra_id_121>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "381": {
+      "content": "<extra_id_122>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "382": {
+      "content": "<extra_id_123>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "383": {
+      "content": "<extra_id_124>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "additional_special_tokens": [
+    "<extra_id_0>",
+    "<extra_id_1>",
+    "<extra_id_2>",
+    "<extra_id_3>",
+    "<extra_id_4>",
+    "<extra_id_5>",
+    "<extra_id_6>",
+    "<extra_id_7>",
+    "<extra_id_8>",
+    "<extra_id_9>",
+    "<extra_id_10>",
+    "<extra_id_11>",
+    "<extra_id_12>",
+    "<extra_id_13>",
+    "<extra_id_14>",
+    "<extra_id_15>",
+    "<extra_id_16>",
+    "<extra_id_17>",
+    "<extra_id_18>",
+    "<extra_id_19>",
+    "<extra_id_20>",
+    "<extra_id_21>",
+    "<extra_id_22>",
+    "<extra_id_23>",
+    "<extra_id_24>",
+    "<extra_id_25>",
+    "<extra_id_26>",
+    "<extra_id_27>",
+    "<extra_id_28>",
+    "<extra_id_29>",
+    "<extra_id_30>",
+    "<extra_id_31>",
+    "<extra_id_32>",
+    "<extra_id_33>",
+    "<extra_id_34>",
+    "<extra_id_35>",
+    "<extra_id_36>",
+    "<extra_id_37>",
+    "<extra_id_38>",
+    "<extra_id_39>",
+    "<extra_id_40>",
+    "<extra_id_41>",
+    "<extra_id_42>",
+    "<extra_id_43>",
+    "<extra_id_44>",
+    "<extra_id_45>",
+    "<extra_id_46>",
+    "<extra_id_47>",
+    "<extra_id_48>",
+    "<extra_id_49>",
+    "<extra_id_50>",
+    "<extra_id_51>",
+    "<extra_id_52>",
+    "<extra_id_53>",
+    "<extra_id_54>",
+    "<extra_id_55>",
+    "<extra_id_56>",
+    "<extra_id_57>",
+    "<extra_id_58>",
+    "<extra_id_59>",
+    "<extra_id_60>",
+    "<extra_id_61>",
+    "<extra_id_62>",
+    "<extra_id_63>",
+    "<extra_id_64>",
+    "<extra_id_65>",
+    "<extra_id_66>",
+    "<extra_id_67>",
+    "<extra_id_68>",
+    "<extra_id_69>",
+    "<extra_id_70>",
+    "<extra_id_71>",
+    "<extra_id_72>",
+    "<extra_id_73>",
+    "<extra_id_74>",
+    "<extra_id_75>",
+    "<extra_id_76>",
+    "<extra_id_77>",
+    "<extra_id_78>",
+    "<extra_id_79>",
+    "<extra_id_80>",
+    "<extra_id_81>",
+    "<extra_id_82>",
+    "<extra_id_83>",
+    "<extra_id_84>",
+    "<extra_id_85>",
+    "<extra_id_86>",
+    "<extra_id_87>",
+    "<extra_id_88>",
+    "<extra_id_89>",
+    "<extra_id_90>",
+    "<extra_id_91>",
+    "<extra_id_92>",
+    "<extra_id_93>",
+    "<extra_id_94>",
+    "<extra_id_95>",
+    "<extra_id_96>",
+    "<extra_id_97>",
+    "<extra_id_98>",
+    "<extra_id_99>",
+    "<extra_id_100>",
+    "<extra_id_101>",
+    "<extra_id_102>",
+    "<extra_id_103>",
+    "<extra_id_104>",
+    "<extra_id_105>",
+    "<extra_id_106>",
+    "<extra_id_107>",
+    "<extra_id_108>",
+    "<extra_id_109>",
+    "<extra_id_110>",
+    "<extra_id_111>",
+    "<extra_id_112>",
+    "<extra_id_113>",
+    "<extra_id_114>",
+    "<extra_id_115>",
+    "<extra_id_116>",
+    "<extra_id_117>",
+    "<extra_id_118>",
+    "<extra_id_119>",
+    "<extra_id_120>",
+    "<extra_id_121>",
+    "<extra_id_122>",
+    "<extra_id_123>",
+    "<extra_id_124>"
+  ],
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "</s>",
+  "extra_ids": 0,
+  "extra_special_tokens": {},
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<pad>",
+  "tokenizer_class": "ByT5Tokenizer",
+  "unk_token": "<unk>"
+}

checkpoints/flash/flash_dpo/args.json

@@ -0,0 +1 @@
+{"cmd": "train", "lm": "/home/dev/flash/runs/flash_lm/best.pt", "out": "/home/dev/flash/runs/flash_dpo", "shard": "0/1", "k": 4, "lr": 1e-06, "beta": 0.1, "sft": 0.1, "bs": 8, "epochs": 2}

checkpoints/flash/flash_dpo/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f59a6fc0dacc331844cf8b513ec99e4d5c75f2583115037c8d38ba9ff7e3a307
+size 2047760470

checkpoints/flash/flash_dpo/config.json

@@ -0,0 +1,9 @@
+{
+ "engine": "cosyvoice3",
+ "base": "FunAudioLLM/Fun-CosyVoice3-0.5B-2512",
+ "rate": "normal",
+ "sampler": "silexcap",
+ "one_pass": true,
+ "sha256_best_pt": "f59a6fc0dacc331844cf8b513ec99e4d5c75f2583115037c8d38ba9ff7e3a307",
+ "training": "Flash SFT (CV3 LM, Phase 3 licensed manifest re-weighted + IgboSynCorp pseudo-transcripts) then DPO: 1,206 preference pairs, 286 steps, beta 0.1, lr 1e-6, val pref-acc 0.65"
+}

checkpoints/flash/flash_dpo/log.jsonl

@@ -0,0 +1,31 @@
+{"step": 0, "val": {"acc": 0.0, "margin": 0.0}}
+{"step": 10, "of": 286, "loss": 0.9068, "acc": 0.625, "margin": 0.046, "gn": 57.21, "min": 0.1}
+{"step": 20, "of": 286, "loss": 0.9388, "acc": 0.5, "margin": -0.002, "gn": 66.55, "min": 0.1}
+{"step": 30, "of": 286, "loss": 0.9699, "acc": 0.375, "margin": -0.035, "gn": 61.96, "min": 0.2}
+{"step": 40, "of": 286, "loss": 0.938, "acc": 0.375, "margin": 0.011, "gn": 63.67, "min": 0.3}
+{"step": 50, "of": 286, "loss": 0.8633, "acc": 0.875, "margin": 0.15, "gn": 52.25, "min": 0.3}
+{"step": 60, "of": 286, "loss": 0.939, "acc": 0.625, "margin": 0.002, "gn": 63.83, "min": 0.4}
+{"step": 70, "of": 286, "loss": 0.8483, "acc": 0.75, "margin": 0.189, "gn": 69.48, "min": 0.4}
+{"step": 80, "of": 286, "loss": 1.0202, "acc": 0.375, "margin": -0.139, "gn": 80.15, "min": 0.5}
+{"step": 90, "of": 286, "loss": 0.8866, "acc": 0.625, "margin": 0.142, "gn": 59.47, "min": 0.5}
+{"step": 100, "of": 286, "loss": 0.8947, "acc": 0.625, "margin": 0.134, "gn": 60.78, "min": 0.6}
+{"step": 110, "of": 286, "loss": 0.9459, "acc": 0.5, "margin": 0.027, "gn": 66.75, "min": 0.6}
+{"step": 120, "of": 286, "loss": 1.0125, "acc": 0.375, "margin": -0.11, "gn": 65.48, "min": 0.7}
+{"step": 130, "of": 286, "loss": 0.8009, "acc": 0.75, "margin": 0.365, "gn": 50.92, "min": 0.8}
+{"step": 140, "of": 286, "loss": 0.8328, "acc": 0.75, "margin": 0.277, "gn": 60.21, "min": 0.8}
+{"epoch": 1, "step": 143, "val": {"acc": 0.6, "margin": 0.15548671048794252}}
+{"step": 150, "of": 286, "loss": 0.5242, "acc": 1.0, "margin": 1.345, "gn": 31.71, "min": 0.9}
+{"step": 160, "of": 286, "loss": 0.476, "acc": 1.0, "margin": 1.509, "gn": 28.95, "min": 0.9}
+{"step": 170, "of": 286, "loss": 0.5501, "acc": 1.0, "margin": 1.171, "gn": 29.98, "min": 1.0}
+{"step": 180, "of": 286, "loss": 0.474, "acc": 1.0, "margin": 1.492, "gn": 26.95, "min": 1.0}
+{"step": 190, "of": 286, "loss": 0.5711, "acc": 1.0, "margin": 1.032, "gn": 34.13, "min": 1.1}
+{"step": 200, "of": 286, "loss": 0.5283, "acc": 1.0, "margin": 1.181, "gn": 32.39, "min": 1.1}
+{"step": 210, "of": 286, "loss": 0.6212, "acc": 0.875, "margin": 0.86, "gn": 36.1, "min": 1.2}
+{"step": 220, "of": 286, "loss": 0.5229, "acc": 1.0, "margin": 1.227, "gn": 32.65, "min": 1.2}
+{"step": 230, "of": 286, "loss": 0.5555, "acc": 1.0, "margin": 1.367, "gn": 35.05, "min": 1.3}
+{"step": 240, "of": 286, "loss": 0.5312, "acc": 1.0, "margin": 1.314, "gn": 36.6, "min": 1.3}
+{"step": 250, "of": 286, "loss": 0.493, "acc": 1.0, "margin": 1.513, "gn": 28.32, "min": 1.3}
+{"step": 260, "of": 286, "loss": 0.5076, "acc": 1.0, "margin": 1.31, "gn": 25.17, "min": 1.4}
+{"step": 270, "of": 286, "loss": 0.434, "acc": 1.0, "margin": 1.739, "gn": 23.64, "min": 1.4}
+{"step": 280, "of": 286, "loss": 0.4263, "acc": 1.0, "margin": 1.907, "gn": 24.99, "min": 1.5}
+{"epoch": 2, "step": 286, "val": {"acc": 0.65, "margin": 0.17853533582141}}

checkpoints/pro/flash_instruct/args.json

@@ -0,0 +1 @@
+{"cmd": "train", "lm": "/home/dev/fi/run/best.pt", "out": "/home/dev/fi/run_dpo", "shard": "0/1", "k": 4, "lr": 1e-06, "beta": 0.1, "sft": 0.1, "bs": 8, "epochs": 2}

checkpoints/pro/flash_instruct/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87c3a7e9a806e89cf1b77cff78989ebe63938016f5d8066cf673d350c4cab3db
+size 2047789708

checkpoints/pro/flash_instruct/config.json

@@ -0,0 +1,14 @@
+{
+ "engine": "cosyvoice3",
+ "base": "FunAudioLLM/Fun-CosyVoice3-0.5B-2512",
+ "rate": "normal",
+ "sampler": "silexcap",
+ "one_pass": true,
+ "instruct": true,
+ "cfg": 2.0,
+ "text_pauses": true,
+ "sha256_best_pt": "87c3a7e9a806e89cf1b77cff78989ebe63938016f5d8066cf673d350c4cab3db",
+ "autoresearch_artifact": "art-dbr28 (private)",
+ "training": "Flash-DPO LM -> Flash-Instruct SFT (3,000 steps, ~100.9k licensed clips with audio-derived pace/pause/energy labels, natural-language instruction in the CosyVoice3 system-prompt slot, 18% default-prompt items, pause/energy control embeddings) -> DPO polish (700 prompts x 4 samples, 564 preference pairs, reward = CER + pace and pause match to native + clipped-ending penalty + small UTMOS guard; 134 steps, beta 0.1, lr 1e-6, SFT weight 0.1; final step kept, val pref-acc 0.61 (0.75 after epoch 1, 28-pair val set))",
+ "data": "licensed only (no African Voices / WaZoBiaSpeech, no NaijaVoices)"
+}

checkpoints/pro/flash_instruct/log.jsonl

@@ -0,0 +1,16 @@
+{"step": 0, "val": {"acc": 0.0, "margin": 0.0}}
+{"step": 10, "of": 134, "loss": 0.9194, "acc": 0.625, "margin": 0.023, "gn": 64.85, "min": 0.1}
+{"step": 20, "of": 134, "loss": 0.9342, "acc": 0.875, "margin": 0.019, "gn": 75.36, "min": 0.1}
+{"step": 30, "of": 134, "loss": 0.8986, "acc": 0.5, "margin": 0.06, "gn": 64.13, "min": 0.2}
+{"step": 40, "of": 134, "loss": 0.9182, "acc": 0.625, "margin": 0.03, "gn": 83.13, "min": 0.2}
+{"step": 50, "of": 134, "loss": 0.9765, "acc": 0.375, "margin": -0.053, "gn": 77.84, "min": 0.3}
+{"step": 60, "of": 134, "loss": 0.8475, "acc": 0.875, "margin": 0.203, "gn": 61.06, "min": 0.3}
+{"epoch": 1, "step": 67, "val": {"acc": 0.75, "margin": 0.12087846860023481}}
+{"step": 70, "of": 134, "loss": 0.5091, "acc": 1.0, "margin": 1.357, "gn": 38.83, "min": 0.4}
+{"step": 80, "of": 134, "loss": 0.4715, "acc": 1.0, "margin": 1.605, "gn": 27.66, "min": 0.5}
+{"step": 90, "of": 134, "loss": 0.5161, "acc": 1.0, "margin": 1.419, "gn": 33.8, "min": 0.5}
+{"step": 100, "of": 134, "loss": 0.4414, "acc": 1.0, "margin": 1.709, "gn": 27.54, "min": 0.5}
+{"step": 110, "of": 134, "loss": 0.5218, "acc": 1.0, "margin": 1.279, "gn": 32.5, "min": 0.6}
+{"step": 120, "of": 134, "loss": 0.4836, "acc": 1.0, "margin": 1.426, "gn": 34.52, "min": 0.6}
+{"step": 130, "of": 134, "loss": 0.5242, "acc": 1.0, "margin": 1.501, "gn": 33.22, "min": 0.7}
+{"epoch": 2, "step": 134, "val": {"acc": 0.6071428571428571, "margin": 0.09966237439740715}}

code/da/data.py

@@ -0,0 +1,95 @@
+"""Arm A data: memmapped Vocos mels + byte tokens with per-token language ids; frame-budget bucketing.
+Beta-binomial alignment priors are computed in DataLoader workers."""
+import json, os, random
+import numpy as np
+import torch
+from torch.utils.data import Dataset, Sampler
+
+from .text import encode, LANG2ID
+from .model import beta_binomial_prior
+
+N_MELS = 100
+
+
+def load_meta(root, datasets, split="train", max_frames=1400, max_tokens=420):
+    items, mm = [], {}
+    for ds in datasets:
+        p = f"{root}/{ds}/meta.jsonl"
+        if not os.path.exists(p) or os.path.getsize(p) == 0:
+            continue
+        mm[ds] = np.memmap(f"{root}/{ds}/mels.f16", dtype=np.float16, mode="r").reshape(-1, N_MELS)
+        for l in open(p, encoding="utf-8"):
+            m = json.loads(l)
+            if m["split"] != split or m["nf"] > max_frames:
+                continue
+            if len(m["text"].encode("utf-8")) + 2 > max_tokens:
+                continue
+            items.append(m)
+    return items, mm
+
+
+class TTSData(Dataset):
+    def __init__(self, items, mm, spk2id):
+        self.items, self.mm, self.spk2id = items, mm, spk2id
+
+    def __len__(self):
+        return len(self.items)
+
+    def __getitem__(self, i):
+        m = self.items[i]
+        mel = np.asarray(self.mm[m["ds"]][m["off"]: m["off"] + m["nf"]], dtype=np.float32)
+        tok, _ = encode(f"<{m['lang']}>{m['text']}</{m['lang']}>")
+        lang = [LANG2ID[m["lang"]]] * len(tok)
+        return dict(tok=tok, lang=lang, mel=mel, spk=self.spk2id[m["spk"]], id=m["id"])
+
+
+def collate(batch):
+    B = len(batch)
+    N = max(len(b["tok"]) for b in batch)
+    T = max(len(b["mel"]) for b in batch)
+    tok = torch.zeros(B, N, dtype=torch.long)
+    lang = torch.zeros(B, N, dtype=torch.long)
+    mel = torch.zeros(B, T, N_MELS)
+    prior = torch.full((B, T, N), -1e4)
+    tl, ml = torch.zeros(B, dtype=torch.long), torch.zeros(B, dtype=torch.long)
+    for i, b in enumerate(batch):
+        n, t = len(b["tok"]), len(b["mel"])
+        tok[i, :n] = torch.tensor(b["tok"]); lang[i, :n] = torch.tensor(b["lang"])
+        mel[i, :t] = torch.from_numpy(b["mel"]); tl[i], ml[i] = n, t
+        prior[i, :t, :n] = beta_binomial_prior(n, t)
+    spk = torch.tensor([b["spk"] for b in batch])
+    return dict(tok=tok, lang=lang, tlens=tl, mel=mel, mlens=ml, spk=spk, prior=prior)
+
+
+class FrameBucketSampler(Sampler):
+    """Batches of similar length under a padded-frame budget; dataset weights by repetition."""
+
+    def __init__(self, items, frame_budget=40000, weights=None, seed=0):
+        self.items, self.budget, self.seed, self.epoch = items, frame_budget, seed, 0
+        self.weights = weights or {}
+
+    def _batches(self):
+        rng = random.Random(self.seed + self.epoch)
+        idx = []
+        for i, m in enumerate(self.items):
+            w = self.weights.get(m["ds"], 1.0)
+            idx += [i] * int(w) + ([i] if rng.random() < (w - int(w)) else [])
+        idx.sort(key=lambda i: self.items[i]["nf"] + rng.random() * 30)
+        batches, cur, mx = [], [], 0
+        for i in idx:
+            nf = self.items[i]["nf"]
+            if cur and max(mx, nf) * (len(cur) + 1) > self.budget:
+                batches.append(cur); cur, mx = [], 0
+            cur.append(i); mx = max(mx, nf)
+        if cur:
+            batches.append(cur)
+        rng.shuffle(batches)
+        return batches
+
+    def __iter__(self):
+        b = self._batches()
+        self.epoch += 1
+        return iter(b)
+
+    def __len__(self):
+        return len(self._batches())

code/da/model.py

@@ -0,0 +1,368 @@
+"""Dynamic Accent - Arm A, written from scratch in PyTorch.
+
+Backbone: Parallel Tacotron 2 (Elias et al. 2021, arXiv 2103.14574): non-autoregressive, token durations,
+  differentiable learned upsampling (MLP over start/end offsets -> token->frame weights W), iterative mel loss.
+Multilingual recipe: Zhang et al. 2019 (arXiv 1907.04448): separate speaker + language embeddings,
+  domain-adversarial speaker classifier (gradient reversal) on text-encoder outputs, residual VAE.
+
+Documented deviation (alignment): PT2 trains durations end-to-end with Soft-DTW. Soft-DTW is O(T*N)-sequential and
+too slow for a 2 h smoke budget, so we use the internal unsupervised alignment-learning objective of
+Badlani et al. 2022 ("One TTS Alignment To Rule Them All", arXiv 2108.10447): a small text/mel attention trained with
+a CTC forward-sum loss + beta-binomial prior, hardened with monotonic alignment search (MAS). The hard durations
+supervise the duration predictor and drive the SAME differentiable PT2 upsampler at train time; predicted durations
+drive it at inference. No external aligner is used.
+"""
+import math
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .text import VOCAB, LANGS
+
+N_MELS = 100
+
+
+# ---------------------------------------------------------------- utils
+def seq_mask(lens, maxlen=None):
+    maxlen = maxlen or int(lens.max())
+    return torch.arange(maxlen, device=lens.device)[None] < lens[:, None]   # True = valid
+
+
+def sinusoid(T, d, device):
+    pos = torch.arange(T, device=device).float()[:, None]
+    i = torch.arange(0, d, 2, device=device).float()[None]
+    ang = pos / (10000 ** (i / d))
+    pe = torch.zeros(T, d, device=device)
+    pe[:, 0::2] = torch.sin(ang)
+    pe[:, 1::2] = torch.cos(ang)
+    return pe
+
+
+class GradReverse(torch.autograd.Function):
+    """Gradient reversal. As in Zhang et al. 2019 the reversed gradient sent into the text encoder is clipped
+    (here: its L2 norm is capped at `clip`), which keeps the min-max game from blowing up the encoder."""
+
+    @staticmethod
+    def forward(ctx, x, lam, clip):
+        ctx.lam, ctx.clip = lam, clip
+        return x.view_as(x)
+
+    @staticmethod
+    def backward(ctx, g):
+        g = -ctx.lam * g
+        if ctx.clip is not None:
+            n = g.norm()
+            if n > ctx.clip:
+                g = g * (ctx.clip / (n + 1e-12))
+        return g, None, None
+
+
+def grad_reverse(x, lam=1.0, clip=0.5):
+    return GradReverse.apply(x, lam, clip)
+
+
+class ConvNorm(nn.Module):
+    def __init__(self, cin, cout, k=5, drop=0.1):
+        super().__init__()
+        self.conv = nn.Conv1d(cin, cout, k, padding=k // 2)
+        self.ln = nn.LayerNorm(cout)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x, mask):           # x [B,T,C], mask [B,T]
+        x = x.masked_fill(~mask[..., None], 0)
+        y = self.conv(x.transpose(1, 2)).transpose(1, 2)
+        return self.drop(F.relu(self.ln(y)))
+
+
+class FFTBlock(nn.Module):
+    """Pre-LN self-attention + convolutional feed-forward (FastSpeech/PT2-style lightweight block)."""
+
+    def __init__(self, d, heads=4, ff=4, k=3, drop=0.1):
+        super().__init__()
+        self.ln1 = nn.LayerNorm(d)
+        self.att = nn.MultiheadAttention(d, heads, dropout=drop, batch_first=True)
+        self.ln2 = nn.LayerNorm(d)
+        self.c1 = nn.Conv1d(d, d * ff, k, padding=k // 2)
+        self.c2 = nn.Conv1d(d * ff, d, 1)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x, mask):
+        h = self.ln1(x)
+        a, _ = self.att(h, h, h, key_padding_mask=~mask, need_weights=False)
+        x = x + self.drop(a)
+        h = self.ln2(x).masked_fill(~mask[..., None], 0).transpose(1, 2)
+        h = self.c2(F.gelu(self.c1(h))).transpose(1, 2)
+        x = x + self.drop(h)
+        return x.masked_fill(~mask[..., None], 0)
+
+
+# ---------------------------------------------------------------- modules
+class TextEncoder(nn.Module):
+    def __init__(self, d, n_lang, layers=6):
+        super().__init__()
+        self.emb = nn.Embedding(VOCAB, d, padding_idx=0)
+        self.lang_in = nn.Embedding(n_lang, d)          # per-token language id at the input
+        self.convs = nn.ModuleList([ConvNorm(d, d, 5) for _ in range(3)])
+        self.blocks = nn.ModuleList([FFTBlock(d) for _ in range(layers)])
+
+    def forward(self, tok, lang, mask):
+        x = self.emb(tok) + self.lang_in(lang)
+        for c in self.convs:
+            x = x + c(x, mask)
+        x = x + sinusoid(x.shape[1], x.shape[2], x.device)[None]
+        for b in self.blocks:
+            x = b(x, mask)
+        return x
+
+
+class ResidualVAE(nn.Module):
+    """Global residual (prosody) encoder: mel -> q(z|x); z broadcast to every token (Zhang 2019 / Hsu 2019)."""
+
+    def __init__(self, zdim=16, h=256):
+        super().__init__()
+        self.convs = nn.Sequential(
+            nn.Conv1d(N_MELS, h, 3, padding=1), nn.ReLU(),
+            nn.Conv1d(h, h, 3, stride=2, padding=1), nn.ReLU(),
+            nn.Conv1d(h, h, 3, stride=2, padding=1), nn.ReLU())
+        self.gru = nn.GRU(h, h // 2, batch_first=True, bidirectional=True)
+        self.mu = nn.Linear(h, zdim)
+        self.logvar = nn.Linear(h, zdim)
+
+    def forward(self, mel, mel_lens):
+        h = self.convs(mel.transpose(1, 2)).transpose(1, 2)
+        lens = torch.clamp((mel_lens + 3) // 4, min=1)
+        h, _ = self.gru(h)
+        m = seq_mask(lens, h.shape[1]).float()[..., None]
+        h = (h * m).sum(1) / m.sum(1)
+        mu, lv = self.mu(h), self.logvar(h).clamp(-8, 8)
+        z = mu + torch.randn_like(mu) * torch.exp(0.5 * lv) if self.training else mu
+        kl = 0.5 * (mu.pow(2) + lv.exp() - 1 - lv).sum(-1).mean()
+        return z, kl
+
+
+class Aligner(nn.Module):
+    """Unsupervised text-mel alignment (Badlani et al. 2022)."""
+
+    def __init__(self, d, h=256, temp=0.0005):
+        super().__init__()
+        self.temp = temp
+        self.key = nn.Sequential(nn.Conv1d(d, h * 2, 3, padding=1), nn.ReLU(), nn.Conv1d(h * 2, 80, 1))
+        self.query = nn.Sequential(nn.Conv1d(N_MELS, h * 2, 3, padding=1), nn.ReLU(),
+                                   nn.Conv1d(h * 2, h, 1), nn.ReLU(), nn.Conv1d(h, 80, 1))
+
+    def forward(self, txt, mel, tmask, mmask, prior_log):
+        k = self.key(txt.transpose(1, 2))                         # B,80,N
+        q = self.query(mel.transpose(1, 2))                       # B,80,T
+        q, k = q.float(), k.float()
+        dist = (q.pow(2).sum(1)[:, :, None] + k.pow(2).sum(1)[:, None, :]
+                - 2 * torch.bmm(q.transpose(1, 2), k)).clamp_min(0)        # B,T,N  (memory-light ||q-k||^2)
+        logits = -self.temp * dist
+        logits = logits.masked_fill(~tmask[:, None, :], -1e4)
+        logp = F.log_softmax(logits, -1) + prior_log                # prior in log domain
+        logp = logp.masked_fill(~tmask[:, None, :], -1e4)
+        soft = F.softmax(logp, -1) * mmask[..., None]
+        return logits, logp, soft
+
+
+def forward_sum_loss(logits, tlens, mlens, blank_logprob=-1.0):
+    """CTC forward-sum: every token must be visited monotonically. logits [B,T,N] (pre-softmax, masked)."""
+    B, T, N = logits.shape
+    lp = F.pad(logits, (1, 0), value=blank_logprob)
+    lp = F.log_softmax(lp, -1).transpose(0, 1)                      # T,B,N+1
+    tgt = torch.arange(1, N + 1, device=logits.device)[None].expand(B, N)
+    return F.ctc_loss(lp.float(), tgt, mlens, tlens, blank=0, reduction="mean", zero_infinity=True)
+
+
+def _mas_np(logp, N, T):
+    """Monotonic alignment search on one [T,N] log-prob matrix -> hard [T,N]."""
+    Q = np.full((T, N), -np.inf, dtype=np.float32)
+    Q[0, 0] = logp[0, 0]
+    for t in range(1, T):
+        for n in range(min(N, t + 1)):
+            stay = Q[t - 1, n]
+            move = Q[t - 1, n - 1] if n > 0 else -np.inf
+            Q[t, n] = max(stay, move) + logp[t, n]
+    path = np.zeros((T, N), dtype=np.float32)
+    n = N - 1
+    for t in range(T - 1, -1, -1):
+        path[t, n] = 1
+        if t > 0 and n > 0 and (n == t or Q[t - 1, n - 1] > Q[t - 1, n]):
+            n -= 1
+    return path
+
+
+try:
+    import numba
+
+    _mas_np = numba.njit(cache=True)(_mas_np)  # noqa: F811
+except Exception:  # numba optional (CPU unit tests)
+    pass
+
+
+@torch.no_grad()
+def mas(logp, tlens, mlens):
+    out = torch.zeros_like(logp)
+    lp = logp.float().cpu().numpy()
+    for b in range(lp.shape[0]):
+        T, N = int(mlens[b]), int(tlens[b])
+        out[b, :T, :N] = torch.from_numpy(_mas_np(np.ascontiguousarray(lp[b, :T, :N]), N, T))
+    return out
+
+
+_prior_cache = {}
+
+
+def beta_binomial_prior(N, T, scale=1.0):
+    from scipy.stats import betabinom
+    key = (N, T)
+    if key not in _prior_cache:
+        x = np.arange(N)[None]
+        t = np.arange(1, T + 1)[:, None]
+        pmf = betabinom.pmf(x, N - 1, scale * t, scale * (T + 1 - t))
+        _prior_cache[key] = torch.from_numpy(np.log(pmf + 1e-8)).float()
+        if len(_prior_cache) > 20000:
+            _prior_cache.clear()
+    return _prior_cache[key]
+
+
+def batch_prior(tlens, mlens, N, T, device):
+    p = torch.full((len(tlens), T, N), -1e4)
+    for b in range(len(tlens)):
+        n, t = int(tlens[b]), int(mlens[b])
+        p[b, :t, :n] = beta_binomial_prior(n, t)
+    return p.to(device)
+
+
+class DurationPredictor(nn.Module):
+    def __init__(self, d, h=256):
+        super().__init__()
+        self.convs = nn.ModuleList([ConvNorm(d, h, 3), ConvNorm(h, h, 3), ConvNorm(h, h, 3)])
+        self.out = nn.Linear(h, 1)
+
+    def forward(self, x, mask):
+        for c in self.convs:
+            x = c(x, mask)
+        return self.out(x).squeeze(-1).masked_fill(~mask, 0)       # log(1 + d)
+
+
+class LearnedUpsampler(nn.Module):
+    """PT2 differentiable upsampling: W[t,k] = softmax_k MLP(S_tk, E_tk, h_k);  O = W H + proj(sum_k W C)."""
+
+    def __init__(self, d, hw=16, hc=8):
+        super().__init__()
+        self.se_w = nn.Linear(2, hw)
+        self.h_w = nn.Linear(d, hw)
+        self.w_out = nn.Linear(hw, 1)
+        self.se_c = nn.Linear(2, hc)
+        self.h_c = nn.Linear(d, hc)
+        self.c_out = nn.Linear(hc, d)
+
+    def forward(self, H, dur, tmask, T):
+        dur = dur.masked_fill(~tmask, 0)
+        e = torch.cumsum(dur, 1)
+        s = e - dur
+        t = torch.arange(T, device=H.device).float()[None, :, None] + 0.5
+        S = (t - s[:, None, :]) / 10.0
+        E = (e[:, None, :] - t) / 10.0
+        se = torch.stack([S, E], -1)                                   # B,T,N,2
+        lw = self.w_out(F.silu(self.se_w(se) + self.h_w(H)[:, None])).squeeze(-1)
+        lw = lw.masked_fill(~tmask[:, None, :], -1e4)
+        W = torch.softmax(lw, -1)                                      # B,T,N
+        C = F.silu(self.se_c(se) + self.h_c(H)[:, None])               # B,T,N,hc
+        out = torch.bmm(W, H) + self.c_out(torch.einsum("btn,btnc->btc", W, C))
+        return out, W
+
+
+class MelDecoder(nn.Module):
+    def __init__(self, d, layers=6, n_iter=3):
+        super().__init__()
+        self.blocks = nn.ModuleList([FFTBlock(d) for _ in range(layers)])
+        self.n_iter = n_iter
+        self.outs = nn.ModuleList([nn.Linear(d, N_MELS) for _ in range(n_iter)])
+
+    def forward(self, x, mask):
+        x = x + sinusoid(x.shape[1], x.shape[2], x.device)[None]
+        mels = []
+        L = len(self.blocks)
+        for i, b in enumerate(self.blocks):
+            x = b(x, mask)
+            j = i - (L - self.n_iter)
+            if j >= 0:
+                mels.append(self.outs[j](x))
+        return mels
+
+
+# ---------------------------------------------------------------- full model
+class DynamicAccentTTS(nn.Module):
+    def __init__(self, n_spk, n_lang=len(LANGS), d=384, enc_layers=6, dec_layers=6, spk_dim=128, lang_dim=64,
+                 zdim=16, adv_hidden=256, mel_mean=None, mel_std=None, align_temp=0.0005):
+        super().__init__()
+        self.n_spk = n_spk
+        self.encoder = TextEncoder(d, n_lang, enc_layers)
+        self.spk_emb = nn.Embedding(n_spk, spk_dim)
+        self.lang_out = nn.Embedding(n_lang, lang_dim)                 # per-token, concatenated to encoder outputs
+        self.vae = ResidualVAE(zdim)
+        self.cond = nn.Linear(d + spk_dim + lang_dim + zdim, d)
+        self.adv = nn.Sequential(nn.LayerNorm(d), nn.Linear(d, adv_hidden), nn.ReLU(), nn.Linear(adv_hidden, n_spk))
+        self.aligner = Aligner(d, temp=align_temp)
+        self.dur = DurationPredictor(d)
+        self.up = LearnedUpsampler(d)
+        self.dec_spk = nn.Linear(spk_dim, d)
+        self.decoder = MelDecoder(d, dec_layers)
+        self.register_buffer("mel_mean", torch.tensor(mel_mean if mel_mean is not None else -2.5))
+        self.register_buffer("mel_std", torch.tensor(mel_std if mel_std is not None else 2.2))
+
+    def _cond(self, Ht, spk, lang, z):
+        B, N, _ = Ht.shape
+        s = self.spk_emb(spk)[:, None].expand(B, N, -1)
+        zz = z[:, None].expand(B, N, -1)
+        return self.cond(torch.cat([Ht, s, self.lang_out(lang), zz], -1)), s
+
+    def forward(self, tok, lang, tlens, mel, mlens, spk, step=0, adv_lambda=1.0, bin_start=4000, prior=None):
+        tmask, mmask = seq_mask(tlens, tok.shape[1]), seq_mask(mlens, mel.shape[1])
+        meln = (mel - self.mel_mean) / self.mel_std
+        Ht = self.encoder(tok, lang, tmask)
+        # adversarial speaker classifier on text encodings (Zhang 2019): GRL removes speaker info from text path
+        adv_logits = self.adv(grad_reverse(Ht, adv_lambda))
+        adv_ce = F.cross_entropy(adv_logits[tmask], spk[:, None].expand_as(tok)[tmask])
+        adv_acc = (adv_logits[tmask].argmax(-1) == spk[:, None].expand_as(tok)[tmask]).float().mean()
+        z, kl = self.vae(meln, mlens)
+        H, _ = self._cond(Ht, spk, lang, z)
+        # alignment (internal, unsupervised)
+        if prior is None:
+            prior = batch_prior(tlens, mlens, tok.shape[1], mel.shape[1], tok.device)
+        logits, logp, soft = self.aligner(self.encoder.emb(tok) + Ht.detach(), meln, tmask, mmask, prior)
+        l_fs = forward_sum_loss(logits.masked_fill(~mmask[..., None], -1e4) + prior, tlens, mlens)
+        hard = mas(logp, tlens, mlens)
+        l_bin = -(hard * torch.log(soft.clamp_min(1e-8))).sum() / hard.sum() if step >= bin_start else soft.new_zeros(())
+        dur_t = hard.sum(1)                                            # B,N frames
+        # durations
+        logd = self.dur(H.detach() if step < 1000 else H, tmask)
+        l_dur = F.mse_loss(logd[tmask], torch.log1p(dur_t[tmask]))
+        # upsample with target durations (train) -> decoder
+        up, W = self.up(H, dur_t, tmask, mel.shape[1])
+        x = up + self.dec_spk(self.spk_emb(spk))[:, None]
+        mels = self.decoder(x, mmask)
+        m = mmask[..., None].float()
+        l_mel = sum((F.l1_loss(o, meln, reduction="none") * m).sum() / (m.sum() * N_MELS) for o in mels) / len(mels)
+        return dict(mel=l_mel, dur=l_dur, fs=l_fs, bin=l_bin, kl=kl, adv=adv_ce, adv_acc=adv_acc.detach()), mels[-1]
+
+    @torch.no_grad()
+    def infer(self, tok, lang, spk, pace=1.0, z=None):
+        tlens = torch.full((tok.shape[0],), tok.shape[1], device=tok.device)
+        tmask = seq_mask(tlens, tok.shape[1])
+        Ht = self.encoder(tok, lang, tmask)
+        if z is None:
+            z = torch.zeros(tok.shape[0], self.vae.mu.out_features, device=tok.device)
+        H, _ = self._cond(Ht, spk, lang, z)
+        dur = (torch.expm1(self.dur(H, tmask)).clamp(min=0) * pace).masked_fill(~tmask, 0)
+        T = max(int(dur.sum(1).max().round().item()), 1)
+        up, W = self.up(H, dur, tmask, T)
+        x = up + self.dec_spk(self.spk_emb(spk))[:, None]
+        mel = self.decoder(x, torch.ones(tok.shape[0], T, dtype=torch.bool, device=tok.device))[-1]
+        return mel * self.mel_std + self.mel_mean, dur
+
+
+def count_params(m):
+    return sum(p.numel() for p in m.parameters())

code/da/p2common.py

@@ -0,0 +1,308 @@
+"""Phase 2 shared tools: romanisation for MMS forced alignment, chunked aligner, pause normalisation,
+pause / F0 / Yoruba-tone metrics.  Used by prep2.py (data) and eval2.py (metrics)."""
+import re, unicodedata
+import numpy as np
+
+# ------------------------------------------------------------------ text
+_MAP = {"ọ": "o", "ẹ": "e", "ṣ": "s", "ị": "i", "ụ": "u", "ṅ": "n", "ń": "n", "ǹ": "n", "ḿ": "m", "ɓ": "b", "ɗ": "d",
+        "ƙ": "k", "ƴ": "y", "ŋ": "n", "ɛ": "e", "ɔ": "o", "ß": "s", "æ": "ae", "œ": "oe", "ø": "o", "đ": "d", "ł": "l"}
+TONE_MARK = {"\u0301": 2, "\u0300": 0, "\u0304": 1}          # acute=H, grave=L, macron=M
+SENT_END = set(".?!")
+CLAUSE = set(";:")
+COMMA = set(",")
+_VOW = set("aeiou")
+
+
+def roman_char(c):
+    """one NFC char -> (romanised latin string, tone or None)."""
+    lc = c.lower()
+    if lc in _MAP:
+        return _MAP[lc], None
+    d = unicodedata.normalize("NFD", lc)
+    base = "".join(x for x in d if unicodedata.category(x) != "Mn")
+    tone = None
+    for x in d:
+        if x in TONE_MARK:
+            tone = TONE_MARK[x]
+    base = "".join(_MAP.get(b, b) for b in base)
+    base = "".join(b for b in base if ("a" <= b <= "z") or b == "'")
+    return base, tone
+
+
+def words_for_align(text):
+    """text -> list of dict(word, rom, punct_after, chars=[(rom_char, orig_index, tone)]).
+    Words that romanise to nothing (digits, symbols) are aligned with the '*' star token."""
+    out = []
+    for m in re.finditer(r"\S+", text):
+        w = m.group(0)
+        chars = []
+        for k, c in enumerate(w):
+            r, t = roman_char(c)
+            for j, rc in enumerate(r):
+                chars.append((rc, m.start() + k, t if j == len(r) - 1 else None))
+        trail = re.sub(r"[\w'’]+", "", w[-3:]) if w else ""
+        p = None
+        if any(c in SENT_END for c in trail):
+            p = "sent"
+        elif any(c in CLAUSE for c in trail):
+            p = "clause"
+        elif any(c in COMMA for c in trail):
+            p = "comma"
+        rom = "".join(c[0] for c in chars)
+        out.append(dict(word=w, rom=rom if rom else "*", punct=p, chars=chars))
+    return out
+
+
+# ------------------------------------------------------------------ aligner
+class Aligner:
+    """torchaudio MMS_FA (CC-BY-NC weights, used only as a data tool/judge) with chunked emissions for long audio."""
+
+    def __init__(self, device="cuda"):
+        import torch, torchaudio
+        self.torch = torch
+        self.F = torchaudio.functional
+        b = torchaudio.pipelines.MMS_FA
+        self.model = b.get_model().to(device).eval().half()
+        self.dict = b.get_dict()
+        self.dev = device
+        self.rate = 320                         # samples per emission frame at 16 kHz (20 ms)
+
+    def emission(self, y16, chunk_s=30, ctx_s=2):
+        torch = self.torch
+        sr = 16000
+        x = torch.from_numpy(y16).float().to(self.dev)
+        if len(y16) <= (chunk_s + 2 * ctx_s) * sr:
+            with torch.inference_mode():
+                e, _ = self.model(x[None].half())
+            return e[0].float().log_softmax(-1)
+        outs = []
+        step, ctx = chunk_s * sr, ctx_s * sr
+        nfr_total = len(y16) // self.rate
+        for s in range(0, len(y16), step):
+            a, b = max(0, s - ctx), min(len(y16), s + step + ctx)
+            with torch.inference_mode():
+                e, _ = self.model(x[a:b][None].half())
+            e = e[0].float().log_softmax(-1)
+            f0 = (s - a) // self.rate
+            nfr = min(step, len(y16) - s) // self.rate
+            outs.append(e[f0:f0 + nfr])
+        e = torch.cat(outs, 0)
+        return e[:max(nfr_total, 1)]
+
+    def align(self, y16, words):
+        """-> per word (start_s, end_s, score) and per char spans [(start_s, end_s)], or None on failure."""
+        torch = self.torch
+        em = self.emission(y16)
+        toks, wid = [], []
+        for i, w in enumerate(words):
+            for c in w["rom"]:
+                if c in self.dict:
+                    toks.append(self.dict[c]); wid.append(i)
+        if not toks or len(toks) * 1 > em.shape[0]:
+            return None
+        t = torch.tensor([toks], dtype=torch.int32, device=self.dev)
+        try:
+            ali, sc = self.F.forced_align(em[None], t, blank=0)
+        except Exception:
+            return None
+        ali, sc = ali[0].cpu().numpy(), sc[0].exp().cpu().numpy()
+        # token spans (merge repeats; blank=0)
+        spans, i, k = [], 0, 0
+        T = len(ali)
+        while i < T:
+            if ali[i] == 0:
+                i += 1; continue
+            j = i
+            while j + 1 < T and ali[j + 1] == ali[i] and not (j + 1 < T and False):
+                j += 1
+            spans.append((i, j + 1, float(sc[i:j + 1].mean())))
+            i = j + 1
+        # repeated identical consecutive tokens (e.g. "aa") collapse in the path above only if no blank between;
+        # forced_align always inserts a blank between identical tokens, so len(spans)==len(toks)
+        if len(spans) != len(toks):
+            return None
+        r = self.rate / 16000
+        W = [[None, None, []] for _ in words]
+        chars = [[] for _ in words]
+        for (a, b, s), w in zip(spans, wid):
+            if W[w][0] is None:
+                W[w][0] = a * r
+            W[w][1] = b * r; W[w][2].append(s); chars[w].append((a * r, b * r))
+        res = []
+        for i, (a, b, s) in enumerate(W):
+            if a is None:
+                return None
+            res.append(dict(start=a, end=b, score=float(np.mean(s)), chars=chars[i]))
+        return res
+
+
+# ------------------------------------------------------------------ energy / pauses
+def frame_db(y, sr, hop_s=0.01):
+    hop = int(sr * hop_s)
+    n = max(1, len(y) // hop)
+    fr = y[: n * hop].reshape(n, hop)
+    e = 10 * np.log10((fr.astype(np.float64) ** 2).mean(1) + 1e-10)
+    return e
+
+
+def silence_mask(y, sr, rel_db=-40.0, hop_s=0.01):
+    e = frame_db(y, sr, hop_s)
+    ref = np.percentile(e, 98)
+    return e < ref + rel_db
+
+
+def runs(mask):
+    """-> list of (start, end) index runs where mask is True."""
+    out, i, n = [], 0, len(mask)
+    while i < n:
+        if mask[i]:
+            j = i
+            while j < n and mask[j]:
+                j += 1
+            out.append((i, j)); i = j
+        else:
+            i += 1
+    return out
+
+
+PAUSE_TARGET = {           # (min, max) silence seconds after a word, by the punctuation that follows it
+    "sent": (0.30, 0.60),
+    "clause": (0.20, 0.50),
+    "comma": (0.00, 0.40),
+    None: (0.00, 0.20),
+}
+# profile B (Phase 2 v2): keeps natural phrase breaks where there is no punctuation (the real anchor pauses at
+# ~14% of unpunctuated word boundaries), still removes hesitations; set P2PAUSE=B
+import os as _os
+if _os.environ.get("P2PAUSE") == "B":
+    PAUSE_TARGET = {"sent": (0.35, 0.70), "clause": (0.25, 0.55), "comma": (0.00, 0.50), None: (0.00, 0.35)}
+LEAD_S, TAIL_S = 0.12, 0.18
+
+
+def normalise_pauses(y, sr, words, ali, seg_a, seg_b, sil=None, lo_s=0.0, hi_s=None):
+    """Rebuild one segment [word seg_a .. seg_b] of y: edge silence fixed to LEAD_S/TAIL_S, every inter-word
+    silence clamped to PAUSE_TARGET[punct] (only truly silent frames are removed; silence is inserted, as a
+    copy of the quietest local frames, when a sentence/clause boundary has too little).  -> (y_out, pauses)"""
+    hop = int(0.01 * sr)
+    if sil is None:
+        sil = silence_mask(y, sr)
+    hi_s = len(y) / sr if hi_s is None else hi_s
+    xf = int(0.005 * sr)
+    pieces, pauses = [], []
+    a0 = ali[seg_a]["start"]
+    start = int(max(lo_s, a0 - LEAD_S, 0.0) * sr)
+    cur = start
+    for i in range(seg_a, seg_b):
+        e_i, s_n = ali[i]["end"], ali[i + 1]["start"]
+        f_a, f_b = int(e_i / 0.01), int(s_n / 0.01) + 1
+        # longest silent run inside the gap (with 20 ms guard to the word edges)
+        best = None
+        for ra, rb in runs(sil[f_a:f_b]):
+            if best is None or rb - ra > best[1] - best[0]:
+                best = (ra, rb)
+        lo, hi = PAUSE_TARGET[words[i]["punct"]]
+        if best is None:
+            cur_sil = 0.0; mid = int((e_i + s_n) / 2 * sr)
+        else:
+            ra, rb = (f_a + best[0]) * hop, (f_a + best[1]) * hop
+            cur_sil = (rb - ra) / sr; mid = (ra + rb) // 2
+        if cur_sil > hi and best is not None:            # shrink: cut the middle of the silent run
+            cut = int((cur_sil - hi) * sr)
+            c0 = mid - cut // 2
+            pieces.append(y[cur:c0]); cur = c0 + cut
+            pauses.append(hi)
+        elif cur_sil < lo:                               # insert quiet frames at the quietest point of the gap
+            add = int((lo - cur_sil) * sr)
+            g0, g1 = int(e_i * sr), max(int(s_n * sr), int(e_i * sr) + hop)
+            seg = y[g0:g1]
+            if len(seg) >= hop:
+                k = int(np.argmin(frame_db(seg, sr))) * hop
+                ins_at = g0 + k
+                q = y[ins_at:ins_at + hop]
+            else:
+                ins_at, q = mid, np.zeros(hop, dtype=y.dtype)
+            filler = np.tile(q, add // hop + 1)[:add] * 0.5
+            pieces.append(y[cur:ins_at]); pieces.append(filler); cur = ins_at
+            pauses.append(lo)
+        else:
+            pauses.append(cur_sil)
+    end = min(len(y), int(min(hi_s, ali[seg_b]["end"] + TAIL_S) * sr))
+    pieces.append(y[cur:end])
+    out = np.concatenate([p for p in pieces if len(p)]) if pieces else y[start:end]
+    # pad edges with silence if the source had less than LEAD/TAIL available
+    lead_have = a0 - start / sr
+    if lead_have < LEAD_S - 0.02:
+        out = np.concatenate([np.zeros(int((LEAD_S - lead_have) * sr), out.dtype), out])
+    tail_have = end / sr - ali[seg_b]["end"]
+    if tail_have < TAIL_S - 0.02:
+        out = np.concatenate([out, np.zeros(int((TAIL_S - tail_have) * sr), out.dtype)])
+    # tiny fades at the edges
+    f = min(xf, len(out) // 4)
+    if f > 0:
+        out[:f] *= np.linspace(0, 1, f); out[-f:] *= np.linspace(1, 0, f)
+    return out.astype(np.float32), pauses
+
+
+# ------------------------------------------------------------------ metrics on audio
+def pause_stats(y, sr, min_pause=0.15):
+    """VAD (energy, -40 dB vs 98th pct) pauses: leading/trailing silence and internal pauses >= min_pause."""
+    sil = silence_mask(y, sr)
+    R = runs(sil)
+    n = len(sil)
+    lead = R[0][1] * 0.01 if R and R[0][0] == 0 else 0.0
+    tail = (n - R[-1][0]) * 0.01 if R and R[-1][1] == n else 0.0
+    internal = [(b - a) * 0.01 for a, b in R if a > 0 and b < n and (b - a) * 0.01 >= min_pause]
+    speech = max(1e-3, n * 0.01 - lead - tail)
+    return dict(lead=round(lead, 3), tail=round(tail, 3), pauses=[round(p, 3) for p in internal],
+                n_pauses=len(internal), pause_rate=round(len(internal) / speech, 4),
+                pause_frac=round(sum(internal) / speech, 4), speech_s=round(speech, 3))
+
+
+def f0_track(y16):
+    import pyworld as pw
+    x = y16.astype(np.float64)
+    f0, t = pw.dio(x, 16000, f0_floor=60, f0_ceil=500, frame_period=10)
+    return pw.stonemask(x, f0, t, 16000)
+
+
+def f0_stats(y16):
+    f0 = f0_track(y16)
+    v = f0[f0 > 0]
+    if len(v) < 20:
+        return dict(voiced=float(len(v)), f0_med=None, st_std=None, st_range=None)
+    st = 12 * np.log2(v / np.median(v))
+    d = np.diff(st)
+    return dict(voiced_frac=round(len(v) / len(f0), 3), f0_med=round(float(np.median(v)), 1),
+                st_std=round(float(st.std()), 3), st_range=round(float(np.percentile(st, 95) - np.percentile(st, 5)), 3),
+                st_vel=round(float(np.abs(d[np.abs(d) < 3]).mean()), 4))
+
+
+def tone_pairs(y16, words, ali):
+    """Yoruba tone-direction accuracy: for consecutive tone-bearing vowels whose tones differ, is the sign of the
+    median-F0 change (semitones) the same as the sign of the tone change?  -> (n_pairs, n_correct)"""
+    f0 = f0_track(y16)
+    vals = []
+    for w, a in zip(words, ali):
+        k = 0
+        for (rc, oi, tone), (s, e) in zip([c for c in w["chars"] if c[0] in "abcdefghijklmnopqrstuvwxyz'"], a["chars"]):
+            if rc in _VOW or (rc in "nm" and tone is not None):
+                t = 1 if tone is None else tone
+                fr = f0[int(s / 0.01): int(e / 0.01) + 1]
+                fr = fr[fr > 0]
+                vals.append((t, float(np.median(12 * np.log2(fr))) if len(fr) else None))
+    n = c = 0
+    for (t1, f1), (t2, f2) in zip(vals, vals[1:]):
+        if t1 == t2 or f1 is None or f2 is None:
+            continue
+        n += 1
+        c += int(np.sign(f2 - f1) == np.sign(t2 - t1))
+    return n, c
+
+
+def wasserstein1(a, b):
+    """1-D earth mover's distance between two samples."""
+    if not len(a) or not len(b):
+        return None
+    a, b = np.sort(a), np.sort(b)
+    q = np.linspace(0, 1, 101)
+    return float(np.mean(np.abs(np.quantile(a, q) - np.quantile(b, q))))

code/da/prep2.py

@@ -0,0 +1,259 @@
+"""Phase 2 data prep (H100 node): every source -> MMS forced alignment -> sentence segmentation of long clips ->
+punctuation-consistent pause normalisation -> 24 kHz int16 + meta.  Output ~/data2/<ds>/{pcm24k.i16, meta.jsonl, stats.json}
+
+  python -m da.prep2 waxal bible_hau bible_yor slr86 slr70 fleurs
+"""
+import os, sys, io, json, glob, csv, hashlib, time
+import numpy as np, soundfile as sf, librosa
+from multiprocessing import Pool
+sys.path.insert(0, os.path.expanduser("~/da"))
+from da.p2common import words_for_align, Aligner, normalise_pauses   # noqa: E402
+
+RAW = "/scratch/raw"
+OUT = os.path.expanduser(os.environ.get("P2OUT", "~/data2"))
+OLD = os.path.expanduser("~/data")
+SR = 24000
+BIBLE_HAU_CAP_H = 30.0
+FLOW_OK = {"waxal", "bible_yor", "bible_hau", "slr86", "slr70"}     # 48 kHz studio-ish sources (FLEURS is 16 kHz)
+
+
+def clean_text(t):
+    import unicodedata, re
+    t = unicodedata.normalize("NFC", t or "")
+    t = t.replace("\u2019", "'").replace("\u2018", "'").replace("\u201c", '"').replace("\u201d", '"')
+    return re.sub(r"\s+", " ", t).strip()
+
+
+def hsplit(i):
+    return "val" if int(hashlib.md5(i.encode()).hexdigest(), 16) % 100 == 0 else "train"
+
+
+# ------------------------------------------------------------------ enumerators (yield meta + loader args)
+def items_waxal():
+    import pyarrow.parquet as pq
+    for lang in ["yor", "ibo", "hau", "pcm"]:
+        files = sorted(glob.glob(f"{RAW}/waxal/data/TTS/{lang}/*.parquet"))
+        files = [f for f in files if not os.path.basename(f).startswith("yor_tts")]
+        for f in files:
+            bn = os.path.basename(f)
+            split = "test" if "test" in bn else ("val" if "validation" in bn else "train")
+            pf = pq.ParquetFile(f)
+            for b in pf.iter_batches(batch_size=8):
+                for r in b.to_pylist():
+                    yield dict(id=f"waxal_{lang}_{r['id']}", ds="waxal", lang=lang,
+                               spk=f"waxal_{lang}_{r.get('speaker_id') or 'spk'}", gender=r.get("gender") or "",
+                               split=split, text=r["text"]), ("bytes", r["audio"]["bytes"])
+
+
+FLEURS = {"hau": "ha_ng", "ibo": "ig_ng", "yor": "yo_ng", "eng": "en_us"}
+
+
+def items_fleurs():
+    """raw FLEURS train audio (16 kHz); speaker ids = Phase 1 ECAPA pseudo-speakers from ~/data/fleurs/meta.jsonl"""
+    for l in open(f"{OLD}/fleurs/meta.jsonl", encoding="utf-8"):
+        m = json.loads(l)
+        fn = m["id"].split("_", 2)[2] + ".wav"
+        p = f"{RAW}/fleurs/data/{FLEURS[m['lang']]}/audio/train/{fn}"
+        yield dict(id=m["id"], ds="fleurs", lang=m["lang"], spk=m["spk"], gender=m.get("gender", ""),
+                   split=hsplit(m["id"]), text=m["text"]), ("path", p)
+
+
+def items_slr(num, lang, prefix):
+    for idx in sorted(glob.glob(f"{RAW}/slr{num}/**/line_index.tsv", recursive=True)):
+        d = os.path.dirname(idx)
+        for line in open(idx, encoding="utf-8"):
+            parts = line.rstrip("\n").split("\t")
+            if len(parts) < 2:
+                continue
+            fid, text = parts[0].strip(), parts[-1]
+            p = os.path.join(d, fid + ".wav")
+            if os.path.exists(p):
+                spk = "_".join(fid.split("_")[:2])
+                yield dict(id=f"{prefix}_{fid}", ds=prefix, lang=lang, spk=f"{prefix}_{spk}",
+                           gender="female" if fid[2] == "f" else "male", split=hsplit(fid), text=text), ("path", p)
+
+
+def items_bible(lang_dir, lang, ds, cap_h=None):
+    root = f"{RAW}/bible/{lang_dir}"
+    auds = sorted(glob.glob(f"{root}/**/*.flac", recursive=True) + glob.glob(f"{root}/**/*.wav", recursive=True))
+    if cap_h:   # deterministic random subset of the train split, roughly cap_h hours (verse ~ 9 s on average)
+        auds.sort(key=lambda p: hashlib.md5(p.encode()).hexdigest())
+    tot = 0.0
+    for p in auds:
+        txt = os.path.splitext(p)[0] + ".txt"
+        if not os.path.exists(txt):
+            continue
+        split = "test" if "/test/" in p else ("val" if "/dev/" in p else "train")
+        if cap_h and split == "train":
+            if tot > cap_h * 3600:
+                continue
+            try:
+                tot += sf.info(p).duration
+            except Exception:
+                continue
+        yield dict(id=f"{ds}_{os.path.splitext(os.path.basename(p))[0]}", ds=ds, lang=lang, spk=ds, gender="",
+                   split=split, text=open(txt, encoding="utf-8").read()), ("path", p)
+
+
+def enum(ds):
+    return {"waxal": items_waxal, "fleurs": items_fleurs,
+            "slr86": lambda: items_slr(86, "yor", "slr86"), "slr70": lambda: items_slr(70, "eng", "slr70"),
+            "bible_yor": lambda: items_bible("yoruba", "yor", "bible_yor"),
+            "bible_hau": lambda: items_bible("hausa", "hau", "bible_hau", BIBLE_HAU_CAP_H)}[ds]()
+
+
+# ------------------------------------------------------------------ workers
+def load(arg):
+    meta, src = arg
+    try:
+        if src[0] == "bytes":
+            y, sr = sf.read(io.BytesIO(src[1]), dtype="float32", always_2d=True); y = y.mean(1)
+        elif src[0] == "path":
+            y, sr = sf.read(src[1], dtype="float32", always_2d=True); y = y.mean(1)
+        else:
+            pcm = np.memmap(src[1], dtype=np.int16, mode="r")
+            y, sr = pcm[src[2]:src[2] + src[3]].astype(np.float32) / 32768.0, 16000
+        meta["text"] = clean_text(meta["text"])
+        meta["sr_in"] = int(sr)
+        if not meta["text"] or len(y) < 0.5 * sr:
+            return meta, None, None, "empty"
+        y24 = librosa.resample(y, orig_sr=sr, target_sr=SR, res_type="soxr_hq") if sr != SR else y
+        y16 = librosa.resample(y, orig_sr=sr, target_sr=16000, res_type="soxr_hq") if sr != 16000 else y
+        return meta, y16, y24, None
+    except Exception as e:  # noqa
+        return meta, None, None, f"err:{type(e).__name__}"
+
+
+def plan_segments(words, ali, dur):
+    """word-index ranges [(a, b)] (inclusive).  Short clips: one segment.  Long clips: whole sentences grouped
+    into 3-14 s segments; an over-long sentence is cut at clause/comma marks."""
+    n = len(words)
+    if dur <= 20.0:
+        return [(0, n - 1)]
+    sents, a = [], 0
+    for i, w in enumerate(words):
+        if w["punct"] == "sent" or i == n - 1:
+            sents.append((a, i)); a = i + 1
+    pieces = []
+    for a, b in sents:
+        if ali[b]["end"] - ali[a]["start"] <= 16.0:
+            pieces.append((a, b)); continue
+        s = a
+        for i in range(a, b + 1):
+            if (words[i]["punct"] in ("clause", "comma") and ali[i]["end"] - ali[s]["start"] > 3.0) or i == b:
+                pieces.append((s, i)); s = i + 1
+    segs, cur = [], None
+    for a, b in pieces:
+        if cur is None:
+            cur = [a, b]; continue
+        if ali[b]["end"] - ali[cur[0]]["start"] <= 14.0 and ali[cur[1]]["end"] - ali[cur[0]]["start"] < 4.0:
+            cur[1] = b
+        else:
+            segs.append(tuple(cur)); cur = [a, b]
+    if cur:
+        segs.append(tuple(cur))
+    return segs
+
+
+def post(arg):
+    meta, y24, words, ali = arg
+    out, why = [], {}
+    segs = plan_segments(words, ali, len(y24) / SR)
+    from da.p2common import silence_mask
+    sil = silence_mask(y24, SR)
+    for k, (a, b) in enumerate(segs):
+        sc = float(np.mean([ali[i]["score"] for i in range(a, b + 1)]))
+        maxw = max(ali[i]["end"] - ali[i]["start"] for i in range(a, b + 1))
+        text = " ".join(words[i]["word"] for i in range(a, b + 1))
+        if sc < 0.30:
+            why["low_score"] = why.get("low_score", 0) + 1; continue
+        if maxw > 2.5:
+            why["long_word"] = why.get("long_word", 0) + 1; continue
+        lo = ali[a - 1]["end"] + 0.02 if a > 0 else 0.0
+        hi = ali[b + 1]["start"] - 0.02 if b + 1 < len(ali) else None
+        y, pauses = normalise_pauses(y24, SR, words, ali, a, b, sil=sil, lo_s=lo, hi_s=hi)
+        dur = len(y) / SR
+        cps = len(text) / dur
+        if not (0.8 <= dur <= 20.0):
+            why["dur"] = why.get("dur", 0) + 1; continue
+        if not (4.0 <= cps <= 25.0):
+            why["cps"] = why.get("cps", 0) + 1; continue
+        rms = np.sqrt((y ** 2).mean() + 1e-12)
+        y = y * (0.07 / rms)
+        pk = np.abs(y).max()
+        if pk > 0.99:
+            y = y * (0.99 / pk)
+        m = dict(meta)
+        if len(segs) > 1:
+            m["id"] = f"{meta['id']}_s{k:03d}"; m["src_id"] = meta["id"]; m["longform"] = True
+        m.update(text=text, dur=round(dur, 3), ascore=round(sc, 3), cps=round(cps, 2),
+                 pauses=[round(p, 2) for p in pauses],
+                 puncts=[words[i]["punct"] for i in range(a, b)], flow_ok=meta["ds"] in FLOW_OK)
+        out.append((m, np.clip(y * 32767, -32768, 32767).astype(np.int16)))
+    return out, why
+
+
+def run(ds):
+    od = f"{OUT}/{ds}"
+    os.makedirs(od, exist_ok=True)
+    al = Aligner()
+    stats = dict(src_items=0, src_hours=0.0, kept=0, hours=0.0, rej={}, longform_src=0, longform_hours_in=0.0,
+                 longform_segments=0)
+    t0 = time.time(); off = 0
+    pending = []
+    with open(f"{od}/pcm24k.i16", "wb") as pf, open(f"{od}/meta.jsonl", "w", encoding="utf-8") as jf, \
+            Pool(20) as lp, Pool(6) as pp:
+        def drain(block=False):
+            nonlocal off
+            keep = []
+            for r in pending:
+                if block or r.ready():
+                    segs, why = r.get()
+                    for k, v in why.items():
+                        stats["rej"][k] = stats["rej"].get(k, 0) + v
+                    for m, pcm in segs:
+                        m["off24"] = off; m["n24"] = int(len(pcm))
+                        pf.write(pcm.tobytes()); off += len(pcm)
+                        jf.write(json.dumps(m, ensure_ascii=False) + "\n")
+                        stats["kept"] += 1; stats["hours"] += m["dur"] / 3600
+                        if m.get("longform"):
+                            stats["longform_segments"] += 1
+                else:
+                    keep.append(r)
+            pending[:] = keep
+        import itertools
+        src = enum(ds)
+        if os.environ.get("LIMIT"):
+            src = itertools.islice(src, 0, None, int(os.environ.get("STRIDE", "1")))
+            src = itertools.islice(src, int(os.environ["LIMIT"]))
+        for meta, y16, y24, err in lp.imap(load, src, chunksize=2):
+            stats["src_items"] += 1
+            if err:
+                stats["rej"][err] = stats["rej"].get(err, 0) + 1; continue
+            d = len(y24) / SR
+            stats["src_hours"] += d / 3600
+            if d > 20:
+                stats["longform_src"] += 1; stats["longform_hours_in"] += d / 3600
+            if d > 2400:
+                stats["rej"]["too_long"] = stats["rej"].get("too_long", 0) + 1; continue
+            words = words_for_align(meta["text"])
+            ali = al.align(y16, words) if words else None
+            if ali is None:
+                stats["rej"]["align_fail"] = stats["rej"].get("align_fail", 0) + 1; continue
+            pending.append(pp.apply_async(post, ((meta, y24, words, ali),)))
+            if len(pending) > 64:
+                drain(block=False)
+                while len(pending) > 128:
+                    time.sleep(0.05); drain(block=False)
+            if stats["src_items"] % 2000 == 0:
+                print(ds, stats["src_items"], "kept", stats["kept"], "h", round(stats["hours"], 2),
+                      "rej", stats["rej"], round(time.time() - t0), "s", flush=True)
+        drain(block=True)
+    stats = {k: (round(v, 3) if isinstance(v, float) else v) for k, v in stats.items()}
+    json.dump(stats, open(f"{od}/stats.json", "w"), indent=1)
+    print(ds, "PREP2_DONE", json.dumps(stats), round(time.time() - t0), "s", flush=True)
+
+
+if __name__ == "__main__":
+    for ds in sys.argv[1:]:
+        run(ds)

code/da/s3_2.py

@@ -0,0 +1,130 @@
+"""Phase 2: S3 speech tokens (speech_tokenizer_v2.onnx, CUDA EP) + CAM++ speaker embeddings for ~/data2/<ds>,
+plus code-switched training pairs (ds "cs_pairs").
+
+  python -m da.s3_2 tok waxal fleurs ...        -> s3tok.i32, s3tok.jsonl, campplus.npy
+  python -m da.s3_2 cs 4000                     -> ~/data2/cs_pairs/{pcm24k.i16, meta.jsonl} (+ run tok on it)
+"""
+import os, sys, json, random, hashlib
+import numpy as np, librosa, torch
+from multiprocessing import Pool
+
+D2 = os.path.expanduser(os.environ.get("P2OUT", "~/data2"))
+MD = os.path.expanduser("~/models/CosyVoice2-0.5B")
+_S = {}
+_FB = torch.from_numpy(librosa.filters.mel(sr=16000, n_fft=400, n_mels=128)).float()
+_WIN = torch.hann_window(400)
+
+
+def log_mel_128(a):
+    st = torch.stft(a, 400, 160, window=_WIN, return_complex=True)
+    mag = st[..., :-1].abs() ** 2
+    lm = torch.clamp(_FB @ mag, min=1e-10).log10()
+    lm = torch.maximum(lm, lm.max() - 8.0)
+    return (lm + 4.0) / 4.0
+
+
+def sess(name, gpu):
+    if name not in _S:
+        import onnxruntime as ort
+        torch.set_num_threads(1)
+        o = ort.SessionOptions(); o.intra_op_num_threads = 2; o.inter_op_num_threads = 1
+        prov = ["CUDAExecutionProvider", "CPUExecutionProvider"] if gpu else ["CPUExecutionProvider"]
+        _S[name] = ort.InferenceSession(f"{MD}/{name}", sess_options=o, providers=prov)
+    return _S[name]
+
+
+def work(args):
+    path, off, n = args
+    import torchaudio.compliance.kaldi as kaldi
+    pcm = np.memmap(path, dtype=np.int16, mode="r")
+    y24 = pcm[off:off + n].astype(np.float32) / 32768.0
+    y16 = librosa.resample(y24, orig_sr=24000, target_sr=16000, res_type="soxr_hq")
+    a = torch.from_numpy(y16)
+    f = log_mel_128(a)[None]
+    s = sess("speech_tokenizer_v2.onnx", True)
+    ins = s.get_inputs()
+    tok = s.run(None, {ins[0].name: f.numpy(), ins[1].name: np.array([f.shape[2]], dtype=np.int32)})[0]
+    fb = kaldi.fbank(a[None], num_mel_bins=80, dither=0, sample_frequency=16000)
+    fb = fb - fb.mean(0, keepdim=True)
+    c = sess("campplus.onnx", False)
+    emb = c.run(None, {c.get_inputs()[0].name: fb[None].numpy()})[0].reshape(-1).astype(np.float32)
+    return np.asarray(tok).reshape(-1).astype(np.int32), emb
+
+
+def tok(ds):
+    od = f"{D2}/{ds}"
+    meta = [json.loads(l) for l in open(f"{od}/meta.jsonl", encoding="utf-8")]
+    jobs = [(f"{od}/pcm24k.i16", m["off24"], m["n24"]) for m in meta]
+    toff, embs = 0, []
+    with open(f"{od}/s3tok.i32", "wb") as tf, open(f"{od}/s3tok.jsonl", "w") as jf, Pool(12) as pool:
+        for i, (m, (t, e)) in enumerate(zip(meta, pool.imap(work, jobs, chunksize=4))):
+            tf.write(t.tobytes()); embs.append(e)
+            jf.write(json.dumps({"id": m["id"], "toff": toff, "ntok": int(len(t))}) + "\n")
+            toff += len(t)
+            if i % 5000 == 0:
+                print(ds, i, len(meta), "tok/s", round(len(t) / max(m["dur"], 1e-3), 1), flush=True)
+    np.save(f"{od}/campplus.npy", np.stack(embs))
+    print(ds, "S3_DONE", toff, flush=True)
+
+
+def build_cs(n_pairs=4000, seed=0):
+    """Join two train utterances in different languages (prefer same gender) into one code-switched item.
+    Junction silence follows the first clip's final punctuation (sentence 0.45 s, comma 0.25 s, else 0.20 s)."""
+    rng = random.Random(seed)
+    pools = {}
+    for ds in ["waxal", "slr70", "slr86", "fleurs"]:
+        p = f"{D2}/{ds}/meta.jsonl"
+        if not os.path.exists(p):
+            continue
+        for l in open(p, encoding="utf-8"):
+            m = json.loads(l)
+            if m["split"] != "train" or not (1.0 <= m["dur"] <= 6.5):
+                continue
+            if ds == "fleurs" and m["lang"] != "eng":
+                continue
+            pools.setdefault(m["lang"], []).append(m)
+    langs = sorted(pools)
+    print("cs pools", {l: len(v) for l, v in pools.items()})
+    od = f"{D2}/cs_pairs"; os.makedirs(od, exist_ok=True)
+    mm = {}
+    off = 0
+    with open(f"{od}/pcm24k.i16", "wb") as pf, open(f"{od}/meta.jsonl", "w", encoding="utf-8") as jf:
+        for k in range(n_pairs):
+            l1, l2 = rng.sample(langs, 2)
+            if rng.random() < 0.5 and "eng" in langs and "eng" not in (l1, l2):
+                l2 = "eng"          # English is the most common partner in real Nigerian code-switching
+            a = rng.choice(pools[l1])
+            g = (a.get("gender") or "").lower()[:1]
+            cand = [b for b in rng.sample(pools[l2], min(50, len(pools[l2]))) if (b.get("gender") or "").lower()[:1] == g]
+            b = cand[0] if cand else rng.choice(pools[l2])
+            ys = []
+            for m in (a, b):
+                if m["ds"] not in mm:
+                    mm[m["ds"]] = np.memmap(f"{D2}/{m['ds']}/pcm24k.i16", dtype=np.int16, mode="r")
+                ys.append(np.asarray(mm[m["ds"]][m["off24"]:m["off24"] + m["n24"]]))
+            last = a["text"].rstrip()[-1:]
+            junc = 0.45 if last in ".?!" else (0.25 if last in ",;:" else 0.20)
+            have = 0.18 + 0.12
+            y1 = ys[0]
+            if junc < have:
+                y1 = y1[: len(y1) - int((have - junc) * 24000)]
+                gap = np.zeros(0, np.int16)
+            else:
+                gap = np.zeros(int((junc - have) * 24000), np.int16)
+            y = np.concatenate([y1, gap, ys[1]])
+            text = f"<{l1}>{a['text']}</{l1}> <{l2}>{b['text']}</{l2}>"
+            m = dict(id=f"cs_{k:05d}", ds="cs_pairs", lang="cs", langs=[l1, l2], spk=a["spk"], gender=a.get("gender", ""),
+                     split="train", text=text, dur=round(len(y) / 24000, 3), off24=off, n24=int(len(y)),
+                     src=[a["id"], b["id"]], flow_ok=False)
+            pf.write(y.tobytes()); off += len(y)
+            jf.write(json.dumps(m, ensure_ascii=False) + "\n")
+    print("cs pairs", n_pairs, "hours", round(off / 24000 / 3600, 2), flush=True)
+
+
+if __name__ == "__main__":
+    if sys.argv[1] == "tok":
+        for ds in sys.argv[2:]:
+            tok(ds)
+    elif sys.argv[1] == "cs":
+        build_cs(int(sys.argv[2]))
+        tok("cs_pairs")

code/da/text.py

@@ -0,0 +1,60 @@
+"""Text front-end: Unicode NFC, tone diacritics preserved, UTF-8 byte tokens with per-token language ids.
+
+Code-switched input uses inline tags:  "<yor>Mo fẹ́ lọ sí ọjà</yor> <eng>to buy some bread</eng>"
+Untagged text takes the default language. Each byte inherits the language of the span it is in.
+"""
+import re
+import unicodedata
+
+LANGS = ["eng", "ibo", "hau", "yor", "pcm"]
+LANG2ID = {l: i for i, l in enumerate(LANGS)}
+PAD, BOS, EOS = 0, 1, 2          # byte b -> token b + 3
+VOCAB = 256 + 3
+_TAG = re.compile(r"<(eng|ibo|hau|yor|pcm)>(.*?)</\1>", re.S)
+
+
+def normalize(t: str) -> str:
+    t = unicodedata.normalize("NFC", t)
+    t = t.replace("\u2019", "'").replace("\u2018", "'").replace("\u201c", '"').replace("\u201d", '"')
+    return re.sub(r"\s+", " ", t).strip()
+
+
+def segments(text: str, default_lang: str = "eng"):
+    """-> list of (lang, normalized_text) spans, order preserved."""
+    out, pos = [], 0
+    for m in _TAG.finditer(text):
+        pre = text[pos:m.start()]
+        if pre.strip():
+            out.append((default_lang, pre))
+        out.append((m.group(1), m.group(2)))
+        pos = m.end()
+    if text[pos:].strip():
+        out.append((default_lang, text[pos:]))
+    # keep a single space between spans
+    res = []
+    for i, (l, s) in enumerate(out):
+        s = normalize(s)
+        if not s:
+            continue
+        if res:
+            s = " " + s
+        res.append((l, s))
+    return res
+
+
+def encode(text: str, default_lang: str = "eng"):
+    """-> (token ids, language ids) incl. BOS/EOS. BOS takes the first span's language, EOS the last."""
+    segs = segments(text, default_lang)
+    toks, langs = [BOS], [LANG2ID[segs[0][0]] if segs else LANG2ID[default_lang]]
+    for l, s in segs:
+        b = s.encode("utf-8")
+        toks += [x + 3 for x in b]
+        langs += [LANG2ID[l]] * len(b)
+    toks.append(EOS)
+    langs.append(langs[-1])
+    return toks, langs
+
+
+def plain(text: str) -> str:
+    """Tagged text -> plain text (for ASR references)."""
+    return " ".join(s.strip() for _, s in segments(text))

code/train_b.py

@@ -0,0 +1,353 @@
+"""Arm B: CosyVoice2-0.5B (Apache-2.0) fine-tune with the Zhang et al. 2019 recipe added to its text->speech-token LM.
+
+Additions (new, ours):
+  * per-token language embedding added to the Qwen text-token embeddings (zero-init)
+  * learned speaker embedding inserted as one token AFTER the text, before the task token (zero-init), so text
+    positions cannot see it; speech positions attend to it (anchor-voice conditioning)
+  * domain-adversarial speaker classifier with gradient reversal on the LM hidden states at text positions
+Flow-matching decoder + HiFT vocoder stay frozen; at inference they are prompted with an anchor-voice clip.
+
+  python train_b.py train --out ~/runs/b1 --minutes 30
+  python train_b.py synth --ckpt ~/runs/b1/last.pt --out ~/eval/sys/armB_ft
+  python train_b.py zeroshot --out ~/eval/sys/cosyvoice2_zeroshot      (pretrained model, cross-lingual, no fine-tune)
+"""
+import argparse, inspect, json, math, os, random, sys, time
+import numpy as np, torch, torch.nn as nn, torch.nn.functional as F, soundfile as sf, librosa
+
+HOME = os.path.expanduser("~")
+sys.path[:0] = [f"{HOME}/CosyVoice", f"{HOME}/CosyVoice/third_party/Matcha-TTS"]
+MODEL_DIR = f"{HOME}/models/CosyVoice2-0.5B"
+LANGS = ["eng", "ibo", "hau", "yor", "pcm"]
+L2I = {l: i for i, l in enumerate(LANGS)}
+sys.path.insert(0, f"{HOME}/da")
+from da.text import segments  # noqa: E402
+
+from da.model import grad_reverse  # noqa: E402
+
+
+def _sf_load_wav(wav, target_sr, min_sr=16000):
+    """soundfile replacement for cosyvoice load_wav (torchaudio>=2.9 load needs torchcodec)."""
+    y, sr = sf.read(wav, dtype="float32", always_2d=True)
+    y = y.mean(1)
+    if sr != target_sr:
+        y = librosa.resample(y, orig_sr=sr, target_sr=target_sr)
+    return torch.from_numpy(y)[None]
+
+
+def load_cosy():
+    import cosyvoice.utils.file_utils as fu
+    fu.load_wav = _sf_load_wav
+    import cosyvoice.cli.frontend as cf
+    cf.load_wav = _sf_load_wav
+    from cosyvoice.cli.cosyvoice import CosyVoice2
+    kw = dict(load_jit=False, load_trt=False, fp16=False)
+    sig = inspect.signature(CosyVoice2.__init__).parameters
+    kw = {k: v for k, v in kw.items() if k in sig}
+    return CosyVoice2(MODEL_DIR, **kw)
+
+
+def text_tokens(tok, text, default="eng"):
+    """tagged text -> (qwen ids, per-token lang ids)."""
+    ids, langs = [], []
+    for l, s in segments(text, default):
+        t = tok(s, add_special_tokens=False)["input_ids"]
+        ids += t; langs += [L2I[l]] * len(t)
+    return ids, langs
+
+
+class DALM(nn.Module):
+    def __init__(self, qlm, n_spk, d=896):
+        super().__init__()
+        self.q = qlm                                     # cosyvoice Qwen2LM
+        self.lang_emb = nn.Embedding(len(LANGS), d); nn.init.zeros_(self.lang_emb.weight)
+        self.spk_emb = nn.Embedding(n_spk, d); nn.init.normal_(self.spk_emb.weight, std=0.02)
+        self.adv = nn.Sequential(nn.Linear(d, 256), nn.ReLU(), nn.Linear(256, n_spk))
+        self.V = qlm.speech_token_size
+
+    def embed_text(self, ids, langs):
+        return self.q.llm.model.model.embed_tokens(ids) + self.lang_emb(langs)
+
+    def build(self, ids, langs, spk, speech=None):
+        """one sequence: [sos, text+lang, spk, task, speech...]"""
+        sos = self.q.llm_embedding.weight[self.q.sos][None]
+        task = self.q.llm_embedding.weight[self.q.task_id][None]
+        parts = [sos, self.embed_text(ids, langs), self.spk_emb(spk)[None], task]
+        if speech is not None:
+            parts.append(self.q.speech_embedding(speech))
+        return torch.cat(parts, 0)
+
+    def hidden(self, x, mask):
+        out = self.q.llm.model.model(inputs_embeds=x, attention_mask=mask, return_dict=True)
+        return out.last_hidden_state
+
+    def forward(self, batch, adv_lambda=1.0):
+        seqs, tgts, tpos = [], [], []
+        for ids, langs, spk, sp in batch:
+            x = self.build(ids, langs, spk, sp)
+            n_text = len(ids)
+            tgt = torch.full((x.shape[0],), -100, device=x.device, dtype=torch.long)
+            # position of task token = 1 + n_text + 1; it predicts speech[0]; last speech pos predicts EOS
+            start = 1 + n_text + 1
+            tgt[start: start + len(sp)] = sp
+            tgt[start + len(sp)] = self.V                         # EOS
+            seqs.append(x); tgts.append(tgt); tpos.append((1, 1 + n_text))
+        T = max(s.shape[0] for s in seqs) + 1
+        D = seqs[0].shape[1]
+        X = seqs[0].new_zeros(len(seqs), T, D)
+        Y = torch.full((len(seqs), T), -100, device=X.device, dtype=torch.long)
+        M = torch.zeros(len(seqs), T, device=X.device, dtype=torch.long)
+        for i, (s, t) in enumerate(zip(seqs, tgts)):
+            X[i, :len(s)] = s; Y[i, :len(t)] = t[:len(s)] if len(t) > len(s) else t; M[i, :len(s)] = 1
+        # targets were laid out on positions; shift is implicit (position p predicts tgt[p])
+        H = self.hidden(X, M)
+        logits = self.q.llm_decoder(H)
+        ce = F.cross_entropy(logits.float().reshape(-1, logits.shape[-1]), Y.reshape(-1), ignore_index=-100)
+        valid = Y != -100
+        acc = (logits.argmax(-1)[valid] == Y[valid]).float().mean()
+        # adversarial speaker classifier on text positions
+        hs, ys = [], []
+        for i, (a, b) in enumerate(tpos):
+            hs.append(H[i, a:b]); ys.append(torch.full((b - a,), int(batch[i][2]), device=X.device))
+        hs = torch.cat(hs); ys = torch.cat(ys)
+        al = self.adv(grad_reverse(hs.float(), adv_lambda))
+        adv = F.cross_entropy(al, ys)
+        adv_acc = (al.argmax(-1) == ys).float().mean()
+        return ce, acc, adv, adv_acc
+
+    @torch.no_grad()
+    def generate(self, ids, langs, spk, top_p=0.8, top_k=25, win=10, tau_r=0.1, seed=0):
+        g = torch.Generator(device=ids.device).manual_seed(seed)
+        x = self.build(ids, langs, spk)[None]
+        n = len(ids)
+        min_len, max_len = int(n * 2), int(n * 20)
+        past, out = None, []
+        inp = x
+        for i in range(max_len):
+            o = self.q.llm.model.model(inputs_embeds=inp, past_key_values=past, use_cache=True, return_dict=True)
+            past = o.past_key_values
+            logp = self.q.llm_decoder(o.last_hidden_state[:, -1]).float().log_softmax(-1)[0]
+            if i < min_len:
+                logp[self.V] = -float("inf")
+            logp[self.V + 1:] = -float("inf")
+            p = logp.exp()
+            sp, si = p.sort(descending=True)
+            keep = (sp.cumsum(0) - sp) < top_p
+            keep[top_k:] = False
+            cand_p, cand_i = sp[keep], si[keep]
+            tokid = int(cand_i[torch.multinomial(cand_p / cand_p.sum(), 1, generator=g)])
+            if out and sum(1 for t in out[-win:] if t == tokid) >= win * tau_r and tokid != self.V:  # RAS
+                tokid = int(torch.multinomial(p, 1, generator=g))
+            if tokid >= self.V:
+                break
+            out.append(tokid)
+            inp = self.q.speech_embedding.weight[tokid][None, None]
+        return out
+
+
+# ------------------------------------------------------------------ data
+def load_items(root, datasets, split, max_tok=500):
+    items, mm = [], {}
+    for ds in datasets:
+        if not os.path.exists(f"{root}/{ds}/s3tok.jsonl"):
+            continue
+        mm[ds] = np.memmap(f"{root}/{ds}/s3tok.i32", dtype=np.int32, mode="r")
+        tk = {}
+        for l in open(f"{root}/{ds}/s3tok.jsonl"):
+            r = json.loads(l); tk[r["id"]] = (r["toff"], r["ntok"])
+        for l in open(f"{root}/{ds}/meta.jsonl", encoding="utf-8"):
+            m = json.loads(l)
+            if m["split"] != split or m["id"] not in tk:
+                continue
+            m["toff"], m["ntok"] = tk[m["id"]]
+            if 5 < m["ntok"] <= max_tok:
+                items.append(m)
+    return items, mm
+
+
+def batches(items, budget, weights, rng):
+    idx = []
+    for i, m in enumerate(items):
+        w = weights.get(m["ds"], 1.0)
+        idx += [i] * int(w) + ([i] if rng.random() < w - int(w) else [])
+    idx.sort(key=lambda i: items[i]["ntok"] + rng.random() * 10)
+    out, cur, mx = [], [], 0
+    for i in idx:
+        L = items[i]["ntok"] + len(items[i]["text"]) // 2 + 4
+        if cur and max(mx, L) * (len(cur) + 1) > budget:
+            out.append(cur); cur, mx = [], 0
+        cur.append(i); mx = max(mx, L)
+    if cur:
+        out.append(cur)
+    rng.shuffle(out)
+    return out
+
+
+def train(a):
+    from transformers import AutoTokenizer
+    tok = AutoTokenizer.from_pretrained(f"{MODEL_DIR}/CosyVoice-BlankEN")
+    cosy = load_cosy()
+    items, mm = load_items(a.data, a.datasets.split(","), "train")
+    val, _ = load_items(a.data, a.datasets.split(","), "val")
+    spks = sorted({m["spk"] for m in items}); spk2id = {s: i for i, s in enumerate(spks)}
+    val = [m for m in val if m["spk"] in spk2id][:200]
+    os.makedirs(a.out, exist_ok=True)
+    json.dump(spk2id, open(f"{a.out}/spk2id.json", "w"))
+    print("armB items", len(items), "hours", round(sum(m["dur"] for m in items) / 3600, 1), "spk", len(spks), flush=True)
+    model = DALM(cosy.model.llm, len(spks)).cuda().train()
+    for p in cosy.model.flow.parameters():
+        p.requires_grad = False
+    for p in cosy.model.hift.parameters():
+        p.requires_grad = False
+    new = list(model.lang_emb.parameters()) + list(model.spk_emb.parameters()) + list(model.adv.parameters())
+    newids = {id(p) for p in new}
+    old = [p for p in model.parameters() if id(p) not in newids and p.requires_grad]
+    opt = torch.optim.AdamW([{"params": old, "lr": a.lr}, {"params": new, "lr": a.lr_new}], weight_decay=0.01)
+    base = [a.lr, a.lr_new]
+    cache = {}
+
+    def enc(m):
+        if m["id"] not in cache:
+            cache[m["id"]] = text_tokens(tok, f"<{m['lang']}>{m['text']}</{m['lang']}>")
+        ids, langs = cache[m["id"]]
+        sp = np.asarray(mm[m["ds"]][m["toff"]: m["toff"] + m["ntok"]], dtype=np.int64)
+        return (torch.tensor(ids).cuda(), torch.tensor(langs).cuda(), torch.tensor(spk2id[m["spk"]]).cuda(),
+                torch.from_numpy(sp).cuda())
+
+    rng = random.Random(0); step = 0; nskip = 0; t0 = time.time(); logf = open(f"{a.out}/log.jsonl", "a")
+
+    def validate():
+        model.eval(); L = []
+        with torch.no_grad(), torch.autocast("cuda", dtype=torch.bfloat16):
+            for i in range(0, len(val), 16):
+                ce, acc, _, _ = model([enc(m) for m in val[i:i + 16]]); L.append(float(ce))
+        model.train(); return float(np.mean(L))
+
+    v0 = validate(); print(json.dumps({"step": 0, "val_ce": v0}), flush=True); logf.write(json.dumps({"step": 0, "val_ce": v0}) + "\n")
+    done = False
+    while not done:
+        for bi in batches(items, a.tokens, {"waxal": a.waxal_w}, rng):
+            lrm = min(1.0, (step + 1) / 200)
+            for g, b in zip(opt.param_groups, base):
+                g["lr"] = b * lrm
+            with torch.autocast("cuda", dtype=torch.bfloat16):
+                ce, acc, adv, adv_acc = model([enc(items[i]) for i in bi])
+            loss = ce + a.adv_w * adv
+            opt.zero_grad(set_to_none=True)
+            if not torch.isfinite(loss):
+                nskip += 1
+                print(json.dumps({"skip_nonfinite_fwd": step, "ce": float(ce), "adv": float(adv), "B": len(bi),
+                                  "maxtok": max(items[i]["ntok"] for i in bi)}), flush=True)
+                continue
+            loss.backward()
+            gn = torch.nn.utils.clip_grad_norm_([p for p in model.parameters() if p.requires_grad], 1.0)
+            if not torch.isfinite(gn):
+                nskip += 1; opt.zero_grad(set_to_none=True)
+                print(json.dumps({"skip_nonfinite_grad": step}), flush=True); continue
+            opt.step(); step += 1
+            if step % 25 == 0:
+                r = dict(step=step, ce=round(float(ce), 4), acc=round(float(acc), 4), adv=round(float(adv), 3),
+                         adv_acc=round(float(adv_acc), 3), gn=round(float(gn), 2), B=len(bi), min=round((time.time() - t0) / 60, 2))
+                print(json.dumps(r), flush=True); logf.write(json.dumps(r) + "\n"); logf.flush()
+            if step % 500 == 0:
+                v = validate(); print(json.dumps({"step": step, "val_ce": v}), flush=True)
+                logf.write(json.dumps({"step": step, "val_ce": v}) + "\n"); logf.flush()
+            if (time.time() - t0) / 60 > a.minutes:
+                done = True; break
+    v = validate(); logf.write(json.dumps({"step": step, "val_ce": v, "final": True}) + "\n")
+    sd = {k: v for k, v in model.state_dict().items()}
+    torch.save(dict(model=sd, step=step, n_spk=len(spks)), f"{a.out}/last.pt")
+    print("TRAIN_B_DONE", step, v, flush=True)
+
+
+# ------------------------------------------------------------------ inference
+def prompt_feats(cosy, wav_path):
+    """flow prompt (speech tokens, 24k mel feat, campplus embedding) from an anchor clip."""
+    fe = cosy.frontend
+    tokn, tokl = fe._extract_speech_token(wav_path)
+    feat, featl = fe._extract_speech_feat(wav_path)
+    # CosyVoice2 aligns: feat frames = 2 * tokens
+    n = min(feat.shape[1] // 2, tokn.shape[1])
+    feat, tokn = feat[:, :2 * n], tokn[:, :n]
+    emb = fe._extract_spk_embedding(wav_path)
+    return tokn.cuda(), feat.cuda(), emb.cuda()
+
+
+@torch.no_grad()
+def token2wav(cosy, tokens, ptok, pfeat, emb):
+    flow = cosy.model.flow
+    t = torch.tensor([tokens], dtype=torch.int32).cuda()
+    kw = dict(token=t, token_len=torch.tensor([t.shape[1]], dtype=torch.int32).cuda(),
+              prompt_token=ptok, prompt_token_len=torch.tensor([ptok.shape[1]], dtype=torch.int32).cuda(),
+              prompt_feat=pfeat, prompt_feat_len=torch.tensor([pfeat.shape[1]], dtype=torch.int32).cuda(),
+              embedding=emb)
+    sig = inspect.signature(flow.inference).parameters
+    if "streaming" in sig:
+        kw["streaming"] = False
+    if "finalize" in sig:
+        kw["finalize"] = True
+    if "flow_cache" in sig:
+        kw["flow_cache"] = torch.zeros(1, 80, 0, 2).cuda()
+    mel = flow.inference(**kw)
+    mel = mel[0] if isinstance(mel, tuple) else mel
+    hs = inspect.signature(cosy.model.hift.inference).parameters
+    w = cosy.model.hift.inference(speech_feat=mel, **({"cache_source": torch.zeros(1, 1, 0).cuda()} if "cache_source" in hs else {}))
+    w = w[0] if isinstance(w, tuple) else w
+    return w.squeeze().float().cpu().numpy()
+
+
+def eval_rows():
+    return [json.loads(l) for l in open(f"{HOME}/eval/eval_set.jsonl", encoding="utf-8")]
+
+
+def synth(a):
+    from transformers import AutoTokenizer
+    tok = AutoTokenizer.from_pretrained(f"{MODEL_DIR}/CosyVoice-BlankEN")
+    cosy = load_cosy()
+    ck = torch.load(a.ckpt, map_location="cuda")
+    spk2id = json.load(open(os.path.join(os.path.dirname(a.ckpt), "spk2id.json")))
+    model = DALM(cosy.model.llm, ck["n_spk"]).cuda().eval()
+    model.load_state_dict(ck["model"])
+    anc = json.load(open(f"{HOME}/eval/anchor.json"))
+    ptok, pfeat, emb = prompt_feats(cosy, anc["ref_wavs"][0])
+    os.makedirs(a.out, exist_ok=True)
+    for r in eval_rows():
+        text = r["text"] if r["lang"] == "cs" else f"<{r['lang']}>{r['text']}</{r['lang']}>"
+        ids, langs = text_tokens(tok, text)
+        with torch.autocast("cuda", dtype=torch.bfloat16):
+            sp = model.generate(torch.tensor(ids).cuda(), torch.tensor(langs).cuda(), torch.tensor(spk2id[anc["spk"]]).cuda())
+        sf.write(f"{a.out}/{r['id']}.wav", token2wav(cosy, sp, ptok, pfeat, emb), cosy.sample_rate)
+    print("synth_b done", a.out, flush=True)
+
+
+def zeroshot(a):
+    """Unmodified pretrained CosyVoice2, cross-lingual mode with the anchor prompt (reference point)."""
+    cosy = load_cosy()
+    anc = json.load(open(f"{HOME}/eval/anchor.json"))
+    from cosyvoice.utils.file_utils import load_wav
+    pw = anc["ref_wavs"][0]
+    sig = inspect.signature(cosy.inference_cross_lingual).parameters
+    os.makedirs(a.out, exist_ok=True)
+    for r in eval_rows():
+        text = " ".join(s.strip() for _, s in segments(r["text"])) if r["lang"] == "cs" else r["text"]
+        prompt = pw
+        outs = [o["tts_speech"] for o in cosy.inference_cross_lingual(text, prompt, stream=False)]
+        w = torch.cat(outs, 1).squeeze().cpu().numpy()
+        sf.write(f"{a.out}/{r['id']}.wav", w, cosy.sample_rate)
+    print("zeroshot done", flush=True)
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("cmd")
+    ap.add_argument("--data", default=f"{HOME}/data")
+    ap.add_argument("--datasets", default="waxal,fleurs,slr86,slr70,bible_yor")
+    ap.add_argument("--out", default=f"{HOME}/runs/b1")
+    ap.add_argument("--ckpt", default="")
+    ap.add_argument("--minutes", type=float, default=30)
+    ap.add_argument("--lr", type=float, default=1e-5)
+    ap.add_argument("--lr_new", type=float, default=1e-3)
+    ap.add_argument("--tokens", type=int, default=12000)
+    ap.add_argument("--waxal_w", type=float, default=2.0)
+    ap.add_argument("--adv_w", type=float, default=0.02)
+    a = ap.parse_args()
+    {"train": train, "synth": synth, "zeroshot": zeroshot}[a.cmd](a)

code/train_b2.py

@@ -0,0 +1,590 @@
+"""Arm B, Phase 2. CosyVoice2-0.5B (Apache-2.0) + language embeddings + speaker token + GRL speaker classifier.
+
+New in Phase 2
+  * data from ~/data2 (24 kHz, forced-aligned, pause-normalised; long WAXAL clips segmented; BibleTTS Hausa; CS pairs)
+  * in-context prompts during LM training (p=0.5): [sos, prompt_text+text, spk, task, prompt_speech, speech] with
+    loss on the target speech only -> at inference the anchor clip steers prosody and pause style
+  * keep-best on validation CE (every --val_every steps), cosine LR, early stop
+  * flow-matching decoder fine-tune on 24 kHz studio sources (tones / pitch / timing detail)
+  * synthesis: anchor prompt at LM and flow, sentence-level generation for multi-sentence text with anchor-matched
+    inter-sentence pauses, N candidates per text (seed + prompt clip vary)
+
+  python train_b2.py lm    --out ~/runs/p2_lm  --minutes 90
+  python train_b2.py flow  --out ~/runs/p2_flow --minutes 60
+  python train_b2.py synth --ckpt ~/runs/p2_lm/best.pt [--flow ~/runs/p2_flow/best.pt] --out DIR --n 4
+"""
+import argparse, inspect, json, math, os, random, re, sys, time
+import numpy as np, torch, torch.nn as nn, torch.nn.functional as F, soundfile as sf, librosa
+
+HOME = os.path.expanduser("~")
+sys.path[:0] = [f"{HOME}/CosyVoice", f"{HOME}/CosyVoice/third_party/Matcha-TTS", f"{HOME}/da"]
+from train_b import load_cosy, text_tokens, DALM, LANGS, L2I, MODEL_DIR, token2wav  # noqa: E402
+from da.model import grad_reverse  # noqa: E402
+from da.text import segments  # noqa: E402
+
+D2 = os.path.expanduser(os.environ.get("P2OUT", f"{HOME}/data2"))
+ANCHOR = "waxal_yor_4"
+
+
+# ------------------------------------------------------------------ model
+class DALM2(DALM):
+    def build2(self, ids, langs, spk, sp=None, pids=None, plangs=None, psp=None):
+        """[sos, (prompt_text) text, spk, task, (prompt_speech) speech] -> embeddings, n_text_total, n_prompt_speech"""
+        sos = self.q.llm_embedding.weight[self.q.sos][None]
+        task = self.q.llm_embedding.weight[self.q.task_id][None]
+        if pids is not None:
+            ids = torch.cat([pids, ids]); langs = torch.cat([plangs, langs])
+        parts = [sos, self.embed_text(ids, langs), self.spk_emb(spk)[None], task]
+        npsp = 0
+        if psp is not None:
+            parts.append(self.q.speech_embedding(psp)); npsp = len(psp)
+        if sp is not None:
+            parts.append(self.q.speech_embedding(sp))
+        return torch.cat(parts, 0), len(ids), npsp
+
+    def forward2(self, batch, adv_lambda=1.0):
+        seqs, tgts, tpos, spks = [], [], [], []
+        for b in batch:
+            ids, langs, spk, sp = b[:4]
+            pr = b[4] if len(b) > 4 else None
+            x, nt, npsp = self.build2(ids, langs, spk, sp, *(pr if pr else (None, None, None)))
+            tgt = torch.full((x.shape[0] + 1,), -100, device=x.device, dtype=torch.long)
+            start = 1 + nt + 2 + npsp - 1          # position whose output predicts speech[0]
+            tgt[start: start + len(sp)] = sp
+            tgt[start + len(sp)] = self.V
+            seqs.append(x); tgts.append(tgt[:x.shape[0]]); tpos.append((1, 1 + nt)); spks.append(int(spk))
+        T = max(s.shape[0] for s in seqs)
+        D = seqs[0].shape[1]
+        X = seqs[0].new_zeros(len(seqs), T, D)
+        Y = torch.full((len(seqs), T), -100, device=X.device, dtype=torch.long)
+        M = torch.zeros(len(seqs), T, device=X.device, dtype=torch.long)
+        for i, (s, t) in enumerate(zip(seqs, tgts)):
+            X[i, :len(s)] = s; Y[i, :len(t)] = t; M[i, :len(s)] = 1
+        H = self.hidden(X, M)
+        logits = self.q.llm_decoder(H)
+        ce = F.cross_entropy(logits.float().reshape(-1, logits.shape[-1]), Y.reshape(-1), ignore_index=-100)
+        valid = Y != -100
+        acc = (logits.argmax(-1)[valid] == Y[valid]).float().mean()
+        hs, ys = [], []
+        for i, (a, b) in enumerate(tpos):
+            hs.append(H[i, a:b]); ys.append(torch.full((b - a,), spks[i], device=X.device))
+        hs = torch.cat(hs); ys = torch.cat(ys)
+        al = self.adv(grad_reverse(hs.float(), adv_lambda))
+        adv = F.cross_entropy(al, ys)
+        return ce, acc, adv, (al.argmax(-1) == ys).float().mean()
+
+    @torch.no_grad()
+    def generate2(self, ids, langs, spk, prompt=None, top_p=0.8, top_k=25, win=10, tau_r=0.1, seed=0,
+                  min_ratio=2.0, max_ratio=20.0):
+        g = torch.Generator(device=ids.device).manual_seed(seed)
+        x, _, _ = self.build2(ids, langs, spk, None, *(prompt if prompt else (None, None, None)))
+        x = x[None]
+        n = len(ids)
+        min_len, max_len = int(n * min_ratio), int(n * max_ratio)
+        past, out, inp = None, [], x
+        for i in range(max_len):
+            o = self.q.llm.model.model(inputs_embeds=inp, past_key_values=past, use_cache=True, return_dict=True)
+            past = o.past_key_values
+            logp = self.q.llm_decoder(o.last_hidden_state[:, -1]).float().log_softmax(-1)[0]
+            if i < min_len:
+                logp[self.V] = -float("inf")
+            logp[self.V + 1:] = -float("inf")
+            p = logp.exp()
+            sp, si = p.sort(descending=True)
+            keep = (sp.cumsum(0) - sp) < top_p
+            keep[top_k:] = False
+            cp, ci = sp[keep], si[keep]
+            tokid = int(ci[torch.multinomial(cp / cp.sum(), 1, generator=g)])
+            if out and sum(1 for t in out[-win:] if t == tokid) >= win * tau_r and tokid != self.V:
+                tokid = int(torch.multinomial(p, 1, generator=g))
+            if tokid >= self.V:
+                break
+            out.append(tokid)
+            inp = self.q.speech_embedding.weight[tokid][None, None]
+        return out
+
+
+# ------------------------------------------------------------------ data
+def load_items(datasets, split, max_tok=500, flow=False):
+    items, mm = [], {}
+    for ds in datasets:
+        od = f"{D2}/{ds}"
+        if not os.path.exists(f"{od}/s3tok.jsonl"):
+            print("missing", ds, flush=True); continue
+        mm[ds] = np.memmap(f"{od}/s3tok.i32", dtype=np.int32, mode="r")
+        tk = [json.loads(l) for l in open(f"{od}/s3tok.jsonl")]
+        for k, l in enumerate(open(f"{od}/meta.jsonl", encoding="utf-8")):
+            m = json.loads(l)
+            t = tk[k]
+            assert t["id"] == m["id"]
+            if m["split"] != split:
+                continue
+            if flow and not m.get("flow_ok"):
+                continue
+            m["toff"], m["ntok"], m["row"] = t["toff"], t["ntok"], k
+            if 5 < m["ntok"] <= max_tok:
+                items.append(m)
+    return items, mm
+
+
+def tagged(m):
+    return m["text"] if m["lang"] == "cs" else f"<{m['lang']}>{m['text']}</{m['lang']}>"
+
+
+DS_W = {"waxal": 2.0, "bible_yor": 0.5, "bible_hau": 0.6, "fleurs": 1.0, "slr86": 1.0, "slr70": 1.0, "cs_pairs": 1.0}
+
+
+def batches(items, budget, rng, extra_w=None, cost=None):
+    idx = []
+    for i, m in enumerate(items):
+        w = DS_W.get(m["ds"], 1.0) * (extra_w(m) if extra_w else 1.0)
+        idx += [i] * int(w) + ([i] if rng.random() < w - int(w) else [])
+    cost = cost or (lambda m: m["ntok"] + len(m["text"]) // 2 + 4)
+    idx.sort(key=lambda i: cost(items[i]) + rng.random() * 10)
+    out, cur, mx = [], [], 0
+    for i in idx:
+        L = cost(items[i])
+        if cur and max(mx, L) * (len(cur) + 1) > budget:
+            out.append(cur); cur, mx = [], 0
+        cur.append(i); mx = max(mx, L)
+    if cur:
+        out.append(cur)
+    rng.shuffle(out)
+    return out
+
+
+# ------------------------------------------------------------------ LM training
+def train_lm(a):
+    from transformers import AutoTokenizer
+    tok = AutoTokenizer.from_pretrained(f"{MODEL_DIR}/CosyVoice-BlankEN")
+    cosy = load_cosy()
+    dss = a.datasets.split(",")
+    items, mm = load_items(dss, "train")
+    val_all, _ = load_items(dss, "val")
+    if a.anchor_only_w > 0:
+        print("anchor items", sum(m["spk"] == ANCHOR for m in items), flush=True)
+    spks = sorted({m["spk"] for m in items})
+    if a.init:
+        ck = torch.load(a.init, map_location="cpu")
+        spk2id = json.load(open(os.path.join(os.path.dirname(a.init), "spk2id.json")))
+        for s in spks:
+            if s not in spk2id:
+                spk2id[s] = len(spk2id)
+    else:
+        spk2id = {s: i for i, s in enumerate(spks)}
+    n_spk = max(len(spk2id), ck["n_spk"]) if a.init else len(spk2id)
+    # balanced val: up to 60 per language (+ anchor), never more than 15 per speaker
+    rng = random.Random(1); rng.shuffle(val_all)
+    val, per_l, per_s = [], {}, {}
+    for m in val_all:
+        if m["spk"] not in spk2id or m["lang"] == "cs":
+            continue
+        L = "anchor" if m["spk"] == ANCHOR else m["lang"]
+        if per_l.get(L, 0) >= 60 or per_s.get(m["spk"], 0) >= 15:
+            continue
+        per_l[L] = per_l.get(L, 0) + 1; per_s[m["spk"]] = per_s.get(m["spk"], 0) + 1; val.append(m)
+    by_spk = {}
+    for m in items:
+        if m["ntok"] <= 160 and m["lang"] != "cs":
+            by_spk.setdefault(m["spk"], []).append(m)
+    os.makedirs(a.out, exist_ok=True)
+    json.dump(spk2id, open(f"{a.out}/spk2id.json", "w"))
+    print("lm items", len(items), "hours", round(sum(m["dur"] for m in items) / 3600, 1), "spk", len(spk2id),
+          "val", len(val), per_l, flush=True)
+    model = DALM2(cosy.model.llm, n_spk).cuda().train()
+    if a.init:
+        sd = ck["model"]
+        if sd["spk_emb.weight"].shape[0] < n_spk:
+            for k in ["spk_emb.weight"]:
+                w = model.state_dict()[k].clone(); w[:sd[k].shape[0]] = sd[k]; sd[k] = w
+            for k in ["adv.2.weight", "adv.2.bias"]:
+                w = model.state_dict()[k].clone(); w[:sd[k].shape[0]] = sd[k]; sd[k] = w
+        print(model.load_state_dict(sd, strict=False), flush=True)
+    for p in cosy.model.flow.parameters():
+        p.requires_grad = False
+    for p in cosy.model.hift.parameters():
+        p.requires_grad = False
+    new = list(model.lang_emb.parameters()) + list(model.spk_emb.parameters()) + list(model.adv.parameters())
+    newids = {id(p) for p in new}
+    old = [p for p in model.parameters() if id(p) not in newids and p.requires_grad]
+    opt = torch.optim.AdamW([{"params": old, "lr": a.lr}, {"params": new, "lr": a.lr_new}], weight_decay=0.01)
+    base = [a.lr, a.lr_new]
+    cache = {}
+
+    def tt(text, key):
+        if key not in cache:
+            cache[key] = text_tokens(tok, text)
+        return cache[key]
+
+    def enc(m, prng=None, force_prompt=None):
+        ids, langs = tt(tagged(m), m["id"])
+        sp = np.asarray(mm[m["ds"]][m["toff"]: m["toff"] + m["ntok"]], dtype=np.int64)
+        r = [torch.tensor(ids).cuda(), torch.tensor(langs).cuda(), torch.tensor(spk2id[m["spk"]]).cuda(),
+             torch.from_numpy(sp).cuda()]
+        use = force_prompt if force_prompt is not None else (prng is not None and prng.random() < a.p_prompt)
+        if use:
+            c = by_spk.get(m["spk"], [])
+            c = [x for x in (prng or random).sample(c, min(6, len(c))) if x["id"] != m["id"]] if c else []
+            if c and c[0]["ntok"] + m["ntok"] <= 600:
+                p = c[0]
+                pids, plangs = tt(tagged(p), p["id"])
+                psp = np.asarray(mm[p["ds"]][p["toff"]: p["toff"] + p["ntok"]], dtype=np.int64)
+                r.append((torch.tensor(pids).cuda(), torch.tensor(plangs).cuda(), torch.from_numpy(psp).cuda()))
+        return r
+
+    def validate():
+        model.eval(); out = {}
+        with torch.no_grad(), torch.autocast("cuda", dtype=torch.bfloat16):
+            for mode in (False, True):
+                vr = random.Random(7); L, W = [], []
+                for i in range(0, len(val), 16):
+                    bt = val[i:i + 16]
+                    ce, _, _, _ = model.forward2([enc(m, vr, force_prompt=mode) for m in bt])
+                    L.append(float(ce) * len(bt)); W.append(len(bt))
+                out["p" if mode else "np"] = sum(L) / sum(W)
+            # anchor-only val
+            av = [m for m in val if m["spk"] == ANCHOR]
+            if av:
+                vr = random.Random(7)
+                ce, _, _, _ = model.forward2([enc(m, vr, force_prompt=True) for m in av[:32]])
+                out["anchor_p"] = float(ce)
+        model.train()
+        out["mean"] = (out["np"] + out["p"]) / 2
+        return out
+
+    extra = (lambda m: a.anchor_only_w if m["spk"] == ANCHOR else 1.0) if a.anchor_only_w > 0 else None
+    rng = random.Random(0); prng = random.Random(3)
+    step, nskip, t0 = 0, 0, time.time()
+    logf = open(f"{a.out}/log.jsonl", "a")
+    v = validate(); best = v["mean"] if not a.select_anchor else 0.5 * (v["mean"] + v.get("anchor_p", v["mean"])); bad = 0
+    logf.write(json.dumps({"step": 0, "val": v}) + "\n"); print(json.dumps({"step": 0, "val": v}), flush=True)
+    torch.save(dict(model=model.state_dict(), step=0, n_spk=n_spk, val=v), f"{a.out}/best.pt")
+    total = a.max_steps
+    done = False
+    while not done:
+        for bi in batches(items, a.tokens, rng, extra, cost=lambda m: m["ntok"] + len(m["text"]) // 2 + 4 + int(a.p_prompt * 200)):
+            lrm = min(1.0, (step + 1) / a.warmup) * (0.1 + 0.9 * 0.5 * (1 + math.cos(math.pi * min(1.0, step / total))))
+            for g, b in zip(opt.param_groups, base):
+                g["lr"] = b * lrm
+            batch = [enc(items[i], prng) for i in bi]
+            # keep the padded length inside the budget when prompts were added
+            with torch.autocast("cuda", dtype=torch.bfloat16):
+                ce, acc, adv, adv_acc = model.forward2(batch, adv_lambda=min(1.0, step / 1000))
+            loss = ce + a.adv_w * adv
+            opt.zero_grad(set_to_none=True)
+            if not torch.isfinite(loss):
+                nskip += 1; print(json.dumps({"skip_nonfinite_fwd": step, "ce": float(ce), "adv": float(adv)}), flush=True)
+                continue
+            loss.backward()
+            gn = torch.nn.utils.clip_grad_norm_([p for p in model.parameters() if p.requires_grad], 1.0)
+            if not torch.isfinite(gn):
+                nskip += 1; opt.zero_grad(set_to_none=True); print(json.dumps({"skip_nonfinite_grad": step}), flush=True)
+                continue
+            opt.step(); step += 1
+            if step % 25 == 0:
+                r = dict(step=step, ce=round(float(ce), 4), acc=round(float(acc), 4), adv=round(float(adv), 3),
+                         adv_acc=round(float(adv_acc), 3), gn=round(float(gn), 2), B=len(bi), lr=round(lrm * a.lr, 9),
+                         skips=nskip, min=round((time.time() - t0) / 60, 2))
+                print(json.dumps(r), flush=True); logf.write(json.dumps(r) + "\n"); logf.flush()
+            if step % a.val_every == 0:
+                v = validate()
+                score = v["mean"] if not a.select_anchor else 0.5 * (v["mean"] + v.get("anchor_p", v["mean"]))
+                imp = score < best - 1e-4
+                rec = {"step": step, "val": v, "best": imp}
+                print(json.dumps(rec), flush=True); logf.write(json.dumps(rec) + "\n"); logf.flush()
+                if imp:
+                    best, bad = score, 0
+                    torch.save(dict(model=model.state_dict(), step=step, n_spk=n_spk, val=v), f"{a.out}/best.pt")
+                else:
+                    bad += 1
+                    if bad >= a.patience:
+                        print("EARLY_STOP", step, flush=True); done = True; break
+            if (time.time() - t0) / 60 > a.minutes or step >= total:
+                done = True; break
+    print("TRAIN_LM_DONE", step, "best", best, "skips", nskip, flush=True)
+
+
+# ------------------------------------------------------------------ flow training
+def train_flow(a):
+    cosy = load_cosy()
+    flow = cosy.model.flow
+    if a.flow_init:
+        flow.load_state_dict(torch.load(a.flow_init, map_location="cuda")["flow"])
+    flow.train()
+    for p in cosy.model.llm.parameters():
+        p.requires_grad = False
+    fe = cosy.frontend.feat_extractor
+    dss = a.datasets.split(",")
+    items, mm = load_items(dss, "train", max_tok=400, flow=True)
+    val, _ = load_items(dss, "val", max_tok=400, flow=True)
+    rng0 = random.Random(1); rng0.shuffle(val); val = val[:256]
+    pcm = {ds: np.memmap(f"{D2}/{ds}/pcm24k.i16", dtype=np.int16, mode="r") for ds in dss if os.path.exists(f"{D2}/{ds}/pcm24k.i16")}
+    emb = {ds: np.load(f"{D2}/{ds}/campplus.npy", mmap_mode="r") for ds in dss if os.path.exists(f"{D2}/{ds}/campplus.npy")}
+    os.makedirs(a.out, exist_ok=True)
+    print("flow items", len(items), "hours", round(sum(m["dur"] for m in items) / 3600, 1), "val", len(val), flush=True)
+    extra = (lambda m: a.anchor_only_w if m["spk"] == ANCHOR else 1.0) if a.anchor_only_w > 0 else None
+
+    def make(bt):
+        toks, feats, es = [], [], []
+        for m in bt:
+            y = torch.from_numpy(np.asarray(pcm[m["ds"]][m["off24"]: m["off24"] + m["n24"]], dtype=np.float32) / 32768.0)
+            n = int(math.ceil(len(y) / 960)) * 960
+            y = F.pad(y, (0, n - len(y)))[None].cuda()
+            ft = fe(y).squeeze(0).transpose(0, 1)         # [T,80]
+            tk = torch.from_numpy(np.asarray(mm[m["ds"]][m["toff"]: m["toff"] + m["ntok"]], dtype=np.int64))
+            k = min(ft.shape[0] // 2, len(tk))
+            toks.append(tk[:k]); feats.append(ft[:2 * k]); es.append(torch.from_numpy(np.array(emb[m["ds"]][m["row"]])))
+        tl = torch.tensor([len(t) for t in toks], dtype=torch.int32)
+        fl = torch.tensor([len(f) for f in feats], dtype=torch.int32)
+        T = int(tl.max()); Fm = int(fl.max())
+        tok = torch.zeros(len(bt), T, dtype=torch.long); feat = torch.zeros(len(bt), Fm, 80)
+        for i, (t, f) in enumerate(zip(toks, feats)):
+            tok[i, :len(t)] = t; feat[i, :len(f)] = f.cpu()
+        return dict(speech_token=tok, speech_token_len=tl, speech_feat=feat, speech_feat_len=fl,
+                    embedding=torch.stack(es).float())
+
+    params = [p for p in flow.parameters() if p.requires_grad]
+    opt = torch.optim.AdamW(params, lr=a.lr, weight_decay=0.0)
+    logf = open(f"{a.out}/log.jsonl", "a")
+
+    def validate():
+        flow.eval(); L = []
+        st = torch.random.get_rng_state(); cst = torch.cuda.get_rng_state(); pst = random.getstate()
+        torch.manual_seed(0); random.seed(0)
+        with torch.no_grad():
+            for i in range(0, len(val), 16):
+                L.append(float(flow(make(val[i:i + 16]), torch.device("cuda"))["loss"]))
+        torch.random.set_rng_state(st); torch.cuda.set_rng_state(cst); random.setstate(pst)
+        flow.train(); return float(np.mean(L))
+
+    v = validate(); best, bad = v, 0
+    print(json.dumps({"step": 0, "val": v}), flush=True); logf.write(json.dumps({"step": 0, "val": v}) + "\n")
+    torch.save(dict(flow=flow.state_dict(), step=0, val=v), f"{a.out}/best.pt")
+    rng = random.Random(0); step, t0, done = 0, time.time(), False
+    while not done:
+        for bi in batches(items, a.tokens, rng, extra, cost=lambda m: m["ntok"]):
+            lrm = min(1.0, (step + 1) / a.warmup)
+            for g in opt.param_groups:
+                g["lr"] = a.lr * lrm
+            with torch.autocast("cuda", dtype=torch.bfloat16):
+                loss = flow(make([items[i] for i in bi]), torch.device("cuda"))["loss"]
+            opt.zero_grad(set_to_none=True)
+            if not torch.isfinite(loss):
+                continue
+            loss.backward()
+            gn = torch.nn.utils.clip_grad_norm_(params, 5.0)
+            if not torch.isfinite(gn):
+                continue
+            opt.step(); step += 1
+            if step % 50 == 0:
+                r = dict(step=step, loss=round(float(loss), 4), gn=round(float(gn), 2), B=len(bi), min=round((time.time() - t0) / 60, 2))
+                print(json.dumps(r), flush=True); logf.write(json.dumps(r) + "\n"); logf.flush()
+            if step % a.val_every == 0:
+                v = validate(); imp = v < best - 1e-4
+                print(json.dumps({"step": step, "val": v, "best": imp}), flush=True)
+                logf.write(json.dumps({"step": step, "val": v, "best": imp}) + "\n"); logf.flush()
+                if imp:
+                    best, bad = v, 0
+                    torch.save(dict(flow=flow.state_dict(), step=step, val=v), f"{a.out}/best.pt")
+                else:
+                    bad += 1
+                    if bad >= a.patience:
+                        done = True; break
+            if (time.time() - t0) / 60 > a.minutes or step >= a.max_steps:
+                done = True; break
+    print("TRAIN_FLOW_DONE", step, "best", best, flush=True)
+
+
+# ------------------------------------------------------------------ synthesis
+_SENT = re.compile(r"(?<=[.?!])\s+")
+
+
+def split_sentences(text):
+    """tagged text -> list of tagged sentences. A sentence ends at . ? ! inside a span or at the end of a span;
+    language spans are cut there and re-tagged, so a sentence keeps its in-sentence switches."""
+    out, cur = [], []
+    for l, s in segments(text):
+        parts = _SENT.split(s.strip())
+        for k, p in enumerate(parts):
+            p = p.strip()
+            if p:
+                cur.append(f"<{l}>{p}</{l}>")
+            if (k < len(parts) - 1 or p[-1:] in ".?!") and cur:
+                out.append(" ".join(cur)); cur = []
+    if cur:
+        out.append(" ".join(cur))
+    return [o for o in out if o.strip()]
+
+
+def trim_edges(w, sr, keep_lead=0.12, keep_tail=0.18):
+    from da.p2common import silence_mask
+    sil = silence_mask(w, sr)
+    sp = np.where(~sil)[0]
+    if not len(sp):
+        return w
+    a, b = sp[0] * 0.01, (sp[-1] + 1) * 0.01
+    out = w[int(max(0, a - keep_lead) * sr): int(min(len(w) / sr, b + keep_tail) * sr)]
+    lead = a - max(0, a - keep_lead)
+    if lead < keep_lead:
+        out = np.concatenate([np.zeros(int((keep_lead - lead) * sr), out.dtype), out])
+    return out
+
+
+def cap_internal(w, sr, cap=0.6):
+    """shorten every internal silence longer than cap seconds to cap (the centre of the silent run is removed)."""
+    from da.p2common import silence_mask, runs
+    sil = silence_mask(w, sr)
+    hop = int(0.01 * sr)
+    R = [(a, b) for a, b in runs(sil) if a > 0 and b < len(sil) and (b - a) * 0.01 > cap]
+    if not R:
+        return w
+    keep, cur = [], 0
+    for a, b in R:
+        cut0 = a * hop + int(cap / 2 * sr)
+        cut1 = b * hop - int(cap / 2 * sr)
+        keep.append(w[cur:cut0]); cur = cut1
+    keep.append(w[cur:])
+    return np.concatenate(keep)
+
+
+class Synth:
+    def __init__(self, ckpt, flow_ckpt=None, sent_pause=0.5):
+        from transformers import AutoTokenizer
+        self.tok = AutoTokenizer.from_pretrained(f"{MODEL_DIR}/CosyVoice-BlankEN")
+        self.cosy = load_cosy()
+        if flow_ckpt:
+            self.cosy.model.flow.load_state_dict(torch.load(flow_ckpt, map_location="cuda")["flow"])
+        ck = torch.load(ckpt, map_location="cuda")
+        self.spk2id = json.load(open(os.path.join(os.path.dirname(ckpt), "spk2id.json")))
+        self.m = DALM2(self.cosy.model.llm, ck["n_spk"]).cuda().eval()
+        self.m.load_state_dict(ck["model"])
+        self.sent_pause = sent_pause
+        self.cap = 0.6
+        # anchor prompts: normalised anchor val clips from data2 (never in train), 3-7 s, highest SNR first
+        meta = [json.loads(l) for l in open(f"{D2}/waxal/meta.jsonl", encoding="utf-8")]
+        tk = [json.loads(l) for l in open(f"{D2}/waxal/s3tok.jsonl")]
+        pcm = np.memmap(f"{D2}/waxal/pcm24k.i16", dtype=np.int16, mode="r")
+        s3 = np.memmap(f"{D2}/waxal/s3tok.i32", dtype=np.int32, mode="r")
+        cand = [(m, t) for m, t in zip(meta, tk) if m["spk"] == ANCHOR and m["split"] == "val" and 3.0 <= m["dur"] <= 7.0
+                and not m.get("longform")]
+        cand.sort(key=lambda x: -x[0]["ascore"])
+        self.prompts = []
+        os.makedirs(f"{HOME}/eval/prompts", exist_ok=True)
+        for m, t in cand[:4]:
+            y = np.asarray(pcm[m["off24"]: m["off24"] + m["n24"]], dtype=np.float32) / 32768.0
+            p = f"{HOME}/eval/prompts/{m['id']}.wav"; sf.write(p, y, 24000)
+            from train_b import prompt_feats
+            ptok, pfeat, pemb = prompt_feats(self.cosy, p)
+            ids, langs = text_tokens(self.tok, tagged(m))
+            lmp = (torch.tensor(ids).cuda(), torch.tensor(langs).cuda(),
+                   torch.from_numpy(np.asarray(s3[t["toff"]: t["toff"] + t["ntok"]], dtype=np.int64)).cuda())
+            self.prompts.append(dict(id=m["id"], text=m["text"], lm=lmp, flow=(ptok, pfeat, pemb)))
+        print("anchor prompts", [p["id"] for p in self.prompts], flush=True)
+
+    def one(self, tagged_text, seed=0, prompt_k=0, use_lm_prompt=True):
+        ids, langs = text_tokens(self.tok, tagged_text)
+        P = self.prompts[prompt_k % len(self.prompts)]
+        with torch.autocast("cuda", dtype=torch.bfloat16):
+            sp = self.m.generate2(torch.tensor(ids).cuda(), torch.tensor(langs).cuda(),
+                                  torch.tensor(self.spk2id[ANCHOR]).cuda(), prompt=P["lm"] if use_lm_prompt else None,
+                                  seed=seed)
+        if len(sp) < 3:
+            sp = sp + [0] * 3
+        self.last_tokens.append(sp)
+        return token2wav(self.cosy, sp, *P["flow"])
+
+    def join(self, ws):
+        sr = self.cosy.sample_rate
+        if len(ws) == 1:
+            return ws[0]
+        out = []
+        for i, w in enumerate(ws):
+            if i:
+                out.append(np.zeros(max(0, int((self.sent_pause - 0.30) * sr)), np.float32))
+            out.append(w)
+        return np.concatenate(out)
+
+    def redecode(self, toks, prompt_k=0):
+        """same LM tokens, (possibly different) flow -> identical post-processing"""
+        sr = self.cosy.sample_rate
+        P = self.prompts[prompt_k % len(self.prompts)]
+        return self.join([cap_internal(trim_edges(token2wav(self.cosy, t, *P["flow"]), sr), sr, self.cap) for t in toks])
+
+    def say(self, tagged_text, seed=0, prompt_k=0, stitch=True, use_lm_prompt=True):
+        sr = self.cosy.sample_rate
+        self.last_tokens = []
+        sents = split_sentences(tagged_text) if stitch else [tagged_text]
+        ws = [cap_internal(trim_edges(self.one(s, seed=seed + 1000 * i, prompt_k=prompt_k, use_lm_prompt=use_lm_prompt), sr), sr, self.cap)
+              for i, s in enumerate(sents)]
+        # trailing 0.18 + leading 0.12 already present; join() tops up to the anchor's sentence pause
+        return self.join(ws)
+
+
+def redecode(a):
+    """decode the LM tokens saved by synth (--src DIR) with another flow checkpoint -> --out"""
+    S = Synth(a.ckpt, a.flow or None, a.sent_pause)
+    os.makedirs(a.out, exist_ok=True)
+    import glob
+    for f in sorted(glob.glob(f"{a.src}/*.tok.json")):
+        d = json.load(open(f))
+        i = os.path.basename(f)[:-9]
+        sf.write(f"{a.out}/{i}.wav", S.redecode(d["tokens"], d["prompt_k"]), S.cosy.sample_rate)
+    print("REDECODE_DONE", a.out, flush=True)
+
+
+def synth(a):
+    S = Synth(a.ckpt, a.flow or None, a.sent_pause)
+    rows = [json.loads(l) for l in open(a.eval_set, encoding="utf-8")]
+    if a.only:
+        keep = set(a.only.split(",")); rows = [r for r in rows if r["id"] in keep or r["lang"] in keep]
+    if a.nper:
+        cnt, sel = {}, []
+        for r in rows:
+            if r["lang"] in ("cs", "para") or cnt.get(r["lang"], 0) < a.nper:
+                sel.append(r); cnt[r["lang"]] = cnt.get(r["lang"], 0) + 1
+        rows = sel
+    ks = [a.k] if a.k >= 0 else list(range(a.n))
+    for k in ks:
+        od = a.out if len(ks) == 1 else f"{a.out}/cand{k}"
+        os.makedirs(od, exist_ok=True)
+        for r in rows:
+            text = r["text"] if r["lang"] in ("cs", "para") else f"<{r['lang']}>{r['text']}</{r['lang']}>"
+            w = S.say(text, seed=k, prompt_k=k, stitch=not a.no_stitch, use_lm_prompt=not a.no_lm_prompt)
+            sf.write(f"{od}/{r['id']}.wav", w, S.cosy.sample_rate)
+            json.dump(dict(tokens=S.last_tokens, prompt_k=k), open(f"{od}/{r['id']}.tok.json", "w"))
+        print("synth cand", k, "done", od, flush=True)
+    print("SYNTH2_DONE", a.out, flush=True)
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("cmd")
+    ap.add_argument("--datasets", default="waxal,fleurs,slr86,slr70,bible_yor,bible_hau,cs_pairs")
+    ap.add_argument("--out", default=f"{HOME}/runs/p2_lm")
+    ap.add_argument("--init", default="")
+    ap.add_argument("--flow_init", default="")
+    ap.add_argument("--ckpt", default="")
+    ap.add_argument("--flow", default="")
+    ap.add_argument("--minutes", type=float, default=90)
+    ap.add_argument("--max_steps", type=int, default=4000)
+    ap.add_argument("--lr", type=float, default=1e-5)
+    ap.add_argument("--lr_new", type=float, default=5e-4)
+    ap.add_argument("--warmup", type=int, default=300)
+    ap.add_argument("--tokens", type=int, default=16000)
+    ap.add_argument("--adv_w", type=float, default=0.02)
+    ap.add_argument("--p_prompt", type=float, default=0.5)
+    ap.add_argument("--val_every", type=int, default=200)
+    ap.add_argument("--patience", type=int, default=5)
+    ap.add_argument("--anchor_only_w", type=float, default=0.0)
+    ap.add_argument("--select_anchor", action="store_true")
+    ap.add_argument("--eval_set", default=f"{HOME}/eval/eval_set2.jsonl")
+    ap.add_argument("--n", type=int, default=1)
+    ap.add_argument("--nper", type=int, default=0)
+    ap.add_argument("--k", type=int, default=-1)
+    ap.add_argument("--src", default="")
+    ap.add_argument("--only", default="")
+    ap.add_argument("--sent_pause", type=float, default=0.6)
+    ap.add_argument("--no_stitch", action="store_true")
+    ap.add_argument("--no_lm_prompt", action="store_true")
+    a = ap.parse_args()
+    {"lm": train_lm, "flow": train_flow, "synth": synth, "redecode": redecode}[a.cmd](a)

config.json

@@ -0,0 +1,41 @@
+{
+ "model_type": "dynamic-accent",
+ "name": "Dynamic Accent Pro v1.1",
+ "version": "1.1",
+ "task": "text-to-speech",
+ "experimental": true,
+ "languages": [
+  "en",
+  "pcm",
+  "yo",
+  "ig",
+  "ha"
+ ],
+ "default_version": "flash",
+ "versions": [
+  "pro",
+  "flash"
+ ],
+ "voices": [
+  "anchor_male",
+  "waxal_ibo_5_female",
+  "waxal_yor_5_female"
+ ],
+ "controls": {
+  "instruct": "natural-language style instruction (--instruct)",
+  "codeswitch_prompt": "optional text-LLM code-switch step (--codeswitch_prompt)"
+ },
+ "settings": "settings.json",
+ "entrypoints": {
+  "cli": "infer.py"
+ },
+ "base_models": [
+  "FunAudioLLM/Fun-CosyVoice3-0.5B-2512"
+ ],
+ "codeswitch_llm": "Qwen/Qwen3-32B (Apache-2.0), optional",
+ "licence": {
+  "weights_prompts_samples": "CC-BY-SA-4.0 (LICENSE)",
+  "code": "Apache-2.0 (LICENSE-CODE)"
+ },
+ "note": "Repo-level manifest (lets the Hub count downloads). Runtime settings live in settings.json; per-checkpoint configs under checkpoints/. Default: flash; --instruct switches to pro unless --version is given."
+}

cosyvoice_requirements.txt

@@ -0,0 +1,42 @@
+--extra-index-url https://download.pytorch.org/whl/cu121
+--extra-index-url https://aiinfra.pkgs.visualstudio.com/PublicPackages/_packaging/onnxruntime-cuda-12/pypi/simple/ # https://github.com/microsoft/onnxruntime/issues/21684
+conformer==0.3.2
+deepspeed==0.15.1; sys_platform == 'linux'
+diffusers==0.29.0
+fastapi==0.115.6
+fastapi-cli==0.0.4
+gdown==5.1.0
+gradio==5.4.0
+grpcio==1.57.0
+grpcio-tools==1.57.0
+hydra-core==1.3.2
+HyperPyYAML==1.2.3
+inflect==7.3.1
+librosa==0.10.2
+lightning==2.2.4
+matplotlib==3.7.5
+modelscope==1.20.0
+networkx==3.1
+numpy==1.26.4
+omegaconf==2.3.0
+onnx==1.16.0
+onnxruntime-gpu==1.18.0; sys_platform == 'linux'
+onnxruntime==1.18.0; sys_platform == 'darwin' or sys_platform == 'win32'
+openai-whisper==20231117
+protobuf==4.25
+pyarrow==18.1.0
+pydantic==2.7.0
+pyworld==0.3.4
+rich==13.7.1
+soundfile==0.12.1
+tensorboard==2.14.0
+tensorrt-cu12==10.13.3.9; sys_platform == 'linux'
+tensorrt-cu12-bindings==10.13.3.9; sys_platform == 'linux'
+tensorrt-cu12-libs==10.13.3.9; sys_platform == 'linux'
+torch==2.3.1
+torchaudio==2.3.1
+transformers==4.51.3
+x-transformers==2.11.24
+uvicorn==0.30.0
+wetext==0.0.4
+wget==3.2

cs_frontend.py

@@ -0,0 +1,187 @@
+"""Code-switch text front end (pipeline step, NOT native model capability).
+
+Turns a plain sentence + a code-switch request ("mostly English, Igbo greetings") into language-tagged text
+(<eng>..</eng> <ibo>..</ibo>) that the TTS then speaks. Uses a permissively licensed text LLM:
+default Qwen/Qwen3-14B (Apache-2.0), thinking disabled. N-ATLaS was not used: its terms cap use at 1,000 active
+users and require a commercial licence beyond that.
+
+Safety rails (MADLAD looped in Flash): max_new_tokens tied to input length, repetition_penalty, no_repeat_ngram,
+output validation (tags only from allowed set, full coverage, length ratio, n-gram repetition cap), up to 2 retries,
+then a safe fallback (the input as single-language text) with a warning.
+"""
+import re, os, json
+from collections import Counter
+
+LANGS = {"eng": "English", "ibo": "Igbo", "yor": "Yoruba", "hau": "Hausa", "pcm": "Nigerian Pidgin"}
+SYS = """You rewrite text for a Nigerian text-to-speech system as natural code-switched speech.
+Follow the user's code-switch request exactly (which languages, how much of each, which parts).
+Rules:
+- Keep the meaning. Do not add new information, greetings or sentences that the request does not ask for.
+- Write Igbo, Yoruba and Hausa in standard orthography (use tone marks/diacritics for Yoruba and Igbo if you can).
+- Wrap every span in a language tag: <eng>...</eng>, <ibo>...</ibo>, <yor>...</yor>, <hau>...</hau>, <pcm>...</pcm>.
+- Nothing may appear outside tags. Output ONLY the tagged text on one line, no explanations.
+- Prefer these common, correct phrases when greetings/thanks/closings are requested:
+  Igbo: Ndewo (hello), Ụtụtụ ọma (good morning), Ehihie ọma (good afternoon), Mgbede ọma (good evening), Kedu? (how are you), Daalụ (thank you), Nnọọ (welcome), Ka ọ dị (goodbye)
+  Yoruba: Ẹ káàárọ̀ (good morning), Ẹ káàsán (good afternoon), Ẹ kú ìrọ̀lẹ́ (good evening), Ẹ kú àbọ̀ (welcome), Ẹ ṣé (thank you), Ó dàbọ̀ (goodbye)
+  Hausa: Sannu (hello), Barka da safiya (good morning), Barka da yamma (good evening), Maraba (welcome), Na gode (thank you), Sai an jima (goodbye)
+  Nigerian Pidgin: How far (hello), Abeg (please), Thank you well well, We go see later (goodbye)
+- If you cannot translate a part reliably, keep that part in English rather than guessing."""
+SHOT_U = "Request: mostly English, Igbo greetings and closing\nText: Good morning everyone. The meeting starts at ten, please be on time. Thank you."
+SHOT_A = "<ibo>Ụtụtụ ọma, unu niile.</ibo> <eng>The meeting starts at ten, please be on time.</eng> <ibo>Daalụ.</ibo>"
+
+TAG = re.compile(r"<(eng|ibo|yor|hau|pcm)>(.*?)</\1>", re.S)
+
+
+def requested_langs(req):
+    r = req.lower()
+    out = {k for k, v in LANGS.items() if v.lower().split()[-1] in r or k in r}
+    if "pidgin" in r:
+        out.add("pcm")
+    return out or {"eng"}
+
+
+def validate(out, src, allowed):
+    out = out.strip()
+    spans = TAG.findall(out)
+    if not spans:
+        return False, "no tags"
+    rest = TAG.sub(" ", out).strip()
+    if re.sub(r"[\s.,!?;:'\"-]", "", rest):
+        return False, f"text outside tags: {rest[:40]}"
+    bad = {l for l, _ in spans} - allowed - {"eng"}
+    if bad:
+        return False, f"unrequested language {bad}"
+    words = " ".join(t for _, t in spans).split()
+    n_src = len(src.split())
+    if not (0.4 * n_src <= len(words) <= 2.5 * n_src + 6):
+        return False, f"length ratio {len(words)}/{n_src}"
+    low = [w.lower().strip(".,!?") for w in words]
+    for k in range(len(low) - 3):
+        if low[k] == low[k + 1] == low[k + 2] == low[k + 3]:
+            return False, "word loop"
+    tri = Counter(tuple(low[i:i + 3]) for i in range(len(low) - 2))
+    if tri and tri.most_common(1)[0][1] > 2:
+        return False, "trigram loop"
+    if any(not t.strip() for _, t in spans):
+        return False, "empty span"
+    return True, "ok"
+
+
+def chrf(hyp, ref, n=6, beta=2.0):
+    def grams(s, k):
+        s = " ".join(s.lower().split())
+        return Counter(s[i:i + k] for i in range(len(s) - k + 1))
+    P, R = [], []
+    for k in range(1, n + 1):
+        h, r = grams(hyp, k), grams(ref, k)
+        if not h or not r:
+            continue
+        m = sum((h & r).values())
+        P.append(m / sum(h.values())); R.append(m / sum(r.values()))
+    if not P:
+        return 0.0
+    p, r = sum(P) / len(P), sum(R) / len(R)
+    return 0.0 if p + r == 0 else 100 * (1 + beta ** 2) * p * r / (beta ** 2 * p + r)
+
+
+class CodeSwitchFrontEnd:
+    def __init__(self, model=os.environ.get("CS_LLM", "Qwen/Qwen3-14B"), device="cuda", cache_dir=None, diac=None):
+        import torch
+        from transformers import AutoTokenizer, AutoModelForCausalLM
+        self.torch = torch
+        self.tok = AutoTokenizer.from_pretrained(model, cache_dir=cache_dir)
+        self.lm = AutoModelForCausalLM.from_pretrained(model, torch_dtype=torch.bfloat16, cache_dir=cache_dir).to(device).eval()
+        self.device = device
+        self.diac = diac          # optional flash FrontEnd (ByT5 diacritic restoration) for ibo/yor spans
+
+    def _gen(self, req, text, temp):
+        msgs = [{"role": "system", "content": SYS}, {"role": "user", "content": SHOT_U}, {"role": "assistant", "content": SHOT_A},
+                {"role": "user", "content": f"Request: {req}\nText: {text}"}]
+        try:
+            p = self.tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True, enable_thinking=False)
+        except TypeError:
+            p = self.tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)
+        ids = self.tok(p, return_tensors="pt").to(self.device)
+        n_in = len(self.tok(text)["input_ids"])
+        # repetition rails act on the GENERATED tokens only (a prompt-wide no_repeat_ngram/repetition_penalty
+        # forbids copying the input and garbles spelling): hard length cap + loop stop + validation below
+        from transformers import StoppingCriteria, StoppingCriteriaList
+        P0 = ids["input_ids"].shape[1]
+
+        class LoopStop(StoppingCriteria):
+            def __call__(s_, input_ids, scores, **k):
+                g = input_ids[0, P0:].tolist()
+                if len(g) < 18:
+                    return False
+                tail = tuple(g[-6:])
+                hits = sum(1 for i in range(len(g) - 6) if tuple(g[i:i + 6]) == tail)
+                return hits >= 2
+        kw = dict(max_new_tokens=int(3 * n_in + 48), pad_token_id=self.tok.eos_token_id,
+                  stopping_criteria=StoppingCriteriaList([LoopStop()]))
+        if temp > 0:
+            kw.update(do_sample=True, temperature=temp, top_p=0.9)
+        else:
+            kw.update(do_sample=False, temperature=None, top_p=None, top_k=None)
+        with self.torch.no_grad():
+            o = self.lm.generate(**ids, **kw)
+        s = self.tok.decode(o[0, ids["input_ids"].shape[1]:], skip_special_tokens=True)
+        s = re.sub(r"<think>.*?</think>", "", s, flags=re.S).strip().splitlines()
+        return s[0].strip() if s else ""
+
+    def back_translate(self, span, lang):
+        msgs = [{"role": "user", "content": f"Translate this {LANGS[lang]} text into English. Output only the translation.\n\n{span}"}]
+        try:
+            p = self.tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True, enable_thinking=False)
+        except TypeError:
+            p = self.tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)
+        ids = self.tok(p, return_tensors="pt").to(self.device)
+        with self.torch.no_grad():
+            o = self.lm.generate(**ids, max_new_tokens=3 * len(span.split()) + 24, do_sample=False, temperature=None,
+                                 top_p=None, top_k=None, pad_token_id=self.tok.eos_token_id)
+        return self.tok.decode(o[0, ids["input_ids"].shape[1]:], skip_special_tokens=True).strip()
+
+    def meaning_check(self, out, src, thr=45.0):
+        """round trip: back-translate every non-English span; the English reconstruction must match the input (chrF)."""
+        parts = [t if l == "eng" else self.back_translate(t, l) for l, t in TAG.findall(out)]
+        back = " ".join(parts)
+        score = min(chrf(back, src), chrf(back, src, beta=0.5))   # recall- and precision-weighted (added content fails)
+        return score >= thr, round(score, 1), back
+
+    def __call__(self, text, req, fallback_lang="eng"):
+        allowed = requested_langs(req)
+        log = []
+        for k, temp in enumerate((0.0, 0.6, 0.8)):      # first try + at most 2 retries
+            out = self._gen(req, text, temp)
+            ok, why = validate(out, text, allowed)
+            rt = None
+            if ok:
+                ok, sc, back = self.meaning_check(out, text)
+                rt = dict(chrf=sc, back=back[:300])
+                if not ok:
+                    why = f"meaning drift (round-trip chrF {sc})"
+            log.append(dict(try_=k, ok=ok, why=why, out=out[:300], roundtrip=rt))
+            if ok:
+                if self.diac is not None:
+                    out = TAG.sub(lambda m: f"<{m.group(1)}>{self.diac.diacritise(m.group(2), m.group(1)) if m.group(1) in ('ibo', 'yor') else m.group(2)}</{m.group(1)}>", out)
+                return out, dict(ok=True, tries=log)
+        return f"<{fallback_lang}>{text}</{fallback_lang}>", dict(ok=False, tries=log, warning="code-switch front end failed validation; spoke the input as-is")
+
+
+if __name__ == "__main__":
+    import sys
+    cache = os.environ.get("HF_CACHE")
+    fe = CodeSwitchFrontEnd(cache_dir=cache)
+    tests = json.load(open(sys.argv[1])) if len(sys.argv) > 1 else [
+        ["Good morning everyone, welcome to the market. Prices are good today, come and buy.", "mostly English, Igbo greetings"],
+        ["Please call your mother tonight, she has been waiting to hear from you.", "Igbo sentence with a few English words"],
+        ["Welcome to our shop. Everything is half price this weekend, so tell your friends.", "Yoruba greeting, the rest in English"],
+        ["Good evening. The rain will be heavy tomorrow, so carry an umbrella.", "half Hausa, half English"],
+        ["My brother, the work is too much today, but we will finish it.", "Nigerian Pidgin mixed with Igbo"],
+        ["Thank you for coming. We will start the program in five minutes.", "English with a Yoruba closing"],
+    ]
+    res = []
+    for t, r in tests:
+        o, info = fe(t, r)
+        res.append(dict(text=t, request=r, out=o, ok=info["ok"], tries=len(info["tries"]), log=info["tries"]))
+        print(json.dumps(res[-1], ensure_ascii=False), flush=True)
+    json.dump(res, open(os.environ.get("CS_OUT", "cs_test.json"), "w"), ensure_ascii=False, indent=1)

flash_instruct.py

@@ -0,0 +1,433 @@
+"""Flash-Instruct: natural-language instruction control for the Flash-DPO CosyVoice3 LM.
+
+The CV3 system-prompt slot ("You are a helpful assistant.<|endofprompt|>") becomes an instruction, e.g.
+"Speak in an Igbo-English mix, slowly, with plenty of pauses." Labels come from label.py (audio-derived).
+~18% of training items keep the original default prompt (and the original rate embedding), so default behaviour is kept.
+Instruction items use rate embedding 0 (none): the instruction carries pace.
+
+  python flash_instruct.py train --init ~/flash/runs/flash_dpo/best.pt --out /scratch/fi_run
+  python flash_instruct.py gen --lm CKPT --out DIR --voice anchor [--instruct "..."] [--rows ROWS] [--shard i/n]
+  python flash_instruct.py adh --lm CKPT --out DIR --voice anchor --shard i/n      (adherence grid)
+"""
+import argparse, json, math, os, random, sys, time
+import numpy as np, torch, torch.nn.functional as F, soundfile as sf
+HOME = os.path.expanduser("~")
+_HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path[:0] = [_HERE]
+import flash_lm as FL  # noqa: E402
+import instruct_text as IT  # noqa: E402
+
+EOP = 151646  # <|endofprompt|>
+# extra source weights on top of flash_lm.FLASH_W (natural/spontaneous speech up, Bible narration down)
+MIXW = {"igbosyncorp": 2.0, "igbosyn_pseudo": 1.5, "naijas2st_igbo": 1.5, "open_bible_igbo": 0.5, "bible_hau": 0.5,
+        "bible_yor": 0.5}
+
+
+PI = {"few": 1, "normal": 2, "many": 3}
+EI = {"calm": 1, "neutral": 2, "lively": 3}
+RI = {"slow": FL.R2I["slow"], "normal": FL.R2I["normal"], "fast": FL.R2I["fast"]}
+
+
+def add_ctrl(model, d=896):
+    """explicit control embeddings (pause, energy) added to the speaker vector next to the existing rate embedding."""
+    import torch.nn as nn
+    if not hasattr(model, "pause_emb"):
+        model.pause_emb = nn.Embedding(4, d, padding_idx=0).cuda(); nn.init.zeros_(model.pause_emb.weight)
+        model.energy_emb = nn.Embedding(4, d, padding_idx=0).cuda(); nn.init.zeros_(model.energy_emb.weight)
+    return model
+
+
+def parse_controls(instr):
+    """keyword parser: natural-language instruction -> (rate, pause, energy) control ids (0 = not requested)."""
+    t = (instr or "").lower()
+    def has(*w):
+        return any(x in t for x in w)
+    rate = RI["slow"] if has("slow", "unhurried", "take your time", "taking your time", "deliberate") else \
+        RI["fast"] if has("fast", "quick", "brisk", "rapid", "hurr") else RI["normal"] if has("natural pace", "normal pace", "steady pace", "comfortable pace", "everyday pace") else 0
+    pause = PI["few"] if has("few pause", "no pause", "hardly any pause", "without stopping", "one smooth flow", "minimal paus", "running the phrases") else \
+        PI["many"] if has("plenty of pause", "many pause", "lots of pause", "pausing often", "frequent pause", "deliberate pause", "breaks between", "more pause") else \
+        PI["normal"] if has("natural pause", "normal phrasing") else 0
+    energy = EI["calm"] if has("calm", "gentle", "soft", "relaxed", "low-key", "quiet", "even-toned", "even tone") else \
+        EI["lively"] if has("lively", "animated", "energetic", "expressive", "upbeat", "excited", "bright") else \
+        EI["neutral"] if has("neutral", "matter-of-fact", "plain") else 0
+    return rate, pause, energy
+
+
+class IFLM(FL.FLM):
+    """FLM whose system-prompt prefix can be set per item (self._pre); optional pause/energy control embeddings."""
+    _pre = None
+    ctrl_scale = 1.0
+
+    def spkvec(self, spk):
+        v = self.spk_emb(spk[0]) + self.rate_emb(spk[1])
+        if hasattr(self, "pause_emb") and spk.shape[0] > 2:
+            v = v + self.ctrl_scale * (self.pause_emb(spk[2]) + self.energy_emb(spk[3]))
+        return v
+
+    def build(self, ids, langs, spk, sp=None, pids=None, plangs=None, psp=None):
+        E = self.q.speech_embedding.weight
+        if pids is not None:
+            ids = torch.cat([pids, ids]); langs = torch.cat([plangs, langs])
+        pfx = self._pre if self._pre is not None else self.prefix
+        pre = self.q.llm.model.model.embed_tokens(pfx.to(ids.device))
+        parts = [E[self.q.sos][None], pre, self.embed_text(ids, langs), self.spkvec(spk)[None], E[self.q.task_id][None]]
+        npsp = 0
+        if psp is not None:
+            parts.append(self.q.speech_embedding(psp)); npsp = len(psp)
+        if sp is not None:
+            parts.append(self.q.speech_embedding(sp))
+        return torch.cat(parts, 0), len(pre), len(ids), npsp
+
+    def pack(self, batch):
+        seqs, tgts, tpos, spks = [], [], [], []
+        for b in batch:
+            ids, langs, spk, sp = b[:4]
+            pr = b[4] if len(b) > 4 else None
+            self._pre = b[5] if len(b) > 5 else None
+            x, P, nt, npsp = self.build(ids, langs, spk, sp, *(pr if pr else (None, None, None)))
+            self._pre = None
+            tgt = torch.full((x.shape[0] + 1,), -100, device=x.device, dtype=torch.long)
+            start = P + nt + 2 + npsp
+            tgt[start: start + len(sp)] = sp
+            tgt[start + len(sp)] = self.EOS
+            seqs.append(x); tgts.append(tgt[:x.shape[0]]); tpos.append((1 + P, 1 + P + nt)); spks.append(int(spk[0]))
+        Tm = max(s.shape[0] for s in seqs); D = seqs[0].shape[1]
+        X = seqs[0].new_zeros(len(seqs), Tm, D)
+        Y = torch.full((len(seqs), Tm), -100, device=X.device, dtype=torch.long)
+        M = torch.zeros(len(seqs), Tm, device=X.device, dtype=torch.long)
+        for i, (s, t) in enumerate(zip(seqs, tgts)):
+            X[i, :len(s)] = s; Y[i, :len(t)] = t; M[i, :len(s)] = 1
+        return X, Y, M, tpos, spks
+
+
+@torch.no_grad()
+def generate_cfg(m, ids, langs, spk_c, spk_u, pre_c, prompt=None, g=1.5, top_p=0.8, top_k=25, win=10, tau_r=0.1, seed=0,
+                 min_ratio=2.0, max_ratio=30.0, max_tok=900):
+    """classifier-free guidance on the instruction: logp = lp_cond + g * (lp_cond - lp_default).
+    cond = instruction prefix + controls; uncond = the default prompt, no controls. Same silexcap sampler as Flash."""
+    gen = torch.Generator(device=ids.device).manual_seed(seed)
+    m._pre = pre_c
+    xc, _, _, _ = m.build(ids, langs, spk_c, None, *(prompt if prompt else (None, None, None)))
+    m._pre = None
+    xu, _, _, _ = m.build(ids, langs, spk_u, None, *(prompt if prompt else (None, None, None)))
+    n = len(ids); min_len, max_len = int(n * min_ratio), min(int(n * max_ratio), max_tok)
+    E = m.q.speech_embedding.weight
+    pc = pu = None; ic, iu = xc[None], xu[None]; out = []
+    for i in range(max_len):
+        oc = m.q.llm.model.model(inputs_embeds=ic, past_key_values=pc, use_cache=True, return_dict=True); pc = oc.past_key_values
+        ou = m.q.llm.model.model(inputs_embeds=iu, past_key_values=pu, use_cache=True, return_dict=True); pu = ou.past_key_values
+        lc = m.q.llm_decoder(oc.last_hidden_state[:, -1]).float().log_softmax(-1)[0]
+        lu = m.q.llm_decoder(ou.last_hidden_state[:, -1]).float().log_softmax(-1)[0]
+        logp = (lc + g * (lc - lu)).log_softmax(-1)
+        eos_lp = logp[m.EOS].clone()
+        logp[m.V:] = -float("inf")
+        if i >= min_len:
+            logp[m.EOS] = eos_lp
+        p = logp.exp(); p = p / p.sum()
+        sp_, si = p.sort(descending=True)
+        keep = (sp_.cumsum(0) - sp_) < top_p; keep[top_k:] = False
+        cp, ci = sp_[keep], si[keep]
+        t = int(ci[torch.multinomial(cp / cp.sum(), 1, generator=gen)])
+        exempt = False
+        if t in FL.SIL:
+            run = 0
+            for u in reversed(out):
+                if u not in FL.SIL:
+                    break
+                run += 1
+            exempt = run < 25
+        if not exempt and out and t != m.EOS and sum(1 for u in out[-win:] if u == t) >= win * tau_r:
+            t = int(torch.multinomial(p, 1, generator=gen))
+        if t >= m.V:
+            break
+        out.append(t)
+        nx = E[torch.tensor([t], device=ids.device)][:, None]
+        ic = iu = nx
+    return [out]
+
+
+def pre_ids(tok, instruct):
+    return tok.t.encode(instruct or IT.DEFAULT) + [EOP]
+
+
+def train(a):
+    cosy = FL.load_cv3(); tok = FL.Tok(cosy)
+    model, spk2id = FL.load_model(cosy, a.init, tok)
+    model.__class__ = IFLM
+    if a.ctrl:
+        add_ctrl(model)
+    model.train()
+    L = {}
+    for l in open(a.labels, encoding="utf-8"):
+        x = json.loads(l); L[x["id"]] = x
+    items, mm = FL.load_data({"train"}, a.max_tok, a.extra_man, a.qual, a.qual_drop)
+    items = [m for m in items if m["spk"] in spk2id and not m["src"].startswith("av_")]
+    # ACE add-on: cleaner + more native mix. drop noisy/low-SNR/clipped clips; up-weight natural speech, down-weight Bible
+    MX = json.load(open(a.mix)) if a.mix and os.path.exists(a.mix) else {"drop": [], "elig": []}
+    drop, elig = set(MX["drop"]), set(MX["elig"])
+    n0 = len(items)
+    items = [m for m in items if m["id"] not in drop]
+    for m in items:
+        m["w"] *= MIXW.get(m["src"], 1.0)
+    n_el = sum(m["id"] in elig for m in items)
+    p_def_e = min(0.6, a.p_default * len(items) / max(1, n_el))
+    hrs = {}
+    for m in items:
+        hrs[m["src"]] = hrs.get(m["src"], 0) + m["dur"] * m["w"] / 3600
+    print("mix: dropped", n0 - len(items), "default-eligible", n_el, "p_default_eligible", round(p_def_e, 3),
+          "effective weighted hours", {k: round(v, 1) for k, v in sorted(hrs.items())}, flush=True)
+    val_all, mmv = FL.load_data(FL.VAL_SPLITS, a.max_tok, None)
+    mm.update(mmv)
+    rng = random.Random(1); rng.shuffle(val_all)
+    val, per_l = [], {}
+    for m in val_all:
+        if m["spk"] not in spk2id or m["lang"] == "cs" or m["id"] not in L or m["src"].startswith("av_"):
+            continue
+        if per_l.get(m["lang"], 0) >= 50:
+            continue
+        per_l[m["lang"]] = per_l.get(m["lang"], 0) + 1; val.append(m)
+    nl = sum(m["id"] in L for m in items)
+    print("items", len(items), "labelled", nl, "val", len(val), per_l, flush=True)
+    by_spk = {}
+    for m in items:
+        if m["ntok"] <= 200 and m["lang"] != "cs":
+            by_spk.setdefault(m["spk"], []).append(m)
+    for p in list(cosy.model.flow.parameters()) + list(cosy.model.hift.parameters()):
+        p.requires_grad = False
+    new = list(model.lang_emb.parameters()) + list(model.spk_emb.parameters()) + list(model.adv.parameters()) + list(model.rate_emb.parameters())
+    ctl = list(model.pause_emb.parameters()) + list(model.energy_emb.parameters()) if a.ctrl else []
+    newids = {id(p) for p in new + ctl}
+    old = [p for p in model.parameters() if id(p) not in newids and p.requires_grad]
+    groups = [{"params": old, "lr": a.lr}, {"params": new, "lr": a.lr_new}]
+    base = [a.lr, a.lr_new]
+    if ctl:
+        groups.append({"params": ctl, "lr": a.lr_ctrl}); base.append(a.lr_ctrl)
+    opt = torch.optim.AdamW(groups, weight_decay=0.01)
+    os.makedirs(a.out, exist_ok=True)
+    json.dump(spk2id, open(f"{a.out}/spk2id.json", "w")); json.dump(vars(a), open(f"{a.out}/args.json", "w"))
+    pcache = {}
+
+    def P_(s):
+        if s not in pcache:
+            pcache[s] = torch.tensor(pre_ids(tok, s)).cuda()
+        return pcache[s]
+
+    def full_labels(m):
+        x = L.get(m["id"])
+        if not x:
+            return None
+        return dict(lang=x["lang"], rate=x["rate"], pause=x["pause"], energy=x["energy"], gender=x["gender"])
+
+    def enc(m, r, mode="sample", shuf=None):
+        """mode: sample (train) | default | inst (fixed rng) ; shuf=labels from another item (diagnostic)."""
+        text = m["tags"] if (m["tags"] and r.random() >= a.tag_drop) else FL.strip_tags(m["text"])
+        ids, langs = tok(FL.tagged(text, m["lang"]))
+        lab = shuf if shuf is not None else full_labels(m)
+        # DEFAULT prompt only on native-like clips (pace and pauses close to real native speech), so the
+        # no-instruction behaviour moves toward native pace/pauses; other clips always carry an instruction
+        use_def = mode == "default" or lab is None or (mode == "sample" and m["id"] in elig and r.random() < p_def_e)
+        pc = ec = 0
+        if use_def:
+            rate = m["rate"] if (mode != "sample" or r.random() >= a.rate_drop) else 0
+            instr = IT.DEFAULT
+        else:
+            sub = IT.sample_labels(lab, r) if mode == "sample" else {k: v for k, v in lab.items() if k != "gender"}
+            instr = IT.make(sub, r)
+            rate = 0
+            if a.ctrl:   # the instruction's controls also go in as explicit embeddings (what it mentions, nothing else)
+                rate = RI.get(sub.get("rate"), 0); pc = PI.get(sub.get("pause"), 0); ec = EI.get(sub.get("energy"), 0)
+        sp = np.asarray(mm[m["ds"]][m["toff"]: m["toff"] + m["ntok"]], dtype=np.int64)
+        spk_t = [spk2id[m["spk"]], rate] + ([pc, ec] if a.ctrl else [])
+        out = [torch.tensor(ids).cuda(), torch.tensor(langs).cuda(), torch.tensor(spk_t).cuda(),
+               torch.from_numpy(sp).cuda(), None, P_(instr)]
+        if r.random() < a.p_prompt:
+            c = by_spk.get(m["spk"], [])
+            c = [x for x in r.sample(c, min(6, len(c))) if x["id"] != m["id"]] if c else []
+            if c and c[0]["ntok"] + m["ntok"] <= a.max_tok + 150:
+                p = c[0]
+                pids, plangs = tok(FL.tagged(FL.strip_tags(p["text"]), p["lang"]))
+                psp = np.asarray(mm[p["ds"]][p["toff"]: p["toff"] + p["ntok"]], dtype=np.int64)
+                out[4] = (torch.tensor(pids).cuda(), torch.tensor(plangs).cuda(), torch.from_numpy(psp).cuda())
+        return out
+
+    def validate():
+        model.eval(); res = {}
+        with torch.no_grad(), torch.autocast("cuda", dtype=torch.bfloat16):
+            for mode in ("default", "inst", "shuf"):
+                vr = random.Random(7); sr_ = random.Random(9); Ls, W = [], []
+                for i in range(0, len(val), 16):
+                    bt = val[i:i + 16]
+                    if mode == "shuf":
+                        b = [enc(m, vr, "inst", shuf=full_labels(sr_.choice(val))) for m in bt]
+                    else:
+                        b = [enc(m, vr, mode) for m in bt]
+                    ce, _, _, _ = model.forward2(b)
+                    Ls.append(float(ce) * len(bt)); W.append(len(bt))
+                res[mode] = sum(Ls) / sum(W)
+        model.train()
+        res["inst_gain"] = res["shuf"] - res["inst"]   # >0: the instruction carries information the model uses
+        res["mean"] = (res["default"] + res["inst"]) / 2
+        return res
+
+    wfn = lambda m: m["w"]  # noqa
+    cost = lambda m: (lambda Lq: int(Lq * (1 + Lq / a.quad)))(m["ntok"] + len(m["text"]) // 2 + 40 + int(a.p_prompt * 200))  # noqa
+    rng = random.Random(0); prng = random.Random(3)
+    step, nskip, t0 = 0, 0, time.time()
+    logf = open(f"{a.out}/log.jsonl", "a")
+    v = validate(); best = v["mean"]; bad = 0
+    print(json.dumps({"step": 0, "val": v}), flush=True); logf.write(json.dumps({"step": 0, "val": v}) + "\n")
+    total, done = a.max_steps, False
+    while not done:
+        for bi in FL.batches(items, a.tokens, rng, wfn, cost):
+            lrm = min(1.0, (step + 1) / a.warmup) * (0.1 + 0.9 * 0.5 * (1 + math.cos(math.pi * min(1.0, step / total))))
+            for gp, b in zip(opt.param_groups, base):
+                gp["lr"] = b * lrm
+            batch = [enc(items[i], prng) for i in bi]
+            opt.zero_grad(set_to_none=True)
+            try:
+                with torch.autocast("cuda", dtype=torch.bfloat16):
+                    ce, acc, adv, adv_acc = model.forward2(batch, adv_lambda=1.0)
+                loss = ce + a.adv_w * adv
+                if not torch.isfinite(loss):
+                    nskip += 1; continue
+                loss.backward()
+            except torch.cuda.OutOfMemoryError:
+                batch = None; opt.zero_grad(set_to_none=True); torch.cuda.empty_cache(); nskip += 1; continue
+            gn = torch.nn.utils.clip_grad_norm_([p for p in model.parameters() if p.requires_grad], 1.0)
+            if not torch.isfinite(gn):
+                nskip += 1; opt.zero_grad(set_to_none=True); continue
+            opt.step(); step += 1
+            if step % 50 == 0:
+                r = dict(step=step, ce=round(float(ce), 4), acc=round(float(acc), 4), gn=round(float(gn), 2), B=len(bi),
+                         skips=nskip, min=round((time.time() - t0) / 60, 2))
+                print(json.dumps(r), flush=True); logf.write(json.dumps(r) + "\n"); logf.flush()
+            if step % a.val_every == 0:
+                v = validate(); imp = v["mean"] < best - 1e-4
+                print(json.dumps({"step": step, "val": v, "best": imp}), flush=True)
+                logf.write(json.dumps({"step": step, "val": v, "best": imp}) + "\n"); logf.flush()
+                torch.save(dict(model=model.state_dict(), step=step, n_spk=len(spk2id), val=v), f"{a.out}/last.pt")
+                if imp:
+                    best, bad = v["mean"], 0
+                    os.replace(f"{a.out}/last.pt", f"{a.out}/best.pt")
+                else:
+                    bad += 1
+                    if bad >= a.patience:
+                        print("EARLY_STOP", step, flush=True); done = True; break
+            if (time.time() - t0) / 60 > a.minutes or step >= total:
+                done = True; break
+    print("TRAIN_FI_DONE", step, "best", best, "skips", nskip, flush=True)
+
+
+class ISynth(FL.Synth):
+    cfg = 0.0      # classifier-free guidance strength on the instruction (0 = off)
+
+    def __init__(self, lm_ckpt, ctrl_scale=1.0, cfg=0.0):
+        super().__init__(lm_ckpt)
+        self.cfg = cfg
+        self.m.__class__ = IFLM
+        sd = torch.load(lm_ckpt, map_location="cuda", weights_only=False)["model"]
+        self.ctrl = "pause_emb.weight" in sd
+        if self.ctrl:
+            add_ctrl(self.m)
+            self.m.pause_emb.weight.data.copy_(sd["pause_emb.weight"]); self.m.energy_emb.weight.data.copy_(sd["energy_emb.weight"])
+            self.m.ctrl_scale = ctrl_scale
+        del sd
+
+    text_pauses = True   # pipeline step: "few/many pauses" also edits the text ([pause] tags / commas), see pause_text.py
+
+    def tokens(self, text, voice="anchor", rate="normal", seed=0, B=1, sampler="silexcap", instruct=None):
+        ptok, pfeat, emb, lmp, sid = self.voice(voice)
+        if instruct and instruct != IT.DEFAULT and self.text_pauses:
+            import pause_text
+            pc_ = parse_controls(instruct)[1]
+            if pc_ in (PI["few"], PI["many"]):
+                text = pause_text.apply(text, "few" if pc_ == PI["few"] else "many")
+        ids, langs = self.tok(text)
+        if instruct and instruct != IT.DEFAULT:
+            self.m._pre = torch.tensor(pre_ids(self.tok, instruct)).cuda()
+            rc, pc, ec = parse_controls(instruct) if self.ctrl else (0, 0, 0)
+            spk = [sid, rc] + ([pc, ec] if self.ctrl else [])
+        else:
+            self.m._pre = None
+            spk = [sid, FL.R2I.get(None if rate == "none" else rate, 0)] + ([0, 0] if self.ctrl else [])
+        try:
+            if self.cfg > 0 and self.m._pre is not None and B == 1:
+                spk_u = [sid, FL.R2I["normal"]] + ([0, 0] if self.ctrl else [])
+                with torch.autocast("cuda", dtype=torch.bfloat16):
+                    return generate_cfg(self.m, torch.tensor(ids).cuda(), torch.tensor(langs).cuda(), torch.tensor(spk).cuda(),
+                                        torch.tensor(spk_u).cuda(), self.m._pre, prompt=lmp, g=self.cfg, seed=seed)
+            with torch.autocast("cuda", dtype=torch.bfloat16):
+                return self.m.generate(torch.tensor(ids).cuda(), torch.tensor(langs).cuda(), torch.tensor(spk).cuda(),
+                                       prompt=lmp, B=B, seed=seed, sampler=sampler)
+        finally:
+            self.m._pre = None
+
+
+ADH = {  # condition -> instruction (held-out phrasings, not verbatim training templates)
+    "default": IT.DEFAULT,
+    "slow": "Please speak slowly and take your time.",
+    "fast": "Speak fast, like a quick everyday conversation.",
+    "few_pauses": "Say it in one smooth flow with hardly any pauses.",
+    "many_pauses": "Speak with plenty of pauses between phrases.",
+    "calm": "Use a calm, gentle, even tone.",
+    "lively": "Sound lively and expressive.",
+}
+
+
+def gen(a):
+    S = ISynth(a.lm, a.ctrl_scale, a.cfg); S.text_pauses = not a.no_text_pauses
+    rows = [json.loads(l) for l in open(a.rows, encoding="utf-8")]
+    if a.shard:
+        i, n = map(int, a.shard.split("/")); rows = rows[i::n]
+    os.makedirs(a.out, exist_ok=True)
+    json.dump(vars(a), open(f"{a.out}/variant.json", "w"))
+    for r in rows:
+        if os.path.exists(f"{a.out}/{r['id']}.wav"):
+            continue
+        text = r.get("tts_text") or FL.item_text(r)
+        toks = S.tokens(text, a.voice, a.rate, a.seed, instruct=r.get("instruct", a.instruct))[0]
+        sf.write(f"{a.out}/{r['id']}.wav", S.wav(toks, a.voice), S.cosy.sample_rate)
+    print("GEN_DONE", a.out, len(rows), flush=True)
+
+
+def adh(a):
+    """adherence grid: each held-out row x each condition in ADH -> OUT/<cond>/<id>.wav"""
+    S = ISynth(a.lm, a.ctrl_scale, a.cfg); S.text_pauses = not a.no_text_pauses
+    rows = [json.loads(l) for l in open(a.rows, encoding="utf-8")]
+    C = a.conds.split(",") if a.conds else list(ADH)
+    jobs = [(c, r) for r in rows for c in C]
+    i, n = map(int, a.shard.split("/")); jobs = jobs[i::n]
+    for c, r in jobs:
+        d = f"{a.out}/{c}"; os.makedirs(d, exist_ok=True)
+        if os.path.exists(f"{d}/{r['id']}.wav"):
+            continue
+        text = r.get("tts_text") or FL.item_text(r)
+        toks = S.tokens(text, a.voice, "normal", a.seed, instruct=ADH[c])[0]
+        sf.write(f"{d}/{r['id']}.wav", S.wav(toks, a.voice), S.cosy.sample_rate)
+    print("ADH_DONE", i, flush=True)
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("cmd"); ap.add_argument("--out", required=True); ap.add_argument("--lm"); ap.add_argument("--init")
+    ap.add_argument("--rows", default=f"{HOME}/flash/score/rows_flash.jsonl")
+    ap.add_argument("--voice", default="anchor"); ap.add_argument("--rate", default="normal"); ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--instruct", default=None); ap.add_argument("--shard")
+    ap.add_argument("--labels", default=f"{HOME}/fi/labels.jsonl"); ap.add_argument("--mix", default=f"{HOME}/fi/mix.json")
+    ap.add_argument("--minutes", type=float, default=50); ap.add_argument("--max_steps", type=int, default=4000)
+    ap.add_argument("--lr", type=float, default=1e-5); ap.add_argument("--lr_new", type=float, default=1e-4)
+    ap.add_argument("--warmup", type=int, default=200); ap.add_argument("--tokens", type=int, default=16000)
+    ap.add_argument("--max_tok", type=int, default=750); ap.add_argument("--adv_w", type=float, default=0.02)
+    ap.add_argument("--p_prompt", type=float, default=0.5); ap.add_argument("--p_default", type=float, default=0.18)
+    ap.add_argument("--tag_drop", type=float, default=0.5); ap.add_argument("--rate_drop", type=float, default=0.5)
+    ap.add_argument("--val_every", type=int, default=500); ap.add_argument("--patience", type=int, default=3)
+    ap.add_argument("--quad", type=float, default=600.0)
+    ap.add_argument("--ctrl", action="store_true", help="also feed the instruction's controls as explicit embeddings")
+    ap.add_argument("--lr_ctrl", type=float, default=1e-3); ap.add_argument("--ctrl_scale", type=float, default=1.0)
+    ap.add_argument("--cfg", type=float, default=0.0, help="classifier-free guidance strength on the instruction")
+    ap.add_argument("--no_text_pauses", action="store_true", help="do not edit the text for few/many-pause instructions")
+    ap.add_argument("--conds", default=None, help="adh: comma-separated subset of conditions")
+    ap.add_argument("--extra_man", default=f"{HOME}/flash/data/igbosyn_pseudo/manifest.jsonl")
+    ap.add_argument("--qual", default=f"{HOME}/flash/qual/utmos_train.jsonl"); ap.add_argument("--qual_drop", type=float, default=0.1)
+    a = ap.parse_args()
+    {"train": train, "gen": gen, "adh": adh}[a.cmd](a)

flash_lm.py

@@ -0,0 +1,532 @@
+"""Dynamic Accent Flash: CosyVoice3 (Fun-CosyVoice3-0.5B-2512, Apache-2.0) LM fine-tune + synthesis.
+
+Same additions as Phase 2/3 (per-token language embedding, learned speaker token after the text, rate embedding added to
+the speaker vector, GRL speaker classifier on text positions, in-context same-speaker prompt p=0.5), ported to the CV3 LM:
+  seq = [sos, "You are a helpful assistant.<|endofprompt|>", (prompt text) text, spk(+rate), task, (prompt speech) speech, eos]
+sos/task live in speech_embedding (CV3), eos = speech_token_size+1. Targets are CV3 speech tokens (s3v3.*).
+Flow (DiT) + HiFT = CV3 base, zero-shot prompted with the voice clip (no flow fine-tune).
+
+  python flash_lm.py lm  --out ~/flash/runs/flash_lm --max_steps 12000 --minutes 75
+  python flash_lm.py gen --lm CKPT --out DIR [--voice anchor|waxal_ibo_5|waxal_yor_5] [--rate normal] [--rows ROWS]
+
+Release note: in this repo use `infer.py --version flash` (it wraps Synth below). Training needs the Phase 3 data
+manifest, which is not shipped; the training code is included for reference. Paths come from COSYVOICE_REPO (CosyVoice
+clone with CosyVoice3 support) and CV3_DIR (Fun-CosyVoice3-0.5B-2512 snapshot).
+"""
+import argparse, json, math, os, random, sys, time, inspect
+import numpy as np, torch, torch.nn as nn, torch.nn.functional as F, soundfile as sf, librosa
+
+HOME = os.path.expanduser("~")
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_CV = os.environ.get("COSYVOICE_REPO") or (f"{_HERE}/CosyVoice" if os.path.isdir(f"{_HERE}/CosyVoice") else f"{HOME}/CosyVoice")
+sys.path[:0] = [_CV, f"{_CV}/third_party/Matcha-TTS", f"{_HERE}/code", f"{HOME}/da"]
+from da.text import segments  # noqa: E402
+from da.model import grad_reverse  # noqa: E402
+
+CV3 = os.environ.get("CV3_DIR") or (f"{_HERE}/pretrained/Fun-CosyVoice3-0.5B-2512" if os.path.isdir(f"{_HERE}/pretrained/Fun-CosyVoice3-0.5B-2512") else f"{HOME}/models/Fun-CosyVoice3-0.5B-2512")
+LANGS = ["eng", "ibo", "hau", "yor", "pcm"]
+L2I = {l: i for i, l in enumerate(LANGS)}
+RATES = [None, "very slow", "slow", "normal", "fast", "very fast"]
+R2I = {r: i for i, r in enumerate(RATES)}
+TAGS = ("[pause]", "[breath]", "[quick_breath]", "[laughter]")
+SIL = {1, 2, 28, 29, 55, 248, 494, 2241, 2242, 2322, 2323}   # CV3 FSQ silent/breath tokens (cosyvoice/cli/model.py)
+ANCHOR = "waxal_yor_4"
+NEW = ["waxal", "igboapi", "open_bible_igbo", "naijas2st_igbo", "igbosyncorp"]
+MAN = f"{HOME}/p3t/manifest_p3.jsonl"
+PDIR = os.environ.get("DA_PROMPTS") or (f"{_HERE}/prompts" if os.path.isdir(f"{_HERE}/prompts") else f"{HOME}/hf_test/prompts")
+VOICES = {
+    "anchor": dict(wav=f"{PDIR}/clip0_waxal_yor_yor_1258.wav" if os.path.exists(f"{PDIR}/clip0_waxal_yor_yor_1258.wav")
+                   else f"{PDIR}/waxal_yor_yor_1258.wav", spk=ANCHOR),
+    "waxal_ibo_5": dict(wav=f"{PDIR}/voice_waxal_ibo_5.wav", spk="waxal_ibo_5"),
+    "waxal_yor_5": dict(wav=f"{PDIR}/voice_waxal_yor_5.wav", spk="waxal_yor_5"),
+}
+# Flash source re-weighting on top of the Phase 3 manifest weight: less Bible narration and slow phone/dictionary reads
+FLASH_W = {"open_bible_igbo": 0.4, "bible_hau": 0.5, "bible_yor": 0.5, "igboapi": 0.6, "naijas2st_igbo": 0.6,
+           "igbosyn_pseudo": 1.0}
+
+
+def strip_tags(t):
+    for g in TAGS:
+        t = t.replace(g, " ")
+    return " ".join(t.split()).replace(" ,", ",").replace(" .", ".")
+
+
+def _sf_load_wav(wav, target_sr, min_sr=16000):
+    y, sr = sf.read(wav, dtype="float32", always_2d=True)
+    y = y.mean(1)
+    if sr != target_sr:
+        y = librosa.resample(y, orig_sr=sr, target_sr=target_sr)
+    return torch.from_numpy(y)[None]
+
+
+def load_cv3():
+    import cosyvoice.utils.file_utils as fu
+    fu.load_wav = _sf_load_wav
+    import cosyvoice.cli.frontend as cf
+    cf.load_wav = _sf_load_wav
+    from cosyvoice.cli.cosyvoice import CosyVoice3
+    kw = dict(load_jit=False, load_trt=False, fp16=False)
+    sig = inspect.signature(CosyVoice3.__init__).parameters
+    return CosyVoice3(CV3, **{k: v for k, v in kw.items() if k in sig})
+
+
+class Tok:
+    def __init__(self, cosy):
+        self.t = cosy.frontend.tokenizer
+        self.prefix = self.t.encode("You are a helpful assistant.") + [151646]
+        self.cache = {}
+
+    def __call__(self, text, default="eng"):
+        if text in self.cache:
+            return self.cache[text]
+        ids, langs = [], []
+        for l, s in segments(text, default):
+            t = self.t.encode(s)
+            ids += t; langs += [L2I[l]] * len(t)
+        self.cache[text] = (ids, langs)
+        return ids, langs
+
+
+class FLM(nn.Module):
+    def __init__(self, q, n_spk, prefix, d=896):
+        super().__init__()
+        self.q = q
+        self.lang_emb = nn.Embedding(len(LANGS), d); nn.init.zeros_(self.lang_emb.weight)
+        self.spk_emb = nn.Embedding(n_spk, d); nn.init.normal_(self.spk_emb.weight, std=0.02)
+        self.rate_emb = nn.Embedding(len(RATES), d, padding_idx=0); nn.init.zeros_(self.rate_emb.weight)
+        self.adv = nn.Sequential(nn.Linear(d, 256), nn.ReLU(), nn.Linear(256, n_spk))
+        self.V = q.speech_token_size
+        self.EOS = q.eos_token
+        self.register_buffer("prefix", torch.tensor(prefix, dtype=torch.long), persistent=False)
+
+    def embed_text(self, ids, langs):
+        return self.q.llm.model.model.embed_tokens(ids) + self.lang_emb(langs)
+
+    def spkvec(self, spk):
+        return self.spk_emb(spk[0]) + self.rate_emb(spk[1])
+
+    def build(self, ids, langs, spk, sp=None, pids=None, plangs=None, psp=None):
+        E = self.q.speech_embedding.weight
+        if pids is not None:
+            ids = torch.cat([pids, ids]); langs = torch.cat([plangs, langs])
+        pre = self.q.llm.model.model.embed_tokens(self.prefix.to(ids.device))
+        parts = [E[self.q.sos][None], pre, self.embed_text(ids, langs), self.spkvec(spk)[None], E[self.q.task_id][None]]
+        npsp = 0
+        if psp is not None:
+            parts.append(self.q.speech_embedding(psp)); npsp = len(psp)
+        if sp is not None:
+            parts.append(self.q.speech_embedding(sp))
+        return torch.cat(parts, 0), len(pre), len(ids), npsp
+
+    def hidden(self, x, mask):
+        return self.q.llm.model.model(inputs_embeds=x, attention_mask=mask, return_dict=True).last_hidden_state
+
+    def pack(self, batch):
+        seqs, tgts, tpos, spks = [], [], [], []
+        for b in batch:
+            ids, langs, spk, sp = b[:4]
+            pr = b[4] if len(b) > 4 else None
+            x, P, nt, npsp = self.build(ids, langs, spk, sp, *(pr if pr else (None, None, None)))
+            tgt = torch.full((x.shape[0] + 1,), -100, device=x.device, dtype=torch.long)
+            start = P + nt + 2 + npsp
+            tgt[start: start + len(sp)] = sp
+            tgt[start + len(sp)] = self.EOS
+            seqs.append(x); tgts.append(tgt[:x.shape[0]]); tpos.append((1 + P, 1 + P + nt)); spks.append(int(spk[0]))
+        Tm = max(s.shape[0] for s in seqs); D = seqs[0].shape[1]
+        X = seqs[0].new_zeros(len(seqs), Tm, D)
+        Y = torch.full((len(seqs), Tm), -100, device=X.device, dtype=torch.long)
+        M = torch.zeros(len(seqs), Tm, device=X.device, dtype=torch.long)
+        for i, (s, t) in enumerate(zip(seqs, tgts)):
+            X[i, :len(s)] = s; Y[i, :len(t)] = t; M[i, :len(s)] = 1
+        return X, Y, M, tpos, spks
+
+    def forward2(self, batch, adv_lambda=1.0):
+        X, Y, M, tpos, spks = self.pack(batch)
+        H = self.hidden(X, M)
+        logits = self.q.llm_decoder(H)
+        ce = F.cross_entropy(logits.float().reshape(-1, logits.shape[-1]), Y.reshape(-1), ignore_index=-100)
+        valid = Y != -100
+        acc = (logits.argmax(-1)[valid] == Y[valid]).float().mean()
+        hs = torch.cat([H[i, a:b] for i, (a, b) in enumerate(tpos)])
+        ys = torch.cat([torch.full((b - a,), spks[i], device=X.device) for i, (a, b) in enumerate(tpos)])
+        al = self.adv(grad_reverse(hs.float(), adv_lambda))
+        return ce, acc, F.cross_entropy(al, ys), (al.argmax(-1) == ys).float().mean()
+
+    def seq_logp(self, batch):
+        """sum log p(speech tokens + eos) per item (for DPO)."""
+        X, Y, M, _, _ = self.pack(batch)
+        logits = self.q.llm_decoder(self.hidden(X, M)).float()
+        lp = logits.log_softmax(-1)
+        valid = Y != -100
+        g = lp.gather(-1, Y.clamp(min=0)[..., None])[..., 0] * valid
+        return g.sum(-1), valid.sum(-1)
+
+    @torch.no_grad()
+    def generate(self, ids, langs, spk, prompt=None, B=1, top_p=0.8, top_k=25, win=10, tau_r=0.1, seed=0,
+                 min_ratio=2.0, max_ratio=30.0, sampler="silexcap", max_tok=900):
+        g = torch.Generator(device=ids.device).manual_seed(seed)
+        x, _, _, _ = self.build(ids, langs, spk, None, *(prompt if prompt else (None, None, None)))
+        inp = x[None].repeat(B, 1, 1)
+        n = len(ids)
+        min_len, max_len = int(n * min_ratio), min(int(n * max_ratio), max_tok)
+        past, outs, done = None, [[] for _ in range(B)], [False] * B
+        E = self.q.speech_embedding.weight
+        for i in range(max_len):
+            o = self.q.llm.model.model(inputs_embeds=inp, past_key_values=past, use_cache=True, return_dict=True)
+            past = o.past_key_values
+            logp = self.q.llm_decoder(o.last_hidden_state[:, -1]).float().log_softmax(-1)
+            eos_lp = logp[:, self.EOS].clone()
+            logp[:, self.V:] = -float("inf")
+            if i >= min_len:
+                logp[:, self.EOS] = eos_lp
+            P = logp.exp()
+            nxt = []
+            for b in range(B):
+                if done[b]:
+                    nxt.append(0); continue
+                p = P[b]; out = outs[b]
+                sp_, si = p.sort(descending=True)
+                keep = (sp_.cumsum(0) - sp_) < top_p
+                keep[top_k:] = False
+                cp, ci = sp_[keep], si[keep]
+                t = int(ci[torch.multinomial(cp / cp.sum(), 1, generator=g)])
+                exempt = False
+                if sampler == "silexcap" and t in SIL:
+                    run = 0
+                    for u in reversed(out):
+                        if u not in SIL:
+                            break
+                        run += 1
+                    exempt = run < 25
+                if not exempt and out and t != self.EOS and sum(1 for u in out[-win:] if u == t) >= win * tau_r:
+                    t = int(torch.multinomial(p, 1, generator=g))
+                if t >= self.V:
+                    done[b] = True; nxt.append(0); continue
+                out.append(t); nxt.append(t)
+            if all(done):
+                break
+            inp = E[torch.tensor(nxt, device=ids.device)][:, None]
+        return outs
+
+
+def load_model(cosy, ckpt, tok):
+    ck = torch.load(ckpt, map_location="cuda", weights_only=False)
+    m = FLM(cosy.model.llm, ck["n_spk"], tok.prefix).cuda().eval()
+    print("load", ckpt, m.load_state_dict(ck["model"], strict=False), flush=True)
+    return m, json.load(open(os.path.join(os.path.dirname(ckpt), "spk2id.json")))
+
+
+# ------------------------------------------------------------------ data
+def load_data(splits, max_tok=750, extra_man=None, qual=None, qual_drop=0.1):
+    rows = [json.loads(l) for l in open(MAN, encoding="utf-8")]
+    if extra_man and os.path.exists(extra_man):
+        rows += [json.loads(l) for l in open(extra_man, encoding="utf-8")]
+    want = {r["id"] for r in rows if r["split"] in splits}
+    drop = set()
+    if qual and os.path.exists(qual) and "train" in splits:       # drop the bottom qual_drop of UTMOS per source
+        Q = [json.loads(l) for l in open(qual)]
+        by = {}
+        for q in Q:
+            by.setdefault(q["src"], []).append(q)
+        for src, L in by.items():
+            if src in ("cs_pairs",):
+                continue
+            thr = float(np.quantile([q["u22"] for q in L], qual_drop))
+            drop |= {q["id"] for q in L if q["u22"] < thr}
+        print("quality filter drops", len(drop), flush=True)
+    src_idx, mm = {}, {}
+    for src in sorted({r["src"] for r in rows}):
+        if src in NEW:
+            d = f"{HOME}/p3t/{src}"
+        elif src == "igbosyn_pseudo":
+            d = f"{HOME}/flash/data/igbosyn_pseudo"
+        else:
+            d = f"{HOME}/data3/{src}"
+        if not os.path.exists(f"{d}/s3v3.done"):
+            print("missing v3 tokens", d, flush=True); continue
+        meta = [json.loads(l) for l in open(f"{d}/meta.jsonl", encoding="utf-8")]
+        tk = [json.loads(l) for l in open(f"{d}/s3v3.jsonl")]
+        ix = {}
+        for k, (m, t) in enumerate(zip(meta, tk)):
+            assert m["id"] == t["id"]
+            if m["id"] in want:
+                ix[m["id"]] = (t["toff"], t["ntok"])
+        src_idx[src] = ix
+        mm[src] = np.memmap(f"{d}/s3v3.i32", dtype=np.int32, mode="r")
+    items = []
+    for r in rows:
+        if r["split"] not in splits or r["src"] not in src_idx or r["id"] in drop and r["speaker"] != ANCHOR:
+            continue
+        ix = src_idx[r["src"]]
+        if r["id"] not in ix:
+            continue
+        toff, ntok = ix[r["id"]]
+        if not (5 < ntok <= max_tok):
+            continue
+        w = float(r.get("weight", 1.0)) * FLASH_W.get(r["src"], 1.0)
+        items.append(dict(id=r["id"], ds=r["src"], src=r["src"], lang=r["lang"], spk=r["speaker"], split=r["split"],
+                          dur=r["dur"], text=r["text_plain"], tags=r.get("text_tags"), rate=R2I.get(r.get("rate_bin"), 0),
+                          w=w, toff=toff, ntok=ntok))
+    return items, mm
+
+
+def tagged(text, lang):
+    return text if lang == "cs" else f"<{lang}>{text}</{lang}>"
+
+
+def batches(items, budget, rng, wfn, cost):
+    idx = []
+    for i, m in enumerate(items):
+        w = wfn(m)
+        idx += [i] * int(w) + ([i] if rng.random() < w - int(w) else [])
+    idx.sort(key=lambda i: cost(items[i]) + rng.random() * 10)
+    out, cur, mx = [], [], 0
+    for i in idx:
+        L = cost(items[i])
+        if cur and max(mx, L) * (len(cur) + 1) > budget:
+            out.append(cur); cur, mx = [], 0
+        cur.append(i); mx = max(mx, L)
+    if cur:
+        out.append(cur)
+    rng.shuffle(out)
+    return out
+
+
+VAL_SPLITS = {"val", "validation", "dev"}
+
+
+def train_lm(a):
+    cosy = load_cv3(); tok = Tok(cosy)
+    items, mm = load_data({"train"}, a.max_tok, a.extra_man, a.qual, a.qual_drop)
+    val_all, mmv = load_data(VAL_SPLITS, a.max_tok)
+    mm.update(mmv)
+    spk2id = {}
+    for s in sorted({m["spk"] for m in items}):
+        spk2id[s] = len(spk2id)
+    n_spk = len(spk2id)
+    rng = random.Random(1); rng.shuffle(val_all)
+    val, per_l, per_s = [], {}, {}
+    for m in val_all:
+        if m["spk"] not in spk2id or m["lang"] == "cs":
+            continue
+        L = "anchor" if m["spk"] == ANCHOR else m["lang"]
+        if per_l.get(L, 0) >= 60 or per_s.get(m["spk"], 0) >= 15:
+            continue
+        per_l[L] = per_l.get(L, 0) + 1; per_s[m["spk"]] = per_s.get(m["spk"], 0) + 1; val.append(m)
+    by_spk = {}
+    for m in items:
+        if m["ntok"] <= 200 and m["lang"] != "cs":
+            by_spk.setdefault(m["spk"], []).append(m)
+    os.makedirs(a.out, exist_ok=True)
+    json.dump(spk2id, open(f"{a.out}/spk2id.json", "w")); json.dump(vars(a), open(f"{a.out}/args.json", "w"))
+    hrs = {}
+    for m in items:
+        hrs[m["src"]] = hrs.get(m["src"], 0) + m["dur"] / 3600
+    print("lm items", len(items), "hours", round(sum(hrs.values()), 1), {k: round(v, 1) for k, v in hrs.items()},
+          "spk", n_spk, "val", len(val), per_l, flush=True)
+    model = FLM(cosy.model.llm, n_spk, tok.prefix).cuda().train()
+    for p in list(cosy.model.flow.parameters()) + list(cosy.model.hift.parameters()):
+        p.requires_grad = False
+    new = list(model.lang_emb.parameters()) + list(model.spk_emb.parameters()) + list(model.adv.parameters()) + list(model.rate_emb.parameters())
+    newids = {id(p) for p in new}
+    old = [p for p in model.parameters() if id(p) not in newids and p.requires_grad]
+    opt = torch.optim.AdamW([{"params": old, "lr": a.lr}, {"params": new, "lr": a.lr_new}], weight_decay=0.01)
+    base = [a.lr, a.lr_new]
+
+    def text_of(m, r):
+        if m["tags"] and r is not None and r.random() >= a.tag_drop:
+            return m["tags"]
+        return strip_tags(m["text"])
+
+    def spk_t(m, r):
+        rate = m["rate"] if (r is not None and r.random() >= a.rate_drop) else 0
+        return torch.tensor([spk2id[m["spk"]], rate]).cuda()
+
+    def enc(m, prng=None, force_prompt=None, val_mode=False):
+        r = None if val_mode else prng
+        ids, langs = tok(tagged(text_of(m, r), m["lang"]))
+        sp = np.asarray(mm[m["ds"]][m["toff"]: m["toff"] + m["ntok"]], dtype=np.int64)
+        out = [torch.tensor(ids).cuda(), torch.tensor(langs).cuda(), spk_t(m, r), torch.from_numpy(sp).cuda()]
+        use = force_prompt if force_prompt is not None else (prng is not None and prng.random() < a.p_prompt)
+        if use:
+            c = by_spk.get(m["spk"], [])
+            c = [x for x in (prng or random).sample(c, min(6, len(c))) if x["id"] != m["id"]] if c else []
+            if c and c[0]["ntok"] + m["ntok"] <= a.max_tok + 150:
+                p = c[0]
+                pids, plangs = tok(tagged(strip_tags(p["text"]), p["lang"]))
+                psp = np.asarray(mm[p["ds"]][p["toff"]: p["toff"] + p["ntok"]], dtype=np.int64)
+                out.append((torch.tensor(pids).cuda(), torch.tensor(plangs).cuda(), torch.from_numpy(psp).cuda()))
+        return out
+
+    def validate():
+        model.eval(); res = {}
+        with torch.no_grad(), torch.autocast("cuda", dtype=torch.bfloat16):
+            for mode in (False, True):
+                vr = random.Random(7); L, W = [], []
+                for i in range(0, len(val), 16):
+                    bt = val[i:i + 16]
+                    ce, _, _, _ = model.forward2([enc(m, vr, force_prompt=mode, val_mode=True) for m in bt])
+                    L.append(float(ce) * len(bt)); W.append(len(bt))
+                res["p" if mode else "np"] = sum(L) / sum(W)
+        model.train()
+        res["mean"] = (res["np"] + res["p"]) / 2
+        return res
+
+    wfn = lambda m: m["w"] * (a.anchor_w if m["spk"] == ANCHOR else 1.0)  # noqa
+    cost = lambda m: (lambda L: int(L * (1 + L / a.quad)))(m["ntok"] + len(m["text"]) // 2 + 20 + int(a.p_prompt * 200))  # noqa
+    rng = random.Random(0); prng = random.Random(3)
+    step, nskip, noom, t0 = 0, 0, 0, time.time()
+    logf = open(f"{a.out}/log.jsonl", "a")
+    v = validate(); best = v["mean"]; bad = 0
+    print(json.dumps({"step": 0, "val": v}), flush=True); logf.write(json.dumps({"step": 0, "val": v}) + "\n")
+    total, done = a.max_steps, False
+    while not done:
+        for bi in batches(items, a.tokens, rng, wfn, cost):
+            lrm = min(1.0, (step + 1) / a.warmup) * (0.1 + 0.9 * 0.5 * (1 + math.cos(math.pi * min(1.0, step / total))))
+            for gp, b in zip(opt.param_groups, base):
+                gp["lr"] = b * lrm
+            batch = [enc(items[i], prng) for i in bi]
+            opt.zero_grad(set_to_none=True)
+            oom = False
+            try:
+                with torch.autocast("cuda", dtype=torch.bfloat16):
+                    ce, acc, adv, adv_acc = model.forward2(batch, adv_lambda=min(1.0, step / 1000))
+                loss = ce + a.adv_w * adv
+                if not torch.isfinite(loss):
+                    nskip += 1; continue
+                loss.backward()
+            except torch.cuda.OutOfMemoryError:
+                oom = True
+            if oom:
+                batch = ce = acc = adv = adv_acc = loss = None
+                opt.zero_grad(set_to_none=True); torch.cuda.empty_cache(); noom += 1; continue
+            gn = torch.nn.utils.clip_grad_norm_([p for p in model.parameters() if p.requires_grad], 1.0)
+            if not torch.isfinite(gn):
+                nskip += 1; opt.zero_grad(set_to_none=True); continue
+            opt.step(); step += 1
+            if step % 50 == 0:
+                r = dict(step=step, ce=round(float(ce), 4), acc=round(float(acc), 4), adv=round(float(adv), 3),
+                         adv_acc=round(float(adv_acc), 3), gn=round(float(gn), 2), B=len(bi), lr=round(lrm * a.lr, 9),
+                         skips=nskip, oom=noom, min=round((time.time() - t0) / 60, 2))
+                print(json.dumps(r), flush=True); logf.write(json.dumps(r) + "\n"); logf.flush()
+            if step % a.val_every == 0:
+                v = validate(); imp = v["mean"] < best - 1e-4
+                rec = {"step": step, "val": v, "best": imp}
+                print(json.dumps(rec), flush=True); logf.write(json.dumps(rec) + "\n"); logf.flush()
+                if imp:
+                    best, bad = v["mean"], 0
+                    torch.save(dict(model={k: t for k, t in model.state_dict().items()}, step=step, n_spk=n_spk, val=v), f"{a.out}/best.pt")
+                else:
+                    bad += 1
+                    if bad >= a.patience:
+                        print("EARLY_STOP", step, flush=True); done = True; break
+            if (time.time() - t0) / 60 > a.minutes or step >= total:
+                done = True; break
+    print("TRAIN_LM_DONE", step, "best", best, "skips", nskip, "oom", noom, flush=True)
+
+
+# ------------------------------------------------------------------ synthesis
+def prompt_feats(cosy, wav):
+    fe = cosy.frontend
+    tokn, _ = fe._extract_speech_token(wav)
+    feat, _ = fe._extract_speech_feat(wav)
+    n = min(feat.shape[1] // 2, tokn.shape[1])
+    return tokn[:, :n].cuda(), feat[:, :2 * n].cuda(), fe._extract_spk_embedding(wav).cuda()
+
+
+@torch.no_grad()
+def token2wav(cosy, tokens, ptok, pfeat, emb):
+    flow = cosy.model.flow
+    t = torch.tensor([tokens], dtype=torch.int32).cuda()
+    mel, _ = flow.inference(token=t, token_len=torch.tensor([t.shape[1]], dtype=torch.int32).cuda(),
+                            prompt_token=ptok.int(), prompt_token_len=torch.tensor([ptok.shape[1]], dtype=torch.int32).cuda(),
+                            prompt_feat=pfeat, prompt_feat_len=torch.tensor([pfeat.shape[1]], dtype=torch.int32).cuda(),
+                            embedding=emb, streaming=False, finalize=True)
+    w, _ = cosy.model.hift.inference(speech_feat=mel, finalize=True)
+    return w.squeeze().float().cpu().numpy()
+
+
+def item_text(r):
+    return r["text"] if r["lang"] in ("cs", "para") else f"<{r['lang']}>{r['text']}</{r['lang']}>"
+
+
+class Synth:
+    def __init__(self, lm_ckpt):
+        self.cosy = load_cv3(); self.tok = Tok(self.cosy)
+        self.m, self.spk2id = load_model(self.cosy, lm_ckpt, self.tok)
+        self.vcache = {}
+        vt = f"{PDIR}/flash_voices_text.json"
+        self.vtext = json.load(open(vt if os.path.exists(vt) else f"{_HERE}/voices_text.json", encoding="utf-8"))
+
+    def voice(self, name):
+        if name not in self.vcache:
+            v = VOICES[name]
+            ptok, pfeat, emb = prompt_feats(self.cosy, v["wav"])
+            ids, langs = self.tok(self.vtext[name])
+            lmp = (torch.tensor(ids).cuda(), torch.tensor(langs).cuda(), ptok[0].long())
+            self.vcache[name] = (ptok, pfeat, emb, lmp, self.spk2id.get(v["spk"], self.spk2id.get(ANCHOR)))
+        return self.vcache[name]
+
+    def tokens(self, text, voice="anchor", rate="normal", seed=0, B=1, sampler="silexcap"):
+        ptok, pfeat, emb, lmp, sid = self.voice(voice)
+        ids, langs = self.tok(text)
+        spk = torch.tensor([sid, R2I.get(None if rate == "none" else rate, 0)]).cuda()
+        with torch.autocast("cuda", dtype=torch.bfloat16):
+            return self.m.generate(torch.tensor(ids).cuda(), torch.tensor(langs).cuda(), spk, prompt=lmp, B=B, seed=seed,
+                                   sampler=sampler)
+
+    def wav(self, toks, voice="anchor"):
+        ptok, pfeat, emb, _, _ = self.voice(voice)
+        if len(toks) < 3:
+            toks = list(toks) + [1, 1, 1]
+        return token2wav(self.cosy, toks, ptok, pfeat, emb)
+
+
+def gen(a):
+    S = Synth(a.lm)
+    rows = [json.loads(l) for l in open(a.rows, encoding="utf-8")]
+    if a.shard:
+        i, n = map(int, a.shard.split("/")); rows = rows[i::n]
+    os.makedirs(a.out, exist_ok=True)
+    json.dump(vars(a), open(f"{a.out}/variant.json", "w"))
+    for r in rows:
+        if os.path.exists(f"{a.out}/{r['id']}.wav"):
+            continue
+        text = r.get("tts_text") or item_text(r)
+        toks = S.tokens(text, a.voice, a.rate, a.seed)[0]
+        w = S.wav(toks, a.voice)
+        sf.write(f"{a.out}/{r['id']}.wav", w, S.cosy.sample_rate)
+        json.dump(dict(tokens=[toks], ntok=[len(toks)]), open(f"{a.out}/{r['id']}.tok.json", "w"))
+    print("GEN_DONE", a.out, len(rows), flush=True)
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("cmd")
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--lm")
+    ap.add_argument("--rows", default=f"{HOME}/flash/score/rows_flash.jsonl")
+    ap.add_argument("--voice", default="anchor")
+    ap.add_argument("--rate", default="normal")
+    ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--shard")
+    ap.add_argument("--minutes", type=float, default=75)
+    ap.add_argument("--max_steps", type=int, default=12000)
+    ap.add_argument("--lr", type=float, default=2e-5)
+    ap.add_argument("--lr_new", type=float, default=1e-3)
+    ap.add_argument("--warmup", type=int, default=300)
+    ap.add_argument("--tokens", type=int, default=16000)
+    ap.add_argument("--max_tok", type=int, default=750)
+    ap.add_argument("--adv_w", type=float, default=0.02)
+    ap.add_argument("--p_prompt", type=float, default=0.5)
+    ap.add_argument("--tag_drop", type=float, default=0.5)
+    ap.add_argument("--rate_drop", type=float, default=0.5)
+    ap.add_argument("--anchor_w", type=float, default=1.0)
+    ap.add_argument("--val_every", type=int, default=1000)
+    ap.add_argument("--patience", type=int, default=4)
+    ap.add_argument("--quad", type=float, default=600.0)
+    ap.add_argument("--extra_man", default=f"{HOME}/flash/data/igbosyn_pseudo/manifest.jsonl")
+    ap.add_argument("--qual", default=f"{HOME}/flash/qual/utmos_train.jsonl")
+    ap.add_argument("--qual_drop", type=float, default=0.1)
+    a = ap.parse_args()
+    {"lm": train_lm, "gen": gen}[a.cmd](a)

frontend/__init__.py

@@ -0,0 +1,2 @@
+"""Dynamic Accent Flash text front-end (normalisation, Yoruba/Igbo diacritic restoration, experimental MT)."""
+from .frontend import FrontEnd  # noqa: F401

frontend/frontend.py

@@ -0,0 +1,122 @@
+"""Dynamic Accent Flash text front-end.
+
+    from frontend import FrontEnd
+    fe = FrontEnd(diac_model="models/diacritics", mt=True)
+    fe("<eng>The meeting is at 3:30 on 21/10/2026.</eng>", mode="codeswitch")          # tags kept, numbers verbalised
+    fe("Ojo naa dara pupo", mode="native", lang="yor")                                # adds Yorùbá tone marks/underdots
+    fe("Please come home early today.", mode="translate", lang="ibo")                 # MADLAD-400 eng/pcm -> ibo
+    fe("I go call you tomorrow", mode="accent", lang="ibo")                           # English/Pidgin words, Igbo accent
+
+Modes
+  codeswitch : input already tagged <ibo>…</ibo> <eng>…</eng> (or untagged = one language `lang`); each segment is
+               normalised in its own language; Yorùbá/Igbo segments that carry no marks are diacritised.
+  native     : the whole text is one language (`lang`); normalise + diacritise.
+  translate  : `lang` is the target (ibo|yor|hau); the input (English or Pidgin) is translated first with
+               MADLAD-400-3B-MT (Apache-2.0), then normalised + diacritised (MADLAD Yorùbá is often unmarked).
+  accent     : keep the words as written but read them with the `lang` accent (whole text tagged <lang>), i.e.
+               "English words with a native accent". Numbers are verbalised in English.
+Output: a tagged string for infer.py / flash_lm.py.
+"""
+import re
+import unicodedata
+
+try:
+    from .normalize import normalize
+except ImportError:  # run as a script
+    from normalize import normalize
+
+SEG = re.compile(r"<(\w{3})>(.*?)</\1>", re.S)
+
+
+def _strip(s):
+    return "".join(c for c in unicodedata.normalize("NFD", s) if unicodedata.category(c) != "Mn")
+
+
+def unmarked(text, thresh=0.05):
+    w = re.findall(r"\w+", unicodedata.normalize("NFC", text))
+    if not w:
+        return False
+    return sum(_strip(x) != unicodedata.normalize("NFC", x) for x in w) / len(w) < thresh
+
+
+class FrontEnd:
+    def __init__(self, diac_model=None, mt=False, device="cuda"):
+        self.diac_dir, self.device = diac_model, device
+        self._d = self._mt = None
+        self.use_mt = mt
+
+    # ---- diacritics (ByT5-small fine-tune, word-guarded)
+    def diacritise(self, text, lang):
+        if lang not in ("yor", "ibo") or not self.diac_dir:
+            return text
+        import torch
+        from transformers import AutoTokenizer, T5ForConditionalGeneration
+        if self._d is None:
+            self._d = (AutoTokenizer.from_pretrained(self.diac_dir),
+                       T5ForConditionalGeneration.from_pretrained(self.diac_dir).to(self.device).eval())
+        tok, m = self._d
+        src = unicodedata.normalize("NFC", _strip(text))
+        x = tok([f"{lang}: {src}"], return_tensors="pt").to(self.device)
+        with torch.no_grad():
+            y = m.generate(**x, max_length=int(x.input_ids.shape[1] * 1.6) + 16)
+        hyp = unicodedata.normalize("NFC", tok.decode(y[0], skip_special_tokens=True))
+        sw, hw = src.split(), hyp.split()
+        if len(sw) != len(hw):
+            return text
+        return " ".join(h if unicodedata.normalize("NFC", _strip(h)) == s else s for s, h in zip(sw, hw))
+
+    # ---- MT (MADLAD-400-3B-MT)
+    def translate(self, text, tgt):
+        import torch
+        from transformers import T5ForConditionalGeneration, T5Tokenizer
+        if self._mt is None:
+            self._mt = (T5Tokenizer.from_pretrained("google/madlad400-3b-mt"),
+                        T5ForConditionalGeneration.from_pretrained("google/madlad400-3b-mt", torch_dtype=torch.bfloat16).to(self.device).eval())
+        tok, m = self._mt
+        code = {"ibo": "ig", "yor": "yo", "hau": "ha", "eng": "en"}[tgt]
+        out = []
+        for sent in re.split(r"(?<=[.!?])\s+", text.strip()):
+            if not sent:
+                continue
+            x = tok([f"<2{code}> {sent}"], return_tensors="pt").to(self.device)
+            with torch.no_grad():
+                y = m.generate(**x, max_new_tokens=256, num_beams=4)
+            out.append(tok.decode(y[0], skip_special_tokens=True))
+        return " ".join(out)
+
+    def _seg(self, lang, s):
+        s = normalize(s, lang)
+        if lang in ("yor", "ibo") and unmarked(s):
+            s = self.diacritise(s, lang)
+        return f"<{lang}>{s}</{lang}>"
+
+    def __call__(self, text, mode="codeswitch", lang="eng"):
+        text = unicodedata.normalize("NFC", text).strip()
+        if mode == "translate":
+            if lang not in ("ibo", "yor", "hau"):
+                raise ValueError("translate mode needs lang in ibo|yor|hau")
+            plain = re.sub(r"</?\w{3}>", "", text)
+            return self._seg(lang, self.translate(normalize(plain, "eng"), lang))
+        if mode == "accent":
+            plain = re.sub(r"</?\w{3}>", "", text)
+            return f"<{lang}>{normalize(plain, 'eng')}</{lang}>"
+        if mode == "native" or not SEG.search(text):
+            return self._seg(lang, re.sub(r"</?\w{3}>", "", text))
+        parts, pos = [], 0
+        for m in SEG.finditer(text):
+            if text[pos:m.start()].strip():
+                parts.append(self._seg(lang, text[pos:m.start()]))
+            parts.append(self._seg(m.group(1), m.group(2)))
+            pos = m.end()
+        if text[pos:].strip():
+            parts.append(self._seg(lang, text[pos:]))
+        return " ".join(parts)
+
+
+if __name__ == "__main__":
+    import argparse
+    ap = argparse.ArgumentParser()
+    ap.add_argument("text"); ap.add_argument("--mode", default="codeswitch"); ap.add_argument("--lang", default="eng")
+    ap.add_argument("--diac_model", default=None); ap.add_argument("--cpu", action="store_true")
+    a = ap.parse_args()
+    print(FrontEnd(a.diac_model, device="cpu" if a.cpu else "cuda")(a.text, a.mode, a.lang))

frontend/normalize.py

@@ -0,0 +1,308 @@
+"""Dynamic Accent Flash text normaliser: numbers, ordinals-as-cardinals, years, dates, times, currency and percent
+-> words, per language (eng, pcm, ibo, hau, yor). Pure Python, no dependencies.
+
+    from normalize import normalize
+    normalize("Ọ bụ ₦5,000 n'ụbọchị 21/10/2026", "ibo")
+
+Coverage: integers 0 .. 999,999,999 (larger stay as digits), decimals (point-by-digit), ₦/N/NGN/naira, $/USD,
+£, kobo, %, dd/mm/yyyy and "21 October 2026" dates, hh:mm times, 1st/2nd... in eng/pcm.
+The Igbo and Hausa systems are decimal and regular. Yorùbá uses the traditional vigesimal/subtractive system for
+1-99 (with tone marks) and decimal composition above 100 (ọgọ́rùn-ún, ẹgbẹ̀rún, mílíọ̀nù + "ó lé"); the Yorùbá forms and
+all date/currency phrasings need a native-speaker check before release (see TEXT_FRONTEND.md).
+"""
+import re
+import unicodedata
+
+# ------------------------------------------------------------------ English / Pidgin
+_E1 = "zero one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen".split()
+_E10 = "_ _ twenty thirty forty fifty sixty seventy eighty ninety".split()
+
+
+def eng(n):
+    if n < 20:
+        return _E1[n]
+    if n < 100:
+        return _E10[n // 10] + ("" if n % 10 == 0 else "-" + _E1[n % 10])
+    if n < 1000:
+        return _E1[n // 100] + " hundred" + ("" if n % 100 == 0 else " and " + eng(n % 100))
+    for v, w in ((10 ** 9, "billion"), (10 ** 6, "million"), (1000, "thousand")):
+        if n >= v:
+            r = n % v
+            tail = "" if r == 0 else ((" and " if r < 100 else " ") + eng(r))
+            return eng(n // v) + " " + w + tail
+    return str(n)
+
+
+def eng_year(n):
+    if 2000 <= n <= 2009:
+        return eng(n)
+    if 1100 <= n <= 2099 and n % 100 != 0:
+        return eng(n // 100) + " " + (("oh " + _E1[n % 100]) if n % 100 < 10 else eng(n % 100))
+    return eng(n)
+
+
+_ORD = {"one": "first", "two": "second", "three": "third", "five": "fifth", "eight": "eighth", "nine": "ninth", "twelve": "twelfth"}
+
+
+def eng_ord(n):
+    w = eng(n)
+    head, _, last = w.rpartition(" ") if " " in w else ("", "", w)
+    h2, dash, l2 = last.rpartition("-")
+    base = l2 if dash else last
+    o = _ORD.get(base) or (base[:-1] + "ieth" if base.endswith("y") else base + "th")
+    last = (h2 + "-" + o) if dash else o
+    return (head + " " + last).strip()
+
+
+# ------------------------------------------------------------------ Igbo (decimal)
+_I1 = ["efu", "otu", "abụọ", "atọ", "anọ", "ise", "isii", "asaa", "asatọ", "itoolu"]
+
+
+def ibo(n):
+    if n < 10:
+        return _I1[n]
+    if n < 100:
+        t, u = divmod(n, 10)
+        s = "iri" if t == 1 else "iri " + _I1[t]
+        return s if u == 0 else s + " na " + _I1[u]
+    for v, w in ((10 ** 9, "ijeri"), (10 ** 6, "nde"), (1000, "puku"), (100, "narị")):
+        if n >= v:
+            q, r = divmod(n, v)
+            s = w if q == 1 else w + " " + ibo(q)
+            return s if r == 0 else s + " na " + ibo(r)
+    return str(n)
+
+
+# ------------------------------------------------------------------ Hausa (decimal)
+_H1 = ["sifili", "ɗaya", "biyu", "uku", "huɗu", "biyar", "shida", "bakwai", "takwas", "tara"]
+_H10 = [None, "goma", "ashirin", "talatin", "arba'in", "hamsin", "sittin", "saba'in", "tamanin", "casa'in"]
+
+
+def hau(n):
+    if n < 10:
+        return _H1[n]
+    if n < 20:
+        return "goma" if n == 10 else "goma sha " + _H1[n - 10]
+    if n < 100:
+        t, u = divmod(n, 10)
+        return _H10[t] if u == 0 else _H10[t] + " da " + _H1[u]
+    for v, w in ((10 ** 9, "biliyan"), (10 ** 6, "miliyan"), (1000, "dubu"), (100, "ɗari")):
+        if n >= v:
+            q, r = divmod(n, v)
+            s = w if q == 1 else w + " " + hau(q)
+            return s if r == 0 else s + " da " + hau(r)
+    return str(n)
+
+
+# ------------------------------------------------------------------ Yorùbá
+# counting forms 1-10, then vigesimal/subtractive 11-99 (standard grammar tables); decimal composition >= 100
+_Y1 = ["òdo", "oókan", "eéjì", "ẹẹ́ta", "ẹẹ́rin", "aárùn-ún", "ẹẹ́fà", "eéje", "ẹẹ́jọ", "ẹẹ́sàn-án", "ẹẹ́wàá"]
+_Y11 = {11: "ọ̀kanlá", 12: "èjìlá", 13: "ẹ̀tàlá", 14: "ẹ̀rìnlá"}
+# tens: name, locative form used after lé/dín ("added to / less than")
+_YT = {20: ("ogún", "lógún"), 30: ("ọgbọ̀n", "lọ́gbọ̀n"), 40: ("ogójì", "lógójì"), 50: ("àádọ́ta", "láàádọ́ta"),
+       60: ("ọgọ́ta", "lọ́gọ́ta"), 70: ("àádọ́rin", "láàádọ́rin"), 80: ("ọgọ́rin", "lọ́gọ́rin"),
+       90: ("àádọ́rùn-ún", "láàádọ́rùn-ún"), 100: ("ọgọ́rùn-ún", "lọ́gọ́rùn-ún")}
+_YLE = {1: "ọ̀kàn", 2: "éjì", 3: "ẹ́tà", 4: "ẹ́rìn"}            # +1..+4
+_YDIN = {1: "ọ̀kàn", 2: "éjì", 3: "ẹẹ́tà", 4: "ẹẹ́rìn"}          # -1..-4
+_YFIVE = {20: "ẹ̀ẹ́dógún", 30: "ẹ̀ẹ́dọ́gbọ̀n", 40: "ẹ̀ẹ́dógójì", 50: "ẹ̀ẹ́dáàádọ́ta", 60: "ẹ̀ẹ́dọ́gọ́ta", 70: "ẹ̀ẹ́dáàádọ́rin",
+          80: "ẹ̀ẹ́dọ́gọ́rin", 90: "ẹ̀ẹ́dáàádọ́rùn-ún", 100: "ẹ̀ẹ́dọ́gọ́rùn-ún"}   # (T - 5)
+_YADJ = {1: "kan", 2: "méjì", 3: "mẹ́ta", 4: "mẹ́rin", 5: "márùn-ún", 6: "mẹ́fà", 7: "méje", 8: "mẹ́jọ", 9: "mẹ́sàn-án", 10: "mẹ́wàá"}
+_YH = {200: "igba", 300: "ọ̀ọ́dúnrún", 400: "irinwó", 500: "ẹ̀ẹ́dẹ́gbẹ̀ta", 600: "ẹgbẹ̀ta", 700: "ẹ̀ẹ́dẹ́gbẹ̀rin",
+       800: "ẹgbẹ̀rin", 900: "ẹ̀ẹ́dẹ́gbẹ̀rún"}
+
+
+def _y99(n):
+    if n <= 10:
+        return _Y1[n]
+    if n in _Y11:
+        return _Y11[n]
+    if n in _YT:
+        return _YT[n][0]
+    T = (n // 10) * 10
+    u = n - T
+    if u <= 4:                       # T + u  (u-lé-T)
+        return _YLE[u] + "lé" + _YT[T][1]
+    if u == 5:                       # (T+10) - 5
+        return _YFIVE[T + 10]
+    return _YDIN[10 - u] + "dín" + _YT[T + 10][1]      # (T+10) - (10-u)
+
+
+def yor(n):
+    if n < 100:
+        return _y99(n)
+    if n < 1000:
+        h, r = divmod(n, 100)
+        s = _YT[100][0] if h == 1 else _YH[h * 100]
+        return s if r == 0 else s + " ó lé " + _y99(r)
+    for v, w in ((10 ** 9, "bílíọ̀nù"), (10 ** 6, "mílíọ̀nù"), (1000, "ẹgbẹ̀rún")):
+        if n >= v:
+            q, r = divmod(n, v)
+            s = w + " " + (_YADJ[q] if q in _YADJ else yor(q))
+            return s if r == 0 else s + " ó lé " + yor(r)
+    return str(n)
+
+
+NUM = {"eng": eng, "pcm": eng, "ibo": ibo, "hau": hau, "yor": yor}
+
+MONTHS = {
+    "eng": "January February March April May June July August September October November December".split(),
+    "ibo": "Jenụwarị Febụwarị Maachị Epreel Mee Juun Julaị Ọgọọst Septemba Ọktoba Novemba Disemba".split(),
+    "hau": "Janairu Fabrairu Maris Afrilu Mayu Yuni Yuli Agusta Satumba Oktoba Nuwamba Disamba".split(),
+    "yor": "Ṣẹ́rẹ́ Èrèlé Ẹrẹ̀nà Ìgbé Ẹ̀bìbí Òkúdu Agẹmọ Ògún Owewe Ọ̀wàrà Bélú Ọ̀pẹ̀".split(),
+}
+MONTHS["pcm"] = MONTHS["eng"]
+_MIDX = {m.lower(): i for i, m in enumerate(MONTHS["eng"])}
+_MIDX.update({m[:3].lower(): i for i, m in enumerate(MONTHS["eng"])})
+
+CUR = {  # (major, minor) per language; phrase order handled in money()
+    "NGN": {"eng": ("naira", "kobo"), "pcm": ("naira", "kobo"), "ibo": ("naịra", "kobo"), "hau": ("naira", "kobo"), "yor": ("náírà", "kọ́bọ̀")},
+    "USD": {"eng": ("dollars", "cents"), "pcm": ("dollars", "cents"), "ibo": ("dọla", "senti"), "hau": ("dala", "santi"), "yor": ("dọ́là", "sẹ́ǹtì")},
+    "GBP": {"eng": ("pounds", "pence"), "pcm": ("pounds", "pence"), "ibo": ("paụnd", "pens"), "hau": ("fam", "fens"), "yor": ("pọ́n-ùn", "pẹ́ńsì")},
+}
+
+
+def num(n, lang):
+    return NUM[lang](n) if n < 10 ** 9 else str(n)
+
+
+def money(amount, code, lang):
+    whole, _, frac = amount.partition(".")
+    whole = int(whole.replace(",", "") or 0)
+    major, minor = CUR[code][lang]
+    if lang in ("eng", "pcm"):
+        s = f"{num(whole, lang)} {major}"
+        if code == "USD" and whole == 1:
+            s = "one dollar"
+        if frac and int(frac[:2].ljust(2, "0")):
+            s += f" {num(int(frac[:2].ljust(2, '0')), lang)} {minor}"
+        return s
+    s = f"{major} {num(whole, lang)}"            # ibo/hau/yor: currency word first ("naịra puku ise")
+    if lang == "yor":
+        s = f"{major} {yor_adj(whole)}"
+    if frac and int(frac[:2].ljust(2, "0")):
+        k = int(frac[:2].ljust(2, "0"))
+        s += {"ibo": " na ", "hau": " da ", "yor": " ó lé "}[lang] + f"{minor} {yor_adj(k) if lang == 'yor' else num(k, lang)}"
+    return s
+
+
+def yor_adj(n):
+    """Yorùbá number after a noun (adjectival form for 1-10, counting form otherwise)."""
+    return _YADJ.get(n) or yor(n)
+
+
+def date(d, m, y, lang):
+    M = MONTHS[lang][m - 1]
+    if lang in ("eng", "pcm"):
+        return f"the {eng_ord(d)} of {M}" + (f", {eng_year(y)}" if y else "")
+    if lang == "ibo":
+        return f"ụbọchị {ibo(d)} n'ọnwa {M}" + (f", afọ {ibo(y)}" if y else "")
+    if lang == "hau":
+        return f"ranar {hau(d)} ga watan {M}" + (f", shekarar {hau(y)}" if y else "")
+    return f"ọjọ́ {yor(d)} oṣù {M}" + (f", ọdún {yor(y)}" if y else "")
+
+
+def clock(h, mi, lang):
+    if lang in ("eng", "pcm"):
+        return eng(h) + ("" if mi == 0 else (" oh " + eng(mi) if mi < 10 else " " + eng(mi))) + (" o'clock" if mi == 0 else "")
+    if lang == "ibo":
+        return f"elekere {ibo(h)}" + ("" if mi == 0 else f" na nkeji {ibo(mi)}")
+    if lang == "hau":
+        return f"ƙarfe {hau(h)}" + ("" if mi == 0 else f" da minti {hau(mi)}")
+    return f"agogo {yor_adj(h)}" + ("" if mi == 0 else f" ó lé ìṣẹ́jú {yor_adj(mi)}")
+
+
+def percent(x, lang):
+    w = decimal(x, lang)
+    return {"eng": f"{w} percent", "pcm": f"{w} percent", "ibo": f"pasentị {w}", "hau": f"kashi {w} cikin ɗari",
+            "yor": f"ìdá {w} nínú ọgọ́rùn-ún"}[lang]
+
+
+_POINT = {"eng": "point", "pcm": "point", "ibo": "ntụpọ", "hau": "digo", "yor": "ààmì"}
+
+
+def decimal(x, lang):
+    a, _, b = x.replace(",", "").partition(".")
+    s = num(int(a or 0), lang)
+    if b:
+        s += f" {_POINT[lang]} " + " ".join(num(int(c), lang) for c in b)
+    return s
+
+
+_AMT = r"\d{1,3}(?:,\d{3})+(?:\.\d+)?|\d+(?:\.\d+)?"
+_RE_MONEY = re.compile(r"(?:(₦|NGN\s?|N(?=\d)|\$|USD\s?|£)\s?(" + _AMT + r")(\s?(?:k|m|bn)\b)?)|(?:(" + _AMT + r")\s?(naira|kobo|dollars?)\b)", re.I)
+_RE_DATE = re.compile(r"\b(\d{1,2})[/.-](\d{1,2})[/.-](\d{4})\b")
+_RE_DATE2 = re.compile(r"\b(\d{1,2})(?:st|nd|rd|th)?\s+(January|February|March|April|May|June|July|August|September|October|November|December|Jan|Feb|Mar|Apr|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec)\.?,?\s*(\d{4})?\b", re.I)
+_RE_TIME = re.compile(r"\b(\d{1,2}):(\d{2})(?:\s?(am|pm)\b)?", re.I)
+_RE_TIME2 = re.compile(r"\b(\d{1,2})\s?(am|pm)\b", re.I)
+_RE_PCT = re.compile(r"(" + _AMT + r")\s?%")
+_RE_ORD = re.compile(r"\b(\d+)(st|nd|rd|th)\b", re.I)
+_RE_YEAR = re.compile(r"\b(1[5-9]\d\d|20\d\d)\b")
+_RE_NUM = re.compile(_AMT)
+_DUP = re.compile(r"\b(n'elekere|elekere|karfe|ƙarfe|ranar|agogo|ọjọ́|ụbọchị)\s+(elekere|ƙarfe|ranar|agogo|ọjọ́|ụbọchị)\b", re.I)
+_SCALE = {"k": 1000, "m": 10 ** 6, "bn": 10 ** 9}
+
+
+def normalize(text, lang):
+    """Verbalise numbers etc. for one language segment (no <lang> tags inside)."""
+    lang = lang if lang in NUM else "eng"
+    t = unicodedata.normalize("NFC", text)
+
+    def _money(m):
+        if m.group(1):
+            sym, amt, sc = m.group(1).strip().upper(), m.group(2), (m.group(3) or "").strip().lower()
+            code = {"₦": "NGN", "N": "NGN", "NGN": "NGN", "$": "USD", "USD": "USD", "£": "GBP"}[sym]
+        else:
+            amt, word, sc = m.group(4), m.group(5).lower(), ""
+            if word == "kobo":
+                k = int(amt.replace(",", ""))
+                return f"{num(k, lang)} kobo" if lang in ("eng", "pcm") else f"{CUR['NGN'][lang][1]} {yor_adj(k) if lang == 'yor' else num(k, lang)}"
+            code = "NGN" if word == "naira" else "USD"
+        if sc:
+            amt = str(int(round(float(amt.replace(",", "")) * _SCALE[sc])))
+        return money(amt, code, lang)
+
+    t = _RE_MONEY.sub(_money, t)
+    t = _RE_PCT.sub(lambda m: percent(m.group(1), lang), t)
+    t = _RE_DATE.sub(lambda m: date(int(m.group(1)), int(m.group(2)), int(m.group(3)), lang)
+                     if 1 <= int(m.group(1)) <= 31 and 1 <= int(m.group(2)) <= 12 else m.group(0), t)
+    t = _RE_DATE2.sub(lambda m: date(int(m.group(1)), _MIDX[m.group(2).lower()[:3]] + 1,
+                                     int(m.group(3)) if m.group(3) else None, lang), t)
+
+    def _time(m):
+        h, mi, ap = int(m.group(1)), int(m.group(2)), (m.group(3) or "").lower()
+        s = clock(h, mi, lang)
+        if ap and lang in ("eng", "pcm"):
+            s += " " + {"am": "a m", "pm": "p m"}[ap]
+        return s
+
+    t = _RE_TIME.sub(_time, t)
+    t = _RE_TIME2.sub(lambda m: (eng(int(m.group(1))) + " " + {"am": "a m", "pm": "p m"}[m.group(2).lower()])
+                      if lang in ("eng", "pcm") else clock(int(m.group(1)), 0, lang), t)
+    if lang in ("eng", "pcm"):
+        t = _RE_ORD.sub(lambda m: eng_ord(int(m.group(1))), t)
+        t = _RE_YEAR.sub(lambda m: eng_year(int(m.group(1))), t)
+    else:
+        t = _RE_ORD.sub(lambda m: num(int(m.group(1)), lang), t)
+    t = _RE_NUM.sub(lambda m: decimal(m.group(0), lang) if "." in m.group(0) else num(int(m.group(0).replace(",", "")), lang), t)
+    t = _DUP.sub(lambda m: m.group(1) if m.group(1).lower().endswith(m.group(2).lower()) or m.group(1).lower() == "karfe" else m.group(0), t)
+    return re.sub(r"\s+", " ", t).strip()
+
+
+def normalize_tagged(text, default="eng"):
+    """Apply normalize() to every <lang>…</lang> segment of a tagged string (untagged text uses `default`)."""
+    out, pos = [], 0
+    for m in re.finditer(r"<(\w{3})>(.*?)</\1>", text, re.S):
+        if m.start() > pos:
+            out.append(normalize(text[pos:m.start()], default) if text[pos:m.start()].strip() else text[pos:m.start()])
+        out.append(f"<{m.group(1)}>{normalize(m.group(2), m.group(1))}</{m.group(1)}>")
+        pos = m.end()
+    if pos < len(text):
+        rest = text[pos:]
+        out.append(normalize(rest, default) if rest.strip() else rest)
+    return "".join(out)
+
+
+if __name__ == "__main__":
+    import sys
+    for L in ["eng", "pcm", "ibo", "hau", "yor"]:
+        print(L, "|", normalize("₦5,000 on 21/10/2026 at 7:30, 45% of 1,235 people, 3.5 km", L))

infer.py

@@ -0,0 +1,801 @@
+#!/usr/bin/env python
+"""Dynamic Accent Pro v1.1: experimental prompt-controlled, code-switching Nigerian TTS.
+
+New in Pro v1.1:
+  --instruct "..."            natural-language style instruction read by the LM. Reliable: pace (slow / fast);
+                              pauses (plenty of / hardly any) via a text step. Tone words (calm/lively) have no
+                              measurable effect; no emotion control. e.g. --instruct "Speak slowly with plenty of pauses."
+                              Without --instruct the LM gets its default prompt (tuned toward native pace and pauses).
+  --codeswitch_prompt "..."   OPTIONAL text pipeline step BEFORE synthesis: a text LLM (Qwen3, Apache-2.0) rewrites plain
+                              text as tagged code-switched text, e.g. "mostly English, Igbo greetings". This is a
+                              pipeline step, not a native model capability; outputs are validated (tags, length,
+                              repetition loops, back-translation meaning check) and fall back to the input text.
+
+Versions (`--version`):
+  pro     (used automatically with --instruct) Flash-Instruct LM `checkpoints/pro/flash_instruct` = Flash-DPO + instruction SFT (licensed data only).
+  phase2/phase3 checkpoints are not in this repo (see Modularcomputing/dynamic-accent-preview).
+  flash   (default) LM `checkpoints/flash/flash_dpo` on Fun-CosyVoice3-0.5B-2512 (Apache-2.0): Flash SFT + DPO preference
+          tuning (naturalness + CER + pace + pause reward), licensed data only. CV3 base flow/vocoder, zero-shot from the
+          voice clip. Text front-end: numbers verbalised, Yoruba/Igbo diacritics restored when missing (ByT5 model in
+          checkpoints/flash/diacritics_byt5). One pass per paragraph (<= ~60 words), model pauses, no post-processing.
+          Needs a CUDA GPU and a CosyVoice clone with CosyVoice3 support.
+  phase2  LM `p2_lm_B` + anchor-SFT flow `p2_flow_sft`. Phase 2 sampler, sentence stitching, edge trim, internal
+          silences capped at 0.6 s, 0.6 s between sentences (exactly the Phase 2 final samples).
+  phase3  LM `p3_lm_full` (re-cut long-form data with natural pauses, ~102 h of Igbo) + the shared Phase 2 flow (see
+          settings.json and checkpoints/phase3/p3_lm_full/config.json). Silence-aware sampler (silence tokens exempt from the repetition check up
+          to a 1 s run), the whole paragraph in ONE pass (up to ~60 words per pass), no audio post-processing: every
+          pause and the pace come from the model.
+
+Voices (`--voice`): `anchor_male` (default; WAXAL Yoruba speaker 4), `waxal_ibo_5_female`, `waxal_yor_5_female`
+(see --list_voices; recommended: phase3 with a female voice, phase2 with anchor_male). A non-anchor voice is zero-shot: its clip is the flow prompt and the LM prompt, and its
+speaker token is used when the LM was trained on that speaker.
+
+  python infer.py --text "<eng>this is dynamic accent,</eng> <pcm>e dey sound nice abi?</pcm>" --version phase3 --out out.wav
+  python infer.py --text "..." --compare --out cmp.wav       # -> cmp_phase2/phase3/flash.wav, same text, seed, voice
+  python infer.py --list_voices
+  python infer.py --auto_tag --tag_only --text "Omo, this traffic no be here o. Ẹ ṣé púpọ̀."   # inspect / edit the tags
+
+Text: wrap each language span in <eng>, <pcm>, <yor>, <ibo> or <hau> tags. Untagged text is treated as English, unless
+--auto_tag (automatic word/span language ID, see tagger.py), --force_lang or --lang_map is given.
+`--pause_mode clause` / `--speed` (prosody v2: fixed gaps + WSOLA) are kept for phase2 only as an experiment; a
+listening test preferred the model's own pauses.
+"""
+
+import argparse, copy, inspect, json, os, re, sys, unicodedata
+
+import numpy as np
+import soundfile as sf
+import librosa
+import torch
+import torch.nn as nn
+import contextlib
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+LANGS = ["eng", "ibo", "hau", "yor", "pcm"]
+L2I = {l: i for i, l in enumerate(LANGS)}
+ANCHOR = "waxal_yor_4"
+DEV = torch.device("cuda" if torch.cuda.is_available() else "cpu")   # set_device() / --device to override
+DEFAULT_SPEED = 1.0    # user listening test 2026-10-21: original model pauses preferred; clause/1.05 kept as experimental
+
+
+def set_device(d):
+    global DEV
+    DEV = torch.device(d if d != "auto" else ("cuda" if torch.cuda.is_available() else "cpu"))
+    return DEV
+
+
+def autocast(dtype):
+    if DEV.type == "cuda" and dtype is not None:
+        return torch.autocast("cuda", dtype=dtype)
+    return contextlib.nullcontext()            # CPU: plain fp32
+
+
+# ------------------------------------------------------------------ text front-end (tags -> spans)
+_TAG = re.compile(r"<(eng|ibo|hau|yor|pcm)>(.*?)</\1>", re.S)
+_SENT = re.compile(r"(?<=[.?!])\s+")
+
+
+def normalize(t):
+    t = unicodedata.normalize("NFC", t)
+    t = t.replace("\u2019", "'").replace("\u2018", "'").replace("\u201c", '"').replace("\u201d", '"')
+    return re.sub(r"\s+", " ", t).strip()
+
+
+def segments(text, default_lang="eng"):
+    out, pos = [], 0
+    for m in _TAG.finditer(text):
+        pre = text[pos:m.start()]
+        if pre.strip():
+            out.append((default_lang, pre))
+        out.append((m.group(1), m.group(2)))
+        pos = m.end()
+    if text[pos:].strip():
+        out.append((default_lang, text[pos:]))
+    res = []
+    for l, s in out:
+        s = normalize(s)
+        if not s:
+            continue
+        if res:
+            s = " " + s
+        res.append((l, s))
+    return res
+
+
+def text_tokens(tok, text, default="eng"):
+    ids, langs = [], []
+    for l, s in segments(text, default):
+        t = tok(s, add_special_tokens=False)["input_ids"]
+        ids += t; langs += [L2I[l]] * len(t)
+    return ids, langs
+
+
+def split_sentences(text):
+    out, cur = [], []
+    for l, s in segments(text):
+        parts = _SENT.split(s.strip())
+        for k, p in enumerate(parts):
+            p = p.strip()
+            if p:
+                cur.append(f"<{l}>{p}</{l}>")
+            if (k < len(parts) - 1 or p[-1:] in ".?!") and cur:
+                out.append(" ".join(cur)); cur = []
+    if cur:
+        out.append(" ".join(cur))
+    return [o for o in out if o.strip()]
+
+
+# ------------------------------------------------------------------ silence post-processing
+def frame_db(y, sr, hop_s=0.01):
+    hop = int(sr * hop_s)
+    n = max(1, len(y) // hop)
+    fr = y[: n * hop].reshape(n, hop)
+    return 10 * np.log10((fr.astype(np.float64) ** 2).mean(1) + 1e-10)
+
+
+def silence_mask(y, sr, rel_db=-40.0, hop_s=0.01):
+    e = frame_db(y, sr, hop_s)
+    return e < np.percentile(e, 98) + rel_db
+
+
+def runs(mask):
+    out, i, n = [], 0, len(mask)
+    while i < n:
+        if mask[i]:
+            j = i
+            while j < n and mask[j]:
+                j += 1
+            out.append((i, j)); i = j
+        else:
+            i += 1
+    return out
+
+
+def trim_edges(w, sr, keep_lead=0.12, keep_tail=0.18):
+    sil = silence_mask(w, sr)
+    sp = np.where(~sil)[0]
+    if not len(sp):
+        return w
+    a, b = sp[0] * 0.01, (sp[-1] + 1) * 0.01
+    out = w[int(max(0, a - keep_lead) * sr): int(min(len(w) / sr, b + keep_tail) * sr)]
+    lead = a - max(0, a - keep_lead)
+    if lead < keep_lead:
+        out = np.concatenate([np.zeros(int((keep_lead - lead) * sr), out.dtype), out])
+    return out
+
+
+def cap_internal(w, sr, cap=0.6):
+    sil = silence_mask(w, sr)
+    hop = int(0.01 * sr)
+    R = [(a, b) for a, b in runs(sil) if a > 0 and b < len(sil) and (b - a) * 0.01 > cap]
+    if not R:
+        return w
+    keep, cur = [], 0
+    for a, b in R:
+        keep.append(w[cur: a * hop + int(cap / 2 * sr)]); cur = b * hop - int(cap / 2 * sr)
+    keep.append(w[cur:])
+    return np.concatenate(keep)
+
+
+
+# ------------------------------------------------------------------ prosody v2: clause chunks, set gaps, pitch-preserving speed
+_PUNCT = re.compile(r"(?<=[,;:.?!])\s+")
+GAPS = {"comma": 0.40, "sent": 0.60, "switch": 0.12}
+JITTER = {"comma": 0.05, "sent": 0.03, "switch": 0.02}
+
+
+def clause_chunks(text):
+    """tagged text -> [(lang, chunk_text, boundary_after)] with boundary in comma|sent|switch|None (None = end).
+    Chunks are cut after , ; : . ? ! and at language switches; a one-word chunk is merged into the next chunk of the
+    same language (one-word LM calls are unstable), keeping its comma inside."""
+    raw = []
+    for l, s in segments(text):
+        for p in _PUNCT.split(s.strip()):
+            if p.strip():
+                raw.append([l, p.strip()])
+    merged = []
+    for c in raw:
+        if merged and merged[-1][0] == c[0] and len(merged[-1][1].split()) < 2:
+            merged[-1][1] = merged[-1][1] + " " + c[1]
+        else:
+            merged.append(c)
+    out = []
+    for i, (l, t) in enumerate(merged):
+        if i == len(merged) - 1:
+            b = None
+        elif t[-1] in ".?!":
+            b = "sent"
+        elif t[-1] in ",;:":
+            b = "comma"
+        else:
+            b = "switch"
+        out.append((l, t, b))
+    return out
+
+
+def trim_tight(w, sr, keep=0.03):
+    sil = silence_mask(w, sr)
+    sp = np.where(~sil)[0]
+    if not len(sp):
+        return w
+    a, b = sp[0] * 0.01, (sp[-1] + 1) * 0.01
+    return w[int(max(0.0, a - keep) * sr): int(min(len(w) / sr, b + keep) * sr)]
+
+
+def time_stretch(w, sr, speed):
+    """pitch-preserving tempo change (speed > 1 = faster). WSOLA via audiotsm, else librosa's phase vocoder."""
+    if abs(speed - 1.0) < 1e-3:
+        return w
+    try:
+        from audiotsm import wsola
+        from audiotsm.io.array import ArrayReader, ArrayWriter
+        r, wr = ArrayReader(w[None].astype(np.float32)), ArrayWriter(1)
+        wsola(1, speed=speed, frame_length=int(0.040 * sr), synthesis_hop=int(0.010 * sr)).run(r, wr)
+        return wr.data[0].astype(np.float32)
+    except ImportError:
+        return librosa.effects.time_stretch(w.astype(np.float32), rate=speed)
+
+
+def fade(w, sr, ms=10):
+    n = min(len(w) // 2, int(sr * ms / 1000))
+    if n > 0:
+        w = w.copy(); r = np.linspace(0, 1, n, dtype=np.float32)
+        w[:n] *= r; w[-n:] *= r[::-1]
+    return w
+
+# ------------------------------------------------------------------ CosyVoice2 base
+def _sf_load_wav(wav, target_sr, min_sr=16000):
+    y, sr = sf.read(wav, dtype="float32", always_2d=True)
+    y = y.mean(1)
+    if sr != target_sr:
+        y = librosa.resample(y, orig_sr=sr, target_sr=target_sr)
+    return torch.from_numpy(y)[None]
+
+
+def load_cosy(model_dir, cosyvoice_dir):
+    sys.path[:0] = [cosyvoice_dir, os.path.join(cosyvoice_dir, "third_party", "Matcha-TTS")]
+    try:                                   # pyworld is only needed for CosyVoice training (F0 features); it often fails
+        import pyworld  # noqa: F401       # to build, so inference runs without it
+    except ImportError:
+        import types
+        sys.modules["pyworld"] = types.ModuleType("pyworld")
+    import cosyvoice.utils.file_utils as fu
+    fu.load_wav = _sf_load_wav
+    import cosyvoice.cli.frontend as cf
+    cf.load_wav = _sf_load_wav
+    from cosyvoice.cli.cosyvoice import CosyVoice2
+    kw = dict(load_jit=False, load_trt=False, fp16=False)
+    sig = inspect.signature(CosyVoice2.__init__).parameters
+    return CosyVoice2(model_dir, **{k: v for k, v in kw.items() if k in sig})
+
+
+def prompt_feats(cosy, wav_path):
+    fe = cosy.frontend
+    tokn, _ = fe._extract_speech_token(wav_path)
+    feat, _ = fe._extract_speech_feat(wav_path)
+    n = min(feat.shape[1] // 2, tokn.shape[1])
+    feat, tokn = feat[:, :2 * n], tokn[:, :n]
+    emb = fe._extract_spk_embedding(wav_path)
+    return tokn.to(DEV), feat.to(DEV), emb.to(DEV)
+
+
+@torch.no_grad()
+def token2wav(cosy, tokens, ptok, pfeat, emb):
+    flow = cosy.model.flow
+    t = torch.tensor([tokens], dtype=torch.int32).to(DEV)
+    kw = dict(token=t, token_len=torch.tensor([t.shape[1]], dtype=torch.int32).to(DEV),
+              prompt_token=ptok, prompt_token_len=torch.tensor([ptok.shape[1]], dtype=torch.int32).to(DEV),
+              prompt_feat=pfeat, prompt_feat_len=torch.tensor([pfeat.shape[1]], dtype=torch.int32).to(DEV),
+              embedding=emb)
+    sig = inspect.signature(flow.inference).parameters
+    if "streaming" in sig:
+        kw["streaming"] = False
+    if "finalize" in sig:
+        kw["finalize"] = True
+    if "flow_cache" in sig:
+        kw["flow_cache"] = torch.zeros(1, 80, 0, 2).to(DEV)
+    mel = flow.inference(**kw)
+    mel = mel[0] if isinstance(mel, tuple) else mel
+    hs = inspect.signature(cosy.model.hift.inference).parameters
+    w = cosy.model.hift.inference(speech_feat=mel, **({"cache_source": torch.zeros(1, 1, 0).to(DEV)} if "cache_source" in hs else {}))
+    w = w[0] if isinstance(w, tuple) else w
+    return w.squeeze().float().cpu().numpy()
+
+
+# ------------------------------------------------------------------ Dynamic Accent LM (Qwen2LM + language + speaker embeddings)
+# S3 tokens that fill silent frames in the anchor's recordings (Phase 3 Stage 0); used by the silence-aware sampler
+SIL_TOKENS = {4137, 4218, 1950, 2031, 3894, 6324, 1707, 3677, 1701, 6405, 1947, 3645, 1944, 1704, 3891, 4134, 3680, 5838, 3651}
+RATES = [None, "very slow", "slow", "normal", "fast", "very fast"]
+
+
+class DALM2(nn.Module):
+    def __init__(self, qlm, n_spk, d=896):
+        super().__init__()
+        self.q = qlm
+        self.lang_emb = nn.Embedding(len(LANGS), d)
+        self.spk_emb = nn.Embedding(n_spk, d)
+        self.rate_emb = nn.Embedding(len(RATES), d, padding_idx=0)   # phase3 speed instruct; zero = none (phase2)
+        nn.init.zeros_(self.rate_emb.weight)
+        self.adv = nn.Sequential(nn.Linear(d, 256), nn.ReLU(), nn.Linear(256, n_spk))  # training-only head
+        self.V = qlm.speech_token_size
+
+    def embed_text(self, ids, langs):
+        return self.q.llm.model.model.embed_tokens(ids) + self.lang_emb(langs)
+
+    def build2(self, ids, langs, spk, rate=0, pids=None, plangs=None, psp=None):
+        sos = self.q.llm_embedding.weight[self.q.sos][None]
+        task = self.q.llm_embedding.weight[self.q.task_id][None]
+        if pids is not None:
+            ids = torch.cat([pids, ids]); langs = torch.cat([plangs, langs])
+        sv = self.spk_emb(spk)
+        if rate:
+            sv = sv + self.rate_emb(torch.tensor(rate, device=sv.device))
+        parts = [sos, self.embed_text(ids, langs), sv[None], task]
+        if psp is not None:
+            parts.append(self.q.speech_embedding(psp))
+        return torch.cat(parts, 0)
+
+    @torch.no_grad()
+    def generate2(self, ids, langs, spk, prompt=None, top_p=0.8, top_k=25, win=10, tau_r=0.1, seed=0,
+                  min_ratio=2.0, max_ratio=20.0, sampler="ras", rate=0, sil_cap=25):
+        """sampler 'ras' = Phase 2 repetition-aware sampling; 'silexcap' = silence tokens exempt from the repetition
+        check while the current silence run is shorter than sil_cap frames (25 = 1.0 s), then the normal check."""
+        g = torch.Generator(device=ids.device).manual_seed(seed)
+        x = self.build2(ids, langs, spk, rate, *(prompt if prompt else (None, None, None)))[None]
+        n = len(ids)
+        min_len, max_len = int(n * min_ratio), int(n * max_ratio)
+        past, out, inp = None, [], x
+        for i in range(max_len):
+            o = self.q.llm.model.model(inputs_embeds=inp, past_key_values=past, use_cache=True, return_dict=True)
+            past = o.past_key_values
+            logp = self.q.llm_decoder(o.last_hidden_state[:, -1]).float().log_softmax(-1)[0]
+            if i < min_len:
+                logp[self.V] = -float("inf")
+            logp[self.V + 1:] = -float("inf")
+            p = logp.exp()
+            sp, si = p.sort(descending=True)
+            keep = (sp.cumsum(0) - sp) < top_p
+            keep[top_k:] = False
+            cp, ci = sp[keep], si[keep]
+            tokid = int(ci[torch.multinomial(cp / cp.sum(), 1, generator=g)])
+            exempt = False
+            if sampler == "silexcap" and tokid in SIL_TOKENS:
+                run = 0
+                for t in reversed(out):
+                    if t not in SIL_TOKENS:
+                        break
+                    run += 1
+                exempt = run < sil_cap
+            if not exempt and out and sum(1 for t in out[-win:] if t == tokid) >= win * tau_r and tokid != self.V:  # RAS
+                tokid = int(torch.multinomial(p, 1, generator=g))
+            if tokid >= self.V:
+                break
+            out.append(tokid)
+            inp = self.q.speech_embedding.weight[tokid][None, None]
+        return out
+
+
+SETTINGS_PATH = os.path.join(HERE, "settings.json")
+SETTINGS = json.load(open(SETTINGS_PATH)) if os.path.exists(SETTINGS_PATH) else {}
+VERSIONS = {k: {kk: vv for kk, vv in v.items() if kk != "desc"} for k, v in SETTINGS.get("versions", {}).items()} or {
+    "phase2": dict(lm="checkpoints/phase2/p2_lm_B/best.pt", flow="checkpoints/phase2/p2_flow_sft/best.pt", sampler="ras",
+                   one_pass=False, postprocess=True, rate=None),
+    "phase3": dict(lm="checkpoints/phase3/p3_lm_full/best.pt", flow="checkpoints/phase2/p2_flow_sft/best.pt",
+                   sampler="silexcap", one_pass=True, postprocess=False, rate="normal"),
+}
+RECOMMENDED = SETTINGS.get("recommended", {})
+
+
+def recommendation(version, voice):
+    """one-line hint when a version/voice pairing is not the recommended one (None when it is)."""
+    rec = RECOMMENDED.get(version)
+    if rec and voice not in rec:
+        return f"note: {version} is recommended with {' or '.join(rec)} ({RECOMMENDED.get('note', '')})"
+    return None
+
+
+def version_cfg(name):
+    cfg = dict(VERSIONS[name])
+    cj = os.path.join(HERE, os.path.dirname(cfg["lm"]), "config.json")
+    if os.path.exists(cj):                      # a checkpoint may override flow / rate / sampler
+        cfg.update({k: v for k, v in json.load(open(cj)).items() if k in cfg})
+    for k in ("lm", "flow", "diacritics"):
+        if cfg.get(k):
+            cfg[k] = os.path.join(HERE, cfg[k])
+    return cfg
+
+
+# ------------------------------------------------------------------ Flash (CosyVoice3 engine)
+FLASH_VOICE = {"anchor_male": "anchor", "waxal_ibo_5_female": "waxal_ibo_5", "waxal_yor_5_female": "waxal_yor_5"}
+
+
+def canonical_voice(voice, voices_json=None):
+    try:
+        al = json.load(open(voices_json, encoding="utf-8")).get("aliases", {}) if voices_json else {}
+    except OSError:
+        al = {}
+    return al.get(voice, voice)
+
+
+class FlashTTS:
+    """--version flash: CosyVoice3 base + Flash-DPO LM (flash_lm.Synth) behind the same say()/sr interface."""
+
+    def __init__(self, a, cfg):
+        if not torch.cuda.is_available():
+            raise SystemExit("--version flash needs a CUDA GPU (phase2/phase3 also run on CPU)")
+        cv3 = getattr(a, "cv3_dir", "") or os.environ.get("CV3_DIR") or os.path.join(HERE, "pretrained", "Fun-CosyVoice3-0.5B-2512")
+        if not os.path.isdir(cv3):
+            from huggingface_hub import snapshot_download
+            snapshot_download("FunAudioLLM/Fun-CosyVoice3-0.5B-2512", local_dir=cv3)
+        os.environ["CV3_DIR"] = cv3
+        os.environ.setdefault("COSYVOICE_REPO", a.cosyvoice_dir)
+        os.environ.setdefault("DA_PROMPTS", os.path.join(HERE, "prompts"))
+        self.instruct = getattr(a, "instruct", None) if cfg.get("instruct") else None
+        if cfg.get("instruct"):
+            import flash_instruct
+            g = a.guidance if getattr(a, "guidance", None) is not None else cfg.get("cfg", 2.0)
+            self.S = flash_instruct.ISynth(a.lm or cfg["lm"], cfg=g)
+            self.S.text_pauses = cfg.get("text_pauses", True) and not getattr(a, "no_text_pauses", False)
+        else:
+            if getattr(a, "instruct", None):
+                print("note: --instruct is ignored by this version (use --version pro)")
+            import flash_lm
+            self.S = flash_lm.Synth(a.lm or cfg["lm"])
+        self.cosy = self.tok = None                  # not shareable with the CosyVoice2 versions
+        self.m = self.S.m
+        self.sr = self.S.cosy.sample_rate
+        r = a.rate if a.rate != "default" else cfg.get("rate", "normal")
+        self.rate = RATES.index(None if r == "none" else r) if (None if r == "none" else r) in RATES else 0
+        self.fe_mode = getattr(a, "frontend", "codeswitch")
+        self.fe_lang = getattr(a, "frontend_lang", "eng")
+        if self.fe_mode == "translate" and not getattr(a, "experimental_translate", False):
+            raise SystemExit("--frontend translate is EXPERIMENTAL and off by default (MADLAD-400 loops on long inputs and is "
+                             "weak on Pidgin). Add --experimental_translate to use it anyway.")
+        from frontend import FrontEnd
+        diac = cfg.get("diacritics") if not getattr(a, "no_diacritics", False) else None
+        self.fe = FrontEnd(diac if diac and os.path.isdir(diac) else None, mt=self.fe_mode == "translate")
+        self.tail_pad = getattr(a, "tail_pad", 0)
+        self.set_voice(a.voice, a.voices)
+
+    def set_voice(self, voice, voices_json=None):
+        v = canonical_voice(voice, voices_json)
+        if v not in FLASH_VOICE:
+            raise SystemExit(f"unknown voice '{voice}' for flash; available: {', '.join(FLASH_VOICE)}")
+        self.voice = FLASH_VOICE[v]
+
+    def frontend(self, text):
+        return self.fe(text, self.fe_mode, self.fe_lang)
+
+    def say(self, tagged_text, seed=0, return_info=False, **_):
+        t = self.frontend(tagged_text)
+        print(f"[flash front-end] {t}")
+        rate = RATES[self.rate]
+        ws = []
+        for i, ch in enumerate(word_chunks(t)):
+            if self.instruct:
+                toks = self.S.tokens(ch, self.voice, rate or "none", seed + 1000 * i, instruct=self.instruct)[0]
+            else:
+                toks = self.S.tokens(ch, self.voice, rate or "none", seed + 1000 * i)[0]
+            pad = int(getattr(self, "tail_pad", 0) or 0)
+            if pad > 0:                                # opt-in: trailing silence tokens so the last phone is not cut
+                toks = list(toks) + [1] * pad
+            ws.append(self.S.wav(toks, self.voice))
+        w = np.concatenate(ws).astype(np.float32)
+        return (w, None) if return_info else w
+
+
+def word_chunks(text, max_words=60):
+    """one pass per <= max_words, split only at sentence ends (a whole paragraph usually fits in one pass)."""
+    sents = split_sentences(text)
+    out, cur, n = [], [], 0
+    for s in sents:
+        w = len(re.sub(r"<[^>]+>", " ", s).split())
+        if cur and n + w > max_words:
+            out.append(" ".join(cur)); cur, n = [], 0
+        cur.append(s); n += w
+    if cur:
+        out.append(" ".join(cur))
+    return out or [text]
+
+
+class DynamicAccent:
+    def __init__(self, model_dir, cosyvoice_dir, lm_ckpt, flow_ckpt, prompts_json, dtype="auto", sent_pause=0.6, cap=0.6,
+                 sampler="ras", one_pass=False, postprocess=True, rate=None, cosy=None, tok=None, copy_llm=False):
+        from transformers import AutoTokenizer
+        self.tok = tok or AutoTokenizer.from_pretrained(os.path.join(model_dir, "CosyVoice-BlankEN"))
+        self.cosy = cosy or load_cosy(model_dir, cosyvoice_dir)
+        self.sr = self.cosy.sample_rate
+        self.flow_sd = torch.load(flow_ckpt, map_location=DEV, weights_only=False)["flow"]
+        self.cosy.model.flow.load_state_dict(self.flow_sd)
+        ck = torch.load(lm_ckpt, map_location=DEV, weights_only=False)
+        self.spk2id = json.load(open(os.path.join(os.path.dirname(lm_ckpt), "spk2id.json")))
+        # two versions resident at once (app.py) must not share LM weights: copy_llm=True gives each its own copy.
+        # The CLI runs versions one after the other and reloads the full LM state in place (saves ~2 GB RAM).
+        qlm = copy.deepcopy(self.cosy.model.llm) if copy_llm else self.cosy.model.llm
+        self.m = DALM2(qlm, ck["n_spk"]).to(DEV).eval()
+        miss = self.m.load_state_dict(ck["model"], strict=False)
+        assert not [k for k in miss.missing_keys if not k.startswith("rate_emb")], miss
+        del ck
+        if DEV.type != "cuda":
+            dtype = "fp32"
+        elif dtype == "auto":
+            dtype = "bf16" if torch.cuda.is_bf16_supported() else "fp16"
+        self.dtype = {"bf16": torch.bfloat16, "fp16": torch.float16, "fp32": None}[dtype]
+        self.sent_pause, self.cap = sent_pause, cap
+        self.sampler, self.one_pass, self.postprocess = sampler, one_pass, postprocess
+        self.rate = RATES.index(rate) if rate in RATES else 0
+        meta = json.load(open(prompts_json, encoding="utf-8"))
+        root = os.path.dirname(os.path.dirname(os.path.abspath(prompts_json)))
+        self.prompts = []
+        for p in meta["prompts"]:
+            ids, langs = text_tokens(self.tok, p["tagged"])
+            lmp = (torch.tensor(ids).to(DEV), torch.tensor(langs).to(DEV), torch.tensor(p["s3_tokens"], dtype=torch.int64).to(DEV))
+            self.prompts.append(dict(id=p["id"], lm=lmp, flow=prompt_feats(self.cosy, os.path.join(root, p["wav"])), spk=ANCHOR))
+        self.voice = None
+
+    def use_flow(self):
+        self.cosy.model.flow.load_state_dict(self.flow_sd)       # two versions may share one CosyVoice2 instance
+
+    def set_voice(self, voice, voices_json=None):
+        """'anchor' or an id from voices.json: its clip is the flow + LM prompt (zero-shot)."""
+        meta = json.load(open(voices_json, encoding="utf-8")) if voices_json else {"voices": {}}
+        voice = meta.get("aliases", {}).get(voice, voice)
+        if voice in (None, "anchor", "anchor_male"):
+            self.voice = None; return
+        if voice not in meta["voices"]:
+            raise SystemExit(f"unknown voice '{voice}'; available: {', '.join(meta['voices'])}")
+        V = meta["voices"][voice]
+        root = os.path.dirname(os.path.dirname(os.path.abspath(voices_json)))
+        ptok, pfeat, pemb = prompt_feats(self.cosy, os.path.join(root, V["wav"]))
+        ids, langs = text_tokens(self.tok, V["tagged"])
+        lmp = (torch.tensor(ids).to(DEV), torch.tensor(langs).to(DEV), ptok[0].long())
+        self.voice = dict(id=voice, lm=lmp, flow=(ptok, pfeat, pemb), spk=V["spk"] if V["spk"] in self.spk2id else ANCHOR)
+
+    def _prompt(self, prompt_k):
+        return self.voice or self.prompts[prompt_k % len(self.prompts)]
+
+    def one(self, tagged_text, seed, prompt_k, use_lm_prompt=True, lm_prompt=None):
+        ids, langs = text_tokens(self.tok, tagged_text)
+        P = self._prompt(prompt_k)
+        with autocast(self.dtype):
+            sp = self.m.generate2(torch.tensor(ids).to(DEV), torch.tensor(langs).to(DEV), torch.tensor(self.spk2id[P["spk"]]).to(DEV),
+                                  prompt=(lm_prompt or P["lm"]) if use_lm_prompt else None, seed=seed, sampler=self.sampler,
+                                  rate=self.rate, max_ratio=30.0 if self.one_pass else 20.0)
+        if len(sp) < 3:
+            sp = sp + [0] * 3
+        self.last_tokens = sp
+        return token2wav(self.cosy, sp, *P["flow"])
+
+    def say(self, tagged_text, seed=0, prompt_k=0, stitch=True, pause_mode="model", speed=1.0, return_info=False):
+        self.use_flow()
+        if self.one_pass:                      # phase3: the model makes every pause; nothing is trimmed or inserted
+            ws, prev = [], None
+            for i, ch in enumerate(word_chunks(tagged_text)):
+                w = self.one(ch, seed + 1000 * i, prompt_k, lm_prompt=prev)
+                ws.append(w)
+                ids, langs = text_tokens(self.tok, ch)       # next chunk continues from this one (model sets the gap)
+                if len(self.last_tokens) <= 400:
+                    prev = (torch.tensor(ids).to(DEV), torch.tensor(langs).to(DEV), torch.tensor(self.last_tokens).to(DEV))
+            w = np.concatenate(ws)
+            return (w, None) if return_info else w
+        if pause_mode == "clause":
+            return self.say_clause(tagged_text, seed, prompt_k, speed, return_info)
+        w = self.say_model(tagged_text, seed, prompt_k, stitch)
+        w = time_stretch(w, self.sr, speed)
+        return (w, None) if return_info else w
+
+    def say_clause(self, tagged_text, seed=0, prompt_k=0, speed=1.10, return_info=False):
+        rng = np.random.default_rng(seed)
+        chunks = clause_chunks(tagged_text)
+        out, info, lead = [], [], 0.03
+        for i, (l, t, b) in enumerate(chunks):
+            w = self.one(f"<{l}>{t}</{l}>", seed + 1000 * i, prompt_k)
+            w = cap_internal(trim_tight(w, self.sr), self.sr, self.cap)
+            w = fade(time_stretch(w, self.sr, speed), self.sr)
+            if i == 0:
+                out.append(np.zeros(int(0.12 * self.sr), np.float32))
+            out.append(w)
+            if b is not None:
+                g = GAPS[b] + rng.uniform(-JITTER[b], JITTER[b])
+                out.append(np.zeros(max(0, int((g - 2 * lead) * self.sr)), np.float32))
+            else:
+                out.append(np.zeros(int(0.15 * self.sr), np.float32))
+            info.append(dict(lang=l, text=t, boundary=b))
+        w = np.concatenate(out)
+        return (w, info) if return_info else w
+
+    def say_model(self, tagged_text, seed=0, prompt_k=0, stitch=True):
+        sents = split_sentences(tagged_text) if stitch else [tagged_text]
+        ws = [cap_internal(trim_edges(self.one(s, seed + 1000 * i, prompt_k), self.sr), self.sr, self.cap)
+              for i, s in enumerate(sents)]
+        if len(ws) == 1:
+            return ws[0]
+        out = []
+        for i, w in enumerate(ws):
+            if i:
+                out.append(np.zeros(max(0, int((self.sent_pause - 0.30) * self.sr)), np.float32))
+            out.append(w)
+        return np.concatenate(out)
+
+
+def build(version, a, cosy=None, tok=None, copy_llm=False):
+    cfg = version_cfg(version)
+    if cfg.get("engine") == "cosyvoice3":
+        return FlashTTS(a, cfg)
+    lm = a.lm or cfg["lm"]; flow = a.flow or cfg["flow"]
+    S = DynamicAccent(a.model_dir, a.cosyvoice_dir, lm, flow, a.prompts, a.dtype, sampler=cfg["sampler"],
+                      one_pass=cfg["one_pass"] and not a.stitch, postprocess=cfg["postprocess"],
+                      rate=a.rate if a.rate != "default" else cfg["rate"], cosy=cosy, tok=tok, copy_llm=copy_llm)
+    S.set_voice(a.voice, a.voices)
+    return S
+
+
+def list_voices(voices_json):
+    V = json.load(open(voices_json, encoding="utf-8"))["voices"] if os.path.exists(voices_json) else {}
+    print("voices (--voice):")
+    for k, v in V.items():
+        print(f"  {k:20s} {v.get('desc', '')}")
+    print("\nversions (--version):")
+    for k, v in SETTINGS.get("versions", {}).items():
+        print(f"  {k:20s} {v.get('desc', '')}")
+    if RECOMMENDED:
+        print("\nrecommended pairing: " + "; ".join(f"{k} -> {', '.join(v)}" for k, v in RECOMMENDED.items() if isinstance(v, list)))
+        print("  " + RECOMMENDED.get("note", ""))
+
+
+def instruct_lang(instr):
+    """single language named in an instruction (None when none or a mix is asked for)."""
+    t = instr.lower()
+    names = {"igbo": "ibo", "yoruba": "yor", "hausa": "hau", "pidgin": "pcm"}
+    hit = [v for k, v in names.items() if k in t]
+    if len(hit) == 1 and not any(w in t for w in ("mix", "english", "code-switch", "switch")):
+        return hit[0]
+    return None
+
+
+def instruct_gender(instr):
+    t = " " + instr.lower() + " "
+    if any(w in t for w in (" female", " woman", " woman's", " women")):
+        return "female"
+    if any(w in t for w in (" male ", " male,", " man ", " man's")):
+        return "male"
+    return None
+
+
+def prepare_text(a):
+    """apply --auto_tag / --force_lang / --lang_map; returns the tagged text that will be synthesised."""
+    from tagger import Tagger, parse_map, TAGGED
+    text = a.text
+    if a.force_lang:
+        from tagger import strip_tags
+        return f"<{a.force_lang}>{strip_tags(text)}</{a.force_lang}>"
+    if a.auto_tag or a.lang_map:
+        if TAGGED.search(text) and not a.auto_tag:
+            return text
+        from tagger import strip_tags
+        T = Tagger(None if a.lid == "none" else a.lid, parse_map(a.lang_map))
+        return T.tag(strip_tags(text))
+    return text
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--text", help="text; tagged ('<eng>Good morning,</eng> <pcm>how body?</pcm>') or plain with --auto_tag")
+    ap.add_argument("--version", default=SETTINGS.get("default_version", "phase3"), choices=sorted(VERSIONS),
+                    help=f"model version (default {SETTINGS.get('default_version', 'phase3')})")
+    ap.add_argument("--compare", action="store_true",
+                    help="render the same text, seed and voice with every version in --compare_versions -> <out>_<version>.wav")
+    ap.add_argument("--compare_versions", default="flash,pro", help="versions for --compare (comma-separated)")
+    ap.add_argument("--instruct", default=None,
+                    help='pro only: natural-language style instruction, e.g. "Speak quickly with few pauses, lively tone."')
+    ap.add_argument("--codeswitch_prompt", default=None,
+                    help='optional text LLM step: rewrite plain --text as code-switched text, e.g. "mostly English, Igbo greetings"')
+    ap.add_argument("--guidance", type=float, default=None,
+                    help="pro: classifier-free guidance strength on --instruct (default 2.0 from settings.json; 0 = off)")
+    ap.add_argument("--no_text_pauses", action="store_true",
+                    help="pro: do not edit the text for few/many-pause instructions (model-only pause control is weak)")
+    ap.add_argument("--cs_llm", default=os.environ.get("CS_LLM", "Qwen/Qwen3-32B"),
+                    help="text LLM for --codeswitch_prompt (Apache-2.0 Qwen3; Qwen/Qwen3-14B needs less GPU memory)")
+    ap.add_argument("--voice", default=SETTINGS.get("default_voice", "anchor_male"),
+                    help="anchor_male | waxal_ibo_5_female | waxal_yor_5_female (see --list_voices)")
+    ap.add_argument("--list_voices", action="store_true", help="list voices, versions and the recommended pairing")
+    ap.add_argument("--rate", default="default", choices=["default", "none", "very slow", "slow", "normal", "fast", "very fast"],
+                    help="phase3/flash speed instruction to the LM (default: the version's setting, 'normal'; 'none' = no instruction)")
+    # flash text front-end
+    ap.add_argument("--frontend", default="codeswitch", choices=["codeswitch", "native", "accent", "translate"],
+                    help="flash only: codeswitch (tagged/one-language text), native (whole text in --frontend_lang), accent "
+                         "(words as written, read with the --frontend_lang accent), translate (EXPERIMENTAL, off by default)")
+    ap.add_argument("--frontend_lang", default="eng", choices=LANGS, help="flash front-end language for untagged text / native / accent / translate target")
+    ap.add_argument("--no_diacritics", action="store_true", help="flash: do not restore missing Yoruba/Igbo diacritics")
+    ap.add_argument("--experimental_translate", action="store_true",
+                    help="flash: allow --frontend translate (MADLAD-400-3B-MT, ~12 GB download; loops on long inputs, weak on Pidgin)")
+    ap.add_argument("--cv3_dir", default=os.environ.get("CV3_DIR", os.path.join(HERE, "pretrained", "Fun-CosyVoice3-0.5B-2512")),
+                    help="flash: stock FunAudioLLM/Fun-CosyVoice3-0.5B-2512 snapshot (downloaded on first run)")
+    # code-switching control
+    ap.add_argument("--auto_tag", action="store_true",
+                    help="tag untagged mixed text automatically (word/span language ID), print it, then synthesise")
+    ap.add_argument("--tag_only", action="store_true", help="with --auto_tag: print the tagged text and exit (edit it, then pass it back as --text)")
+    ap.add_argument("--force_lang", choices=LANGS, help="read the whole text in one language (tags are ignored)")
+    ap.add_argument("--lang_map", default="", help='per-word language overrides for the tagger, e.g. "omo=pcm,sha=pcm"')
+    ap.add_argument("--lid", default="none", choices=["none", "glotlid"],
+                    help="optional LID model for --auto_tag (glotlid: cis-lmu/glotlid, Apache-2.0, 1.7 GB, pip install fasttext)")
+    ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--tail_pad", type=int, default=0,
+                    help="flash/pro: append N silence speech tokens (25 per second) before the vocoder so the final syllable "
+                         "is not clipped; 6 removed measured clipped endings in testing (opt-in, default 0)")
+    ap.add_argument("--out", default="out.wav")
+    ap.add_argument("--prompt_clip", type=int, default=0, help="anchor prompt clip 0-3 (final systems: 0)")
+    ap.add_argument("--model_dir", default=os.environ.get("COSYVOICE2_DIR", os.path.join(HERE, "pretrained", "CosyVoice2-0.5B")),
+                    help="stock FunAudioLLM/CosyVoice2-0.5B snapshot (downloaded on first run)")
+    ap.add_argument("--cosyvoice_dir", default=os.environ.get("COSYVOICE_REPO", os.path.join(HERE, "CosyVoice")),
+                    help="clone of github.com/FunAudioLLM/CosyVoice (with submodules)")
+    ap.add_argument("--lm", default="", help="override the version's LM checkpoint")
+    ap.add_argument("--flow", default="", help="override the version's flow checkpoint")
+    ap.add_argument("--prompts", default=os.path.join(HERE, "prompts", "prompts.json"))
+    ap.add_argument("--voices", default=os.path.join(HERE, "prompts", "voices.json"))
+    ap.add_argument("--dtype", default="auto", choices=["auto", "bf16", "fp16", "fp32"],
+                    help="LM autocast dtype on GPU (samples: bf16; auto picks fp16 on GPUs without bf16). CPU always runs fp32")
+    ap.add_argument("--stitch", action="store_true", help="phase3: generate sentence by sentence instead of one pass")
+    ap.add_argument("--no_stitch", action="store_true", help="phase2: generate multi-sentence text in one pass")
+    ap.add_argument("--pause_mode", default="model", choices=["clause", "model"], help="phase2 only; clause = experimental prosody v2 (not recommended)")
+    ap.add_argument("--speed", type=float, default=DEFAULT_SPEED, help="phase2 only; pitch-preserving tempo factor (1.0 = as trained; not recommended)")
+    a = ap.parse_args()
+    a.voice_set = any(x == "--voice" or x.startswith("--voice=") for x in sys.argv)
+    a.version_set = any(x == "--version" or x.startswith("--version=") for x in sys.argv)
+    if a.instruct and not a.version_set and not a.compare and "pro" in VERSIONS:
+        a.version = "pro"; print("[instruct] using --version pro (instruction-controlled)")
+    if a.list_voices:
+        list_voices(a.voices); return
+    if not a.text:
+        ap.error("--text is required")
+    if a.codeswitch_prompt:
+        from cs_frontend import CodeSwitchFrontEnd, TAG
+        from tagger import strip_tags
+        fe = CodeSwitchFrontEnd(model=a.cs_llm)
+        cs_text, info = fe(strip_tags(a.text), a.codeswitch_prompt)
+        print(f"[code-switch front end] {cs_text}" + ("" if info["ok"] else f"  ({info['warning']})"))
+        del fe; torch.cuda.empty_cache()
+        a.text = cs_text
+    elif a.instruct and not a.force_lang:
+        il = instruct_lang(a.instruct)
+        from tagger import TAGGED
+        if il and not TAGGED.search(a.text) and not a.auto_tag:
+            a.force_lang = il                      # "Speak in Igbo ..." on untagged text -> read it as Igbo
+    if a.instruct and not a.voice_set:
+        g = instruct_gender(a.instruct)
+        if g == "female":
+            a.voice = "waxal_ibo_5_female"; print("[instruct] female voice requested -> --voice waxal_ibo_5_female")
+    text = prepare_text(a)
+    if text != a.text or a.auto_tag:
+        print(f"[tagged] {text}")
+    if a.tag_only:
+        return
+    versions = [v.strip() for v in a.compare_versions.split(",") if v.strip()] if a.compare else [a.version]
+    bad = [v for v in versions if v not in VERSIONS]
+    if bad:
+        ap.error(f"unknown version(s) {bad}; available: {sorted(VERSIONS)}")
+    if any(VERSIONS[v].get("engine") != "cosyvoice3" for v in versions) and not os.path.isdir(a.model_dir):
+        from huggingface_hub import snapshot_download
+        snapshot_download("FunAudioLLM/CosyVoice2-0.5B", local_dir=a.model_dir)
+    cosy = tok = None
+    base, ext = os.path.splitext(a.out)
+    for v in versions:
+        hint = recommendation(v, json.load(open(a.voices)).get("aliases", {}).get(a.voice, a.voice) if os.path.exists(a.voices) else a.voice)
+        if hint:
+            print(hint)
+        S = build(v, a, cosy, tok)
+        if S.cosy is not None:
+            cosy, tok = S.cosy, S.tok
+        w = S.say(text, seed=a.seed, prompt_k=a.prompt_clip, stitch=not a.no_stitch, pause_mode=a.pause_mode,
+                  speed=a.speed if v == "phase2" else 1.0)
+        out = f"{base}_{v}{ext or '.wav'}" if a.compare else a.out
+        sf.write(out, w, S.sr)
+        print(f"[{v}] wrote {out} ({len(w) / S.sr:.2f} s, {S.sr} Hz, voice={a.voice}, device={DEV.type})")
+        del S.m
+        if isinstance(S, FlashTTS):
+            del S.S
+        del S; torch.cuda.empty_cache()
+
+
+if __name__ == "__main__":
+    main()

instruct_text.py

@@ -0,0 +1,130 @@
+"""Natural-language instruction templates for Flash-Instruct.
+labels: dict(lang=<ibo|yor|hau|pcm|eng|cs:<l1>+<l2>>, rate=slow|normal|fast|None, pause=few|normal|many|None,
+             energy=calm|neutral|lively|None, gender=male|female|None)
+make(labels, rng) -> one instruction string (many surface forms per label combination).
+DEFAULT = the original CosyVoice3 system prompt; ~18% of training items keep it.
+"""
+import random
+
+DEFAULT = "You are a helpful assistant."
+LN = {"ibo": "Igbo", "yor": "Yoruba", "hau": "Hausa", "pcm": "Nigerian Pidgin", "eng": "Nigerian English"}
+
+RATE = {
+    "slow": ["slowly", "at an unhurried pace", "at a slow, relaxed pace", "taking your time", "at a gentle, slow pace",
+             "a little slower than usual", "slowly and deliberately"],
+    "normal": ["at a natural pace", "at a normal speaking pace", "at a steady, everyday pace", "at a comfortable pace"],
+    "fast": ["quickly", "at a brisk pace", "fast, like quick everyday conversation", "at a quick pace",
+             "a little faster than usual", "briskly"],
+}
+PAUSE = {
+    "few": ["with few pauses", "in one smooth flow with hardly any pauses", "without stopping much",
+            "with minimal pausing", "running the phrases together"],
+    "normal": ["with natural pauses", "with normal phrasing", "pausing where it feels natural"],
+    "many": ["with plenty of pauses", "pausing often between phrases", "with frequent pauses",
+             "with lots of breaks between phrases", "with deliberate pauses"],
+}
+ENERGY = {
+    "calm": ["calm", "soft and calm", "gentle, even-toned", "relaxed and low-key", "quiet and steady"],
+    "neutral": ["neutral", "plain, matter-of-fact", "even", "straightforward"],
+    "lively": ["lively", "animated", "expressive and energetic", "bright and lively", "upbeat, expressive"],
+}
+GENDER = {"male": ["male", "man's"], "female": ["female", "woman's"]}
+
+
+def art(w):
+    return ("an " if w[:1].lower() in "aeiou" else "a ") + w
+
+
+def lang_phrase(lang, rng):
+    if lang.startswith("cs:"):
+        a, b = lang[3:].split("+")
+        A, B = LN.get(a, a), LN.get(b, b).replace("Nigerian English", "English")
+        return rng.choice([f"an {A}-{B} mix" if A[0] in "AEIOU" else f"a {A}-{B} mix", f"mixed {A} and {B}",
+                           f"{A} with some {B} mixed in", f"code-switched {A} and {B}"])
+    return LN.get(lang, lang)
+
+
+def make(lab, rng=random):
+    parts = {}
+    if lab.get("rate"):
+        parts["rate"] = rng.choice(RATE[lab["rate"]])
+    if lab.get("pause"):
+        parts["pause"] = rng.choice(PAUSE[lab["pause"]])
+    if lab.get("energy"):
+        parts["energy"] = rng.choice(ENERGY[lab["energy"]])
+    lang = lang_phrase(lab["lang"], rng) if lab.get("lang") else None
+    g = rng.choice(GENDER[lab["gender"]]) if lab.get("gender") else None
+    tone = parts.get("energy")
+    adv = [parts[k] for k in ("rate", "pause") if k in parts]
+    advs = ", ".join(adv)
+    T = []
+    # template family 1: imperative sentence
+    s = "Speak"
+    if lang:
+        s += f" in {lang}" + (f", sounding {tone}," if tone else "")
+    elif tone:
+        s += f" in {art(tone)} tone"
+    if advs:
+        s += f" {advs}"
+    T.append(s + ".")
+    # family 2: read-this style
+    s = "Read this"
+    if advs:
+        s += f" {advs}"
+    if tone:
+        s += f", in {art(tone)} voice"
+    if lang:
+        s += f". The language is {lang}"
+    T.append(s + ".")
+    # family 3: descriptive/caption style
+    d = []
+    if g:
+        d.append(f"A {g} voice")
+    else:
+        d.append("A speaker")
+    if lang:
+        d.append(f"speaking {lang}")
+    s = " ".join(d)
+    if advs:
+        s += f", {advs}"
+    if tone:
+        s += f"; the delivery is {tone}" if (lang or advs) else f" with {art(tone)} delivery"
+    T.append(s + ".")
+    # family 4: tag list
+    tags = []
+    if lang: tags.append(f"language: {lang}")
+    if "rate" in parts: tags.append(f"pace: {lab['rate']}")
+    if "pause" in parts: tags.append(f"pauses: {lab['pause']}")
+    if tone: tags.append(f"tone: {lab['energy']}")
+    if g: tags.append(f"voice: {lab['gender']}")
+    if tags:
+        T.append("Style - " + "; ".join(tags) + ".")
+    # family 5: polite request
+    s = "Please say this"
+    if lang:
+        s += f" in {lang}"
+    if tone:
+        s += f" with {art(tone)} delivery"
+    if advs:
+        s += f", {advs}"
+    T.append(s + ".")
+    out = rng.choice(T)
+    return out[0].upper() + out[1:]
+
+
+def sample_labels(full, rng, p=None):
+    """drop each control independently so instructions mention subsets; keep at least one."""
+    p = p or dict(lang=0.55, rate=0.75, pause=0.7, energy=0.6, gender=0.3)
+    while True:
+        lab = {k: (v if (v and rng.random() < p.get(k, 0.5)) else None) for k, v in full.items()}
+        if any(lab.values()):
+            return lab
+
+
+if __name__ == "__main__":
+    r = random.Random(0)
+    full = dict(lang="cs:ibo+eng", rate="slow", pause="many", energy="calm", gender="female")
+    for _ in range(12):
+        print(make(sample_labels(full, r), r))
+    for l in ["ibo", "yor", "hau", "pcm", "eng"]:
+        print(make(dict(lang=l, rate="fast", pause="few", energy="lively"), r))

pause_text.py

@@ -0,0 +1,42 @@
+"""Text-side pause control (pipeline step): 'many pauses' -> insert the model's trained [pause] tag at commas and
+every ~5 words inside long phrases; 'few pauses' -> drop commas/semicolons and [pause] tags inside sentences."""
+import re
+TAGRE = re.compile(r"(<\w+>)(.*?)(</\w+>)", re.S)
+
+
+def _many(s, every=5):
+    out = []
+    for sent in re.split(r"(?<=[.!?])\s+", s.strip()):
+        parts = re.split(r"(,|;|:)", sent)
+        buf = []
+        for p in parts:
+            if p in (",", ";", ":"):
+                buf.append(p + " [pause]"); continue
+            w = p.split(); chunk = []
+            for i, x in enumerate(w):
+                chunk.append(x)
+                if (i + 1) % every == 0 and i + 1 < len(w) - 1:
+                    chunk.append("[pause]")
+            buf.append(" ".join(chunk))
+        out.append(" ".join(b for b in buf if b).replace(" ,", ",").replace(" ;", ";"))
+    return " [pause] ".join(out) if len(out) > 1 else out[0]
+
+
+def _few(s):
+    s = s.replace("[pause]", " ").replace("[breath]", " ")
+    s = re.sub(r"\s*[,;:]\s*", " ", s)
+    return " ".join(s.split())
+
+
+def apply(text, mode):
+    f = _many if mode == "many" else _few if mode == "few" else None
+    if f is None:
+        return text
+    if TAGRE.search(text):
+        return TAGRE.sub(lambda m: m.group(1) + f(m.group(2)) + m.group(3), text)
+    return f(text)
+
+
+if __name__ == "__main__":
+    t = "<ibo>Ndewo nụ, ụmụnna m.</ibo> <eng>Tonight we will talk about the new market road and the school fees,</eng> <ibo>ma ọ bụrụ na ego ezughị.</ibo>"
+    print(apply(t, "many")); print(apply(t, "few"))

prompts/clip0_waxal_yor_yor_1258.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7e368595eb4c267f124164c7d8a83b03462d549c5efd235dd8ec6eb557dc418
+size 285164

prompts/clip1_waxal_yor_yor_1205.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8731a9032a1e84a88a2494b65a576794f732cf5c8555c1b94af1a5d370ad7c9
+size 314924

prompts/clip2_waxal_yor_yor_1263.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cf10737379673b123cee008f78006f4fa2fdabc779563d466f85f0772b9cec5
+size 194924

prompts/clip3_waxal_yor_yor_1218.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a0e00a437713a35429fe9423c3acf4ec668038e418fc7b85391bec53cb2368a
+size 262124

prompts/flash_voices_text.json

@@ -0,0 +1,3 @@
+{"anchor": "<yor>Púpọ̀ jùlọ àwọn olókìkí ní ìlú Èkó ń gbé ní erékùṣù náà.</yor>",
+ "waxal_ibo_5": "<ibo>I nwere ike itinye mmemme ọbụla n'izu a ma gị atụla ụjọ maka oké mmiri ozuzo.</ibo>",
+ "waxal_yor_5": "<yor>Nínú oṣù Ọpẹ́ ni ó ra mọ́tò tí wọ́n jí gbé.</yor>"}

prompts/prompts.json

@@ -0,0 +1,602 @@
+{
+ "anchor_speaker": "waxal_yor_4",
+ "source": "WAXAL (CC-BY-SA-4.0), anchor val clips, pause profile B (~/data3)",
+ "prompts": [
+  {
+   "index": 0,
+   "id": "waxal_yor_yor_1258",
+   "wav": "prompts/clip0_waxal_yor_yor_1258.wav",
+   "lang": "yor",
+   "text": "Púpọ̀ jùlọ àwọn olókìkí ní ìlú Èkó ń gbé ní erékùṣù náà.",
+   "tagged": "<yor>Púpọ̀ jùlọ àwọn olókìkí ní ìlú Èkó ń gbé ní erékùṣù náà.</yor>",
+   "dur": 5.94,
+   "s3_tokens": [
+    3677,
+    4137,
+    4218,
+    2166,
+    1452,
+    5830,
+    2175,
+    2112,
+    696,
+    5027,
+    4834,
+    2344,
+    1860,
+    5973,
+    1939,
+    1862,
+    1558,
+    3880,
+    316,
+    2621,
+    2864,
+    2864,
+    2891,
+    5051,
+    3412,
+    3888,
+    3888,
+    1458,
+    1701,
+    1950,
+    1973,
+    1946,
+    3890,
+    4133,
+    692,
+    3617,
+    4346,
+    3617,
+    5030,
+    4955,
+    2768,
+    4955,
+    2789,
+    2006,
+    2903,
+    3395,
+    3771,
+    6013,
+    3853,
+    5096,
+    5095,
+    1350,
+    978,
+    2298,
+    5586,
+    1122,
+    1788,
+    2598,
+    295,
+    566,
+    51,
+    3669,
+    3748,
+    2938,
+    4751,
+    4750,
+    4741,
+    2006,
+    1349,
+    1835,
+    1510,
+    1588,
+    2180,
+    5581,
+    4606,
+    2330,
+    1127,
+    573,
+    660,
+    1364,
+    617,
+    2290,
+    5209,
+    2077,
+    2076,
+    2184,
+    967,
+    4616,
+    4607,
+    4526,
+    4769,
+    2591,
+    4526,
+    4579,
+    2446,
+    4137,
+    4137,
+    4137,
+    1959,
+    3670,
+    3671,
+    3751,
+    1479,
+    4769,
+    5021,
+    4994,
+    4751,
+    5561,
+    5561,
+    5236,
+    3255,
+    4218,
+    4218,
+    4218,
+    4137,
+    5352,
+    6081,
+    5379,
+    1006,
+    1034,
+    4679,
+    2960,
+    2411,
+    1207,
+    860,
+    4760,
+    233,
+    1407,
+    654,
+    3567,
+    5826,
+    6310,
+    5481,
+    5563,
+    3348,
+    6556,
+    2102,
+    886,
+    1563,
+    1479,
+    2300,
+    4547,
+    4546,
+    2522,
+    263,
+    263,
+    1225,
+    1953,
+    1947
+   ]
+  },
+  {
+   "index": 1,
+   "id": "waxal_yor_yor_1205",
+   "wav": "prompts/clip1_waxal_yor_yor_1205.wav",
+   "lang": "yor",
+   "text": "Mejìlá ní ìsọdipúpọ̀ nípasẹ̀ mẹ́rin dọ́gba mejì-mejìlá.",
+   "tagged": "<yor>Mejìlá ní ìsọdipúpọ̀ nípasẹ̀ mẹ́rin dọ́gba mejì-mejìlá.</yor>",
+   "dur": 6.56,
+   "s3_tokens": [
+    3677,
+    1968,
+    1804,
+    1884,
+    1883,
+    2312,
+    4579,
+    3021,
+    1041,
+    5250,
+    4858,
+    80,
+    3799,
+    1532,
+    731,
+    6158,
+    4486,
+    3669,
+    5938,
+    3748,
+    4742,
+    4751,
+    4751,
+    4751,
+    4714,
+    5605,
+    1951,
+    2031,
+    1978,
+    3481,
+    1268,
+    3721,
+    4672,
+    4999,
+    4752,
+    586,
+    2894,
+    2413,
+    1608,
+    2347,
+    1940,
+    1410,
+    2139,
+    6558,
+    5829,
+    2148,
+    2112,
+    1410,
+    5099,
+    5081,
+    2894,
+    707,
+    518,
+    1308,
+    1950,
+    4131,
+    3645,
+    1707,
+    1959,
+    1987,
+    1753,
+    1484,
+    5857,
+    1482,
+    4571,
+    3637,
+    4299,
+    1383,
+    3574,
+    4214,
+    3647,
+    56,
+    5401,
+    6374,
+    1035,
+    32,
+    2303,
+    2303,
+    227,
+    2127,
+    6502,
+    1882,
+    4742,
+    4490,
+    4579,
+    4550,
+    3016,
+    1724,
+    377,
+    377,
+    2456,
+    2456,
+    25,
+    3903,
+    3975,
+    4137,
+    4218,
+    4137,
+    4137,
+    6324,
+    6324,
+    6324,
+    1968,
+    3913,
+    1727,
+    1807,
+    1110,
+    2666,
+    5078,
+    5078,
+    1125,
+    2157,
+    1452,
+    389,
+    5186,
+    2999,
+    2513,
+    2270,
+    3242,
+    5429,
+    5105,
+    5103,
+    2922,
+    1464,
+    1950,
+    4218,
+    1987,
+    1987,
+    1987,
+    1804,
+    6256,
+    1639,
+    2573,
+    4849,
+    4696,
+    1509,
+    1779,
+    4440,
+    5911,
+    4857,
+    4777,
+    323,
+    323,
+    2445,
+    978,
+    1950,
+    1968,
+    1996,
+    1885,
+    1882,
+    4760,
+    4696,
+    3966,
+    5658,
+    4431,
+    5506,
+    78,
+    5986,
+    74,
+    1460,
+    1460,
+    982,
+    1701,
+    1947
+   ]
+  },
+  {
+   "index": 2,
+   "id": "waxal_yor_yor_1263",
+   "wav": "prompts/clip2_waxal_yor_yor_1263.wav",
+   "lang": "yor",
+   "text": "Ọmọ ọdún méji ni Nóla ní oṣù kẹwàá.",
+   "tagged": "<yor>Ọmọ ọdún méji ni Nóla ní oṣù kẹwàá.</yor>",
+   "dur": 4.06,
+   "s3_tokens": [
+    3677,
+    4218,
+    2057,
+    4217,
+    2762,
+    2127,
+    4314,
+    2852,
+    2771,
+    572,
+    4835,
+    963,
+    1914,
+    954,
+    6554,
+    5041,
+    6502,
+    4068,
+    2420,
+    4858,
+    2265,
+    1995,
+    2022,
+    4440,
+    5262,
+    5506,
+    323,
+    753,
+    1563,
+    750,
+    323,
+    2267,
+    2591,
+    2321,
+    2240,
+    4670,
+    2455,
+    4389,
+    2922,
+    3648,
+    4137,
+    1950,
+    1987,
+    1753,
+    1481,
+    1480,
+    3745,
+    6012,
+    1073,
+    4949,
+    5054,
+    2297,
+    5905,
+    5986,
+    2216,
+    5915,
+    5186,
+    5186,
+    4469,
+    2916,
+    3645,
+    1458,
+    1464,
+    4218,
+    4137,
+    1725,
+    3670,
+    3831,
+    2941,
+    5102,
+    5561,
+    6074,
+    5234,
+    2012,
+    2006,
+    2096,
+    2912,
+    5828,
+    2990,
+    6051,
+    6054,
+    1588,
+    2072,
+    2139,
+    1734,
+    2355,
+    2528,
+    4571,
+    2384,
+    881,
+    644,
+    1456,
+    2185,
+    707,
+    1946,
+    812,
+    3242,
+    5914,
+    4545,
+    1711,
+    2031,
+    6405
+   ]
+  },
+  {
+   "index": 3,
+   "id": "waxal_yor_yor_1218",
+   "wav": "prompts/clip3_waxal_yor_yor_1218.wav",
+   "lang": "yor",
+   "text": "Ìdajì àti ọ̀kan kẹ́fà dọ́gba méji kẹ́ta.",
+   "tagged": "<yor>Ìdajì àti ọ̀kan kẹ́fà dọ́gba méji kẹ́ta.</yor>",
+   "dur": 5.46,
+   "s3_tokens": [
+    3707,
+    2031,
+    566,
+    566,
+    4778,
+    861,
+    1770,
+    68,
+    3083,
+    5996,
+    4570,
+    777,
+    3939,
+    4683,
+    5169,
+    5911,
+    3239,
+    1052,
+    286,
+    259,
+    5109,
+    2922,
+    2922,
+    3894,
+    3651,
+    2031,
+    1976,
+    3161,
+    3890,
+    3890,
+    2219,
+    1527,
+    2085,
+    6380,
+    6131,
+    5401,
+    1038,
+    2267,
+    4697,
+    4697,
+    4778,
+    4697,
+    4778,
+    5507,
+    5507,
+    5507,
+    3050,
+    3255,
+    3894,
+    4218,
+    4137,
+    1979,
+    1304,
+    1385,
+    2897,
+    601,
+    4299,
+    2031,
+    2754,
+    4869,
+    5030,
+    5030,
+    665,
+    497,
+    1723,
+    2112,
+    762,
+    2271,
+    2213,
+    4523,
+    4853,
+    6372,
+    6534,
+    6534,
+    688,
+    650,
+    1055,
+    1784,
+    3161,
+    2917,
+    2916,
+    1458,
+    1458,
+    1461,
+    2031,
+    1807,
+    1726,
+    1806,
+    1806,
+    873,
+    2657,
+    5081,
+    4852,
+    1941,
+    1888,
+    2181,
+    218,
+    3242,
+    2999,
+    2999,
+    3242,
+    3170,
+    2926,
+    3645,
+    3645,
+    1701,
+    2031,
+    1959,
+    1727,
+    1727,
+    3994,
+    6256,
+    1883,
+    4841,
+    4848,
+    2346,
+    1779,
+    1284,
+    4509,
+    5181,
+    1943,
+    1923,
+    1707,
+    168,
+    4751,
+    2330,
+    62,
+    67,
+    1707,
+    2058,
+    54,
+    2189,
+    3242,
+    2927,
+    2925,
+    1944,
+    4218
+   ]
+  }
+ ]
+}

prompts/voice_waxal_ibo_5.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d537c83dbe167ccf0b43f03304e456fb05e59dfda6b4e359d941900ef629924f
+size 318044

prompts/voice_waxal_yor_5.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ce75b93cf5166d0dc2f53cc943330b4d304f2e060f831d38deb2e664fff49ca5
+size 182924

prompts/voices.json

@@ -0,0 +1,41 @@
+{
+ "note": "zero-shot voices: the clip is the flow + LM prompt; the speaker token is used when the LM saw that speaker",
+ "voices": {
+  "anchor_male": {
+   "wav": null,
+   "lang": "yor",
+   "spk": "waxal_yor_4",
+   "gender": "male",
+   "source": "WAXAL Media Trust TTS, Yoruba speaker 4 (prompts/clip0..3)",
+   "licence": "CC-BY-SA-4.0 (Media Trust TTS subset)",
+   "desc": "male, WAXAL Yoruba speaker 4: the anchor voice both versions were trained around (uses prompts/prompts.json clip 0)"
+  },
+  "waxal_ibo_5_female": {
+   "wav": "prompts/voice_waxal_ibo_5.wav",
+   "tagged": "<ibo>I nwere ike itinye mmemme ọbụla n'izu a ma gị atụla ụjọ maka oké mmiri ozuzo.</ibo>",
+   "text": "I nwere ike itinye mmemme ọbụla n'izu a ma gị atụla ụjọ maka oké mmiri ozuzo.",
+   "lang": "ibo",
+   "spk": "waxal_ibo_5",
+   "gender": "female",
+   "source_clip": "waxal_ibo_test_ibo_502_c003909",
+   "licence": "CC-BY-SA-4.0 (Media Trust TTS subset)",
+   "desc": "female native Igbo speaker (WAXAL ibo speaker 5); prompt clip waxal_ibo_test_ibo_502_c003909 (6.625 s)"
+  },
+  "waxal_yor_5_female": {
+   "wav": "prompts/voice_waxal_yor_5.wav",
+   "tagged": "<yor>Nínú oṣù Ọpẹ́ ni ó ra mọ́tò tí wọ́n jí gbé.</yor>",
+   "text": "Nínú oṣù Ọpẹ́ ni ó ra mọ́tò tí wọ́n jí gbé.",
+   "lang": "yor",
+   "spk": "waxal_yor_5",
+   "gender": "female",
+   "source_clip": "waxal_yor_test_yor_686",
+   "licence": "CC-BY-SA-4.0 (Media Trust TTS subset)",
+   "desc": "female native Yoruba speaker (WAXAL yor speaker 5); prompt clip waxal_yor_test_yor_686 (3.81 s)"
+  }
+ },
+ "aliases": {
+  "anchor": "anchor_male",
+  "waxal_ibo_5": "waxal_ibo_5_female",
+  "waxal_yor_5": "waxal_yor_5_female"
+ }
+}