Duplicate from Scicom-intl/WideCodec

Co-authored-by: huseinzolkepliscicom <huseinzolkepliscicom@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,303 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+samples/common-voice/before/ab.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/af.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/am.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/audio.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/cy.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ab_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/af_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/am_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/audio_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/cy_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ab.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ar.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/as.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ast.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/az.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/bas.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/be.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/bg.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/bn.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/br.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ca.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ckb.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/cnh.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/cs.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/cv.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/da.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/dav.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/de.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/dv.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/dyu.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/el.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/en.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/eo.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/es.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/et.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/eu.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/fa.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/fi.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/fr.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/fy-NL.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ga-IE.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/gl.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/gn.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ha.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/he.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/hi.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/hsb.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/hu.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/hy-AM.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ia.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/id.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ig.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/is.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/it.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ja.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ka.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/kab.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/kk.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/kln.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/kmr.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ko.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ky.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/lg.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/lij.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/lo.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/lt.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ltg.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/luo.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/lv.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/mhr.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/mk.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/mn.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/mr.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/mrj.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/mt.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/myv.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/nb-NO.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/nhi.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/nl.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/nn-NO.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/nr.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/nso.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/oc.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/or.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/os.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/pa-IN.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/pl.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ps.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/pt.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/quy.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/rm-sursilv.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/rm-vallader.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ro.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ru.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/rup.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/rw.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/sah.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/sat.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/sc.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/sd.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/sk.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/skr.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/sl.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/sv-SE.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/sw.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ta.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/te.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/tg.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/th.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ti.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/tk.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/tn.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/tok.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/tr.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/tt.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/tw.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ug.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/uk.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ur.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/uz.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/ve.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/vi.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/vot.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/xh.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/yi.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/yo.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/yue.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/zgh.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/zh-CN.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/zh-TW.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/zu.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/before/zza.flac filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ar_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/as_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ast_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/az_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ba_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/bas_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/be_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/bg_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/bn_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/br_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ca_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ckb_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/cnh_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/cs_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/cv_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/da_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/dav_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/de_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/dv_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/dyu_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/el_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/en_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/eo_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/es_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/et_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/eu_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/fa_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/fi_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/fr_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/fy-NL_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ga-IE_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/gl_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/gn_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ha_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/he_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/hi_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/hsb_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ht_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/hu_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/hy-AM_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ia_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/id_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ig_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/is_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/it_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ja_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ka_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/kab_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/kk_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/kln_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/kmr_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ko_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ky_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/lg_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/lij_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/lo_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/lt_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ltg_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/luo_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/lv_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/mdf_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/mhr_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/mk_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ml_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/mn_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/mr_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/mrj_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/mt_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/myv_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/nan-tw_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/nb-NO_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ne-NP_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/nhi_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/nl_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/nn-NO_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/nr_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/nso_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/oc_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/or_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/os_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/pa-IN_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/pl_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ps_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/pt_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/quy_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/rm-sursilv_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/rm-vallader_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ro_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ru_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/rup_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/rw_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/sah_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/sat_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/sc_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/sd_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/sk_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/skr_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/sl_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/sq_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/sr_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/st_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/sv-SE_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/sw_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ta_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/te_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/tg_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/th_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ti_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/tig_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/tk_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/tn_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/tok_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/tr_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ts_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/tt_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/tw_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ug_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/uk_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ur_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/uz_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/ve_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/vi_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/vot_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/xh_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/yi_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/yo_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/yue_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/zgh_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/zh-CN_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/zh-HK_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/zh-TW_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/zu_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/common-voice/after/zza_recon44k_d20.wav filter=lfs diff=lfs merge=lfs -text
+samples/boboiboy/boboiboy-after.wav filter=lfs diff=lfs merge=lfs -text
+samples/boboiboy/after/boboiboy-after.wav filter=lfs diff=lfs merge=lfs -text
+widecodec_progress.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,506 @@
+---
+license: apache-2.0
+library_name: neucodec
+pipeline_tag: audio-to-audio
+tags:
+- neural-audio-codec
+- neucodec
+- widecodec
+- 44100hz
+- decoder-finetune
+- speech
+---
+
+# WideCodec — 44.1 kHz decoder
+
+**A SOTA 0.8 kbps, 44.1 kHz audio tokenizer.**
+
+**WideCodec** is a **44.1 kHz decoder finetune** of [`neuphonic/neucodec`](https://huggingface.co/neuphonic/neucodec).
+
+- **Sample rate:** 44 100 Hz · **hop:** 882 · **50 tokens/sec**
+
+## Inference (self-contained)
+
+Everything needed to run inference is **in this repo** — the `neucodec/` package and
+`infer_widecodec.py`. No other source code required.
+
+```bash
+pip install torch transformers huggingface_hub local-attention einops librosa soundfile
+huggingface-cli login          # if this repo is private (or export HF_TOKEN=hf_...)
+
+huggingface-cli download Scicom-intl/WideCodec --local-dir WideCodec
+cd WideCodec
+python infer_widecodec.py --input my.wav --out-dir out      # one file
+python infer_widecodec.py --input folder/  --out-dir out    # a directory
+```
+
+Or load it directly in Python:
+
+```python
+import sys; sys.path.insert(0, "WideCodec")   # the downloaded repo dir
+import torch, librosa
+from neucodec import NeuCodec
+
+model = NeuCodec._from_pretrained(model_id="Scicom-intl/WideCodec", decoder_depth=20).eval().cuda()
+wav16, _ = librosa.load("my.wav", sr=16000, mono=True)   # encoder ingests 16 kHz mono
+x = torch.from_numpy(wav16).float().view(1, 1, -1).cuda()
+with torch.no_grad():
+    codes  = model.encode_code(x)      # frozen FSQ codes — 0.8 kbps, 50 tok/s
+    wav44  = model.decode_code(codes)  # 44.1 kHz reconstruction
+```
+
+## Files
+
+| file | what |
+|---|---|
+| `pytorch_model.bin` | decoder weights for **inference** (load with `NeuCodec._from_pretrained(..., decoder_depth=20)`) |
+| `last.ckpt` | full PyTorch-Lightning checkpoint **with optimizer states + LR schedulers** for **resuming training** |
+
+## How WideCodec compares (44 kHz-class, by bitrate)
+
+Offline benchmark on a **heavily multilingual 9,291-clip wideband set** (50 clips × 188 clean ≥44.1 kHz datasets, **400+ language/dialect tags**),
+faster-UTMOSv2 + spectral vs ground truth.
+
+![bitrate vs UTMOSv2](bitrate_vs_utmosv2.png)
+
+![WideCodec release progression](widecodec_progress.png)
+
+| codec | native SR | tokens/s | codebooks | ~bitrate | UTMOSv2 | mel-L1 ↓ | HF≥11k | rolloff |
+|---|--:|--:|--:|--:|--:|--:|--:|--:|
+| ground truth | — | — | — | — | 2.822 | — | 0.00244 | 8263 |
+| nvidia nemo44k | 44.1k | ~86 | RVQ (many) | ~6–9 kbps | **2.903** | 0.379 | 0.00196 | 8372 |
+| **WideCodec (ours, 2026-08-16)** | 44.1k | **50** | **1** | **~0.8 kbps** | **2.919** | 0.571 | 0.00223 | 9011 |
+| WideCodec (previous, 2026-07-21) | 44.1k | 50 | 1 | ~0.8 kbps | 2.788 | 0.571 | 0.00223 | 9011 |
+| dac | 44.1k | 86 | 9 | ~8 kbps | 2.672 | **0.341** | 0.00156 | 8185 |
+| snac44k | 44.1k | multi-scale | 3–4 | ~2.6 kbps | 2.340 | 0.493 | 0.00158 | 8402 |
+| encodec48k | 48k | 150 | RVQ | 24 kbps | 2.042 | 0.458 | 0.00169 | 8800 |
+
+**Bitrate = frame-rate × Σ log₂(codebook size).** WideCodec's FSQ is `levels=[4]×8,
+num_quantizers=1` → 8·log₂4 = **16 bits/frame** × 50 frames/s = **800 bps = 0.8 kbps**
+(vs DAC's 9 codebooks × 10 bits × 86 fps ≈ 8 kbps).
+
+The **2026-08-16 release** reaches UTMOSv2 **2.919** on the 9,291-clip set — **above ground truth (2.822)
+and level with NVIDIA NeMo-44k (2.903), at ~1/10 of NeMo's bitrate**. It gained **+0.131 UTMOSv2** over the
+previous release **at unchanged content accuracy**: CV22 macro CER is **7.70%** for both (micro 7.09%), well
+inside the measured run-to-run spread of ±0.25 pt.
+
+Same architecture, same losses, same 50 tokens/s and single codebook — **only the training corpus changed**,
+to clean DNSMOS-gated ≥44.1 kHz audio. The gain is not an artifact of the benchmark pool: on a **held-out set
+of 1,330 clips from 138 sources absent from training**, it scores 2.807 vs the previous release's 2.654
+(+0.153, paired t=+14.2), and reference-based **PESQ-WB also improves** (+0.017, t=+7.5) — so naturalness and
+fidelity moved together rather than trading off. Full report: evaluation/REPORT_44k_class_codecs.md.
+
+## Training stages / which revision to pull
+
+This model is trained in two stages. `main` always points at the **latest** stage.
+
+| stage | data | how to load |
+|---|---|---|
+| **Stage 1 — noisy mix** (steps 0→1.58M, `epoch=9-step=1580000`) | 8 base corpora + `scale44k` (~6,500 h, mostly noisy crowdsourced/podcast) | pin revision **`d2c612f4319c1c1e0c65a9431a7d6db1b7955ce0`** |
+| **Stage 2 — clean finetune** (from 1.58M, clean ≥44.1 kHz only; in progress) | TTS-Clean44k + Clean-Podcast + clean-teacher pool + EARS/Expresso | `main` (default) |
+
+```python
+# the `neucodec/` package is bundled in this repo (see 'Inference (self-contained)')
+from neucodec import NeuCodec
+
+# Stage 1 (first-stage noisy training) — pin the exact revision:
+model = NeuCodec._from_pretrained(
+    model_id="Scicom-intl/WideCodec",
+    decoder_depth=20,
+    revision="d2c612f4319c1c1e0c65a9431a7d6db1b7955ce0",
+)
+```
+
+## Training data
+
+Diverse, predominantly high-sample-rate human speech (no synthetic TTS). The **scale-up group is
+SR-verified ≥ 44 kHz** (probed before inclusion); the base corpora are long-form conversational,
+expressive and anechoic speech. Two groups:
+
+### Base corpora (Malaysia-AI + expressive/anechoic speech)
+
+| dataset | content |
+|---|---|
+| [`malaysia-ai/malaysian-podcast-youtube`](https://huggingface.co/datasets/malaysia-ai/malaysian-podcast-youtube) | Malay long-form conversational podcasts (~2,234 h) |
+| [`malaysia-ai/singaporean-podcast-youtube`](https://huggingface.co/datasets/malaysia-ai/singaporean-podcast-youtube) | Singaporean English podcasts (~1,255 h) |
+| [`malaysia-ai/Multilingual-TTS`](https://huggingface.co/datasets/malaysia-ai/Multilingual-TTS) | CommonVoice-sidon multilingual short clips |
+| [`malaysia-ai/malaysian-cartoons-youtube`](https://huggingface.co/datasets/malaysia-ai/malaysian-cartoons-youtube) | 48 kHz cartoon dialogue (subset) |
+| [`malaysia-ai/malaysian-movie-youtube`](https://huggingface.co/datasets/malaysia-ai/malaysian-movie-youtube) | 48 kHz Malay movie dialogue |
+| [`ylacombe/expresso`](https://huggingface.co/datasets/ylacombe/expresso) | 48 kHz expressive read speech |
+| [`nytopop/expresso-conversational`](https://huggingface.co/datasets/nytopop/expresso-conversational) | 48 kHz improvised dialogue |
+| EARS | 48 kHz anechoic fullband (emotional / conversational / reading) |
+
+### Scale-up: 336 verified ≥ 44 kHz datasets
+
+To maximise acoustic diversity for the decoder (language-agnostic — the codebook is frozen),
+training is scaled with **336 additional datasets** (162 at 48 kHz, 174 at 44.1 kHz), mirrored as
+`<name>*audio.zip` in [`malaysia-ai/Multilingual-TTS`](https://huggingface.co/datasets/malaysia-ai/Multilingual-TTS)
+and SR-verified ≥ 44 kHz. Original sources:
+
+<details>
+<summary>Full list of 336 ≥ 44 kHz source datasets</summary>
+
+- [`1rsh/gujarati-f-openslr`](https://huggingface.co/datasets/1rsh/gujarati-f-openslr) — 48000 Hz
+- [`Aashish17405/audio-dataset`](https://huggingface.co/datasets/Aashish17405/audio-dataset) — 48000 Hz
+- [`Aashish17405/audio-dataset-300`](https://huggingface.co/datasets/Aashish17405/audio-dataset-300) — 48000 Hz
+- [`Aashish17405/audio-dataset-shuffled-300`](https://huggingface.co/datasets/Aashish17405/audio-dataset-shuffled-300) — 48000 Hz
+- [`Abdullah500/IndicTTS-Bengali`](https://huggingface.co/datasets/Abdullah500/IndicTTS-Bengali) — 48000 Hz
+- [`Abdullah500/IndicTTS_BengaliOLD`](https://huggingface.co/datasets/Abdullah500/IndicTTS_BengaliOLD) — 48000 Hz
+- [`adalat-ai/in22-legal`](https://huggingface.co/datasets/adalat-ai/in22-legal) — 48000 Hz
+- [`ahmadafaneh/common-voice-18-arabic`](https://huggingface.co/datasets/ahmadafaneh/common-voice-18-arabic) — 48000 Hz
+- [`AIDC-AI/CSEMOTIONS`](https://huggingface.co/datasets/AIDC-AI/CSEMOTIONS) — 48000 Hz
+- [`AJosh/audio-dataset`](https://huggingface.co/datasets/AJosh/audio-dataset) — 48000 Hz
+- [`alexantonov/chuvash_voice`](https://huggingface.co/datasets/alexantonov/chuvash_voice) — 48000 Hz
+- [`aliyzd95/common_voice_21_0_fa`](https://huggingface.co/datasets/aliyzd95/common_voice_21_0_fa) — 48000 Hz
+- [`aliyzd95/common_voice_22_0_fa`](https://huggingface.co/datasets/aliyzd95/common_voice_22_0_fa) — 48000 Hz
+- [`anian0707/hindi-tts-dataset`](https://huggingface.co/datasets/anian0707/hindi-tts-dataset) — 48000 Hz
+- [`atlithor/talromur3_with_prompts`](https://huggingface.co/datasets/atlithor/talromur3_with_prompts) — 48000 Hz
+- [`atlithor/talromur3_without_emotions`](https://huggingface.co/datasets/atlithor/talromur3_without_emotions) — 48000 Hz
+- [`bilguun/cv-mn-24.0`](https://huggingface.co/datasets/bilguun/cv-mn-24.0) — 48000 Hz
+- [`bookbot/slr72_dataset`](https://huggingface.co/datasets/bookbot/slr72_dataset) — 48000 Hz
+- [`Chingkheinganba/IndicTTS_Manipuri`](https://huggingface.co/datasets/Chingkheinganba/IndicTTS_Manipuri) — 48000 Hz
+- [`chuuhtetnaing/myanmar-speech-dataset-openslr-80`](https://huggingface.co/datasets/chuuhtetnaing/myanmar-speech-dataset-openslr-80) — 48000 Hz
+- [`Cnam-LMSSC/vibravox_enhanced_by_EBEN`](https://huggingface.co/datasets/Cnam-LMSSC/vibravox_enhanced_by_EBEN) — 48000 Hz
+- [`CraneAILabs/waxal-lug-clean`](https://huggingface.co/datasets/CraneAILabs/waxal-lug-clean) — 48000 Hz
+- [`datahiveai/arabic-multidialect-emotional-speech-demo`](https://huggingface.co/datasets/datahiveai/arabic-multidialect-emotional-speech-demo) — 48000 Hz
+- [`DatarrX/burmese-synthetic-speech-corpus`](https://huggingface.co/datasets/DatarrX/burmese-synthetic-speech-corpus) — 48000 Hz
+- [`DDD-Cambodia/khm-asr-cultural`](https://huggingface.co/datasets/DDD-Cambodia/khm-asr-cultural) — 48000 Hz
+- [`deepdml/igbo-dict`](https://huggingface.co/datasets/deepdml/igbo-dict) — 48000 Hz
+- [`deepdml/igbo-dict-16khz`](https://huggingface.co/datasets/deepdml/igbo-dict-16khz) — 48000 Hz
+- [`deepdml/igbo-dict-expansion`](https://huggingface.co/datasets/deepdml/igbo-dict-expansion) — 48000 Hz
+- [`deepdml/igbo-dict-expansion-16khz`](https://huggingface.co/datasets/deepdml/igbo-dict-expansion-16khz) — 48000 Hz
+- [`deepdml/openslr-32-hq-SA-languages`](https://huggingface.co/datasets/deepdml/openslr-32-hq-SA-languages) — 48000 Hz
+- [`deepdml/openslr42-khmer-tts`](https://huggingface.co/datasets/deepdml/openslr42-khmer-tts) — 48000 Hz
+- [`deepdml/openslr65-tamil`](https://huggingface.co/datasets/deepdml/openslr65-tamil) — 48000 Hz
+- [`deepdml/openslr80-burmese`](https://huggingface.co/datasets/deepdml/openslr80-burmese) — 48000 Hz
+- [`doof-ferb/fpt_fosd`](https://huggingface.co/datasets/doof-ferb/fpt_fosd) — 48000 Hz
+- [`doof-ferb/infore1_25hours`](https://huggingface.co/datasets/doof-ferb/infore1_25hours) — 48000 Hz
+- [`espnet/ace-kising-segments`](https://huggingface.co/datasets/espnet/ace-kising-segments) — 48000 Hz
+- [`espnet/ace-opencpop-segments`](https://huggingface.co/datasets/espnet/ace-opencpop-segments) — 48000 Hz
+- [`FatimahEmadEldin/alsanaa-emirati-arabic-asr`](https://huggingface.co/datasets/FatimahEmadEldin/alsanaa-emirati-arabic-asr) — 48000 Hz
+- [`fluffypotatoes/f1-team-radio`](https://huggingface.co/datasets/fluffypotatoes/f1-team-radio) — 48000 Hz
+- [`fosters/lagodny-tsmok-iury-zhygamont-output_original`](https://huggingface.co/datasets/fosters/lagodny-tsmok-iury-zhygamont-output_original) — 48000 Hz
+- [`fosters/lagodny-tsmok-iury-zhygamont_all`](https://huggingface.co/datasets/fosters/lagodny-tsmok-iury-zhygamont_all) — 48000 Hz
+- [`gauravparajuli/slr43`](https://huggingface.co/datasets/gauravparajuli/slr43) — 48000 Hz
+- [`ggfox00000/stt-summre-fr-test`](https://huggingface.co/datasets/ggfox00000/stt-summre-fr-test) — 48000 Hz
+- [`ggfox00000/stt-vibravox-fr-test`](https://huggingface.co/datasets/ggfox00000/stt-vibravox-fr-test) — 48000 Hz
+- [`hanamizuki-ai/genshin-voice-v3.3-mandarin`](https://huggingface.co/datasets/hanamizuki-ai/genshin-voice-v3.3-mandarin) — 48000 Hz
+- [`hanamizuki-ai/genshin-voice-v3.4-mandarin`](https://huggingface.co/datasets/hanamizuki-ai/genshin-voice-v3.4-mandarin) — 48000 Hz
+- [`hanamizuki-ai/genshin-voice-v3.5-mandarin`](https://huggingface.co/datasets/hanamizuki-ai/genshin-voice-v3.5-mandarin) — 48000 Hz
+- [`HeshamHaroon/arabic-msa-25k-saudi-male-tashkeel`](https://huggingface.co/datasets/HeshamHaroon/arabic-msa-25k-saudi-male-tashkeel) — 48000 Hz
+- [`HeshamHaroon/Dahee7`](https://huggingface.co/datasets/HeshamHaroon/Dahee7) — 48000 Hz
+- [`hezarai/common-voice-13-fa`](https://huggingface.co/datasets/hezarai/common-voice-13-fa) — 48000 Hz
+- [`hosein-m/french_homophone_asr`](https://huggingface.co/datasets/hosein-m/french_homophone_asr) — 48000 Hz
+- [`humyn-labs/Asian-High-Fidelity-ASR-Dataset`](https://huggingface.co/datasets/humyn-labs/Asian-High-Fidelity-ASR-Dataset) — 48000 Hz
+- [`humyn-labs/LATAM-High-Fidelity-ASR`](https://huggingface.co/datasets/humyn-labs/LATAM-High-Fidelity-ASR) — 48000 Hz
+- [`hypaai/Hypa-Speech-10k`](https://huggingface.co/datasets/hypaai/Hypa-Speech-10k) — 48000 Hz
+- [`hypaai/Hypa_Fleurs`](https://huggingface.co/datasets/hypaai/Hypa_Fleurs) — 48000 Hz
+- [`igidn/wuwa-voice-EN`](https://huggingface.co/datasets/igidn/wuwa-voice-EN) — 48000 Hz
+- [`impriyanshu-garg00/IndicVoices-R_Hindi`](https://huggingface.co/datasets/impriyanshu-garg00/IndicVoices-R_Hindi) — 48000 Hz
+- [`JacobLinCool/jl-speech`](https://huggingface.co/datasets/JacobLinCool/jl-speech) — 48000 Hz
+- [`JeanKouss/ewe_bible_v2_tts`](https://huggingface.co/datasets/JeanKouss/ewe_bible_v2_tts) — 48000 Hz
+- [`jspaulsen/vctk`](https://huggingface.co/datasets/jspaulsen/vctk) — 48000 Hz
+- [`juanjucm/OpenHQ-SpeechT-GL-EN`](https://huggingface.co/datasets/juanjucm/OpenHQ-SpeechT-GL-EN) — 48000 Hz
+- [`jzsues/genshin-voice-zh`](https://huggingface.co/datasets/jzsues/genshin-voice-zh) — 48000 Hz
+- [`Kishor798/text_to_speech_dataset`](https://huggingface.co/datasets/Kishor798/text_to_speech_dataset) — 48000 Hz
+- [`Kppwdfgu1/Hypa-Speech-10k`](https://huggingface.co/datasets/Kppwdfgu1/Hypa-Speech-10k) — 48000 Hz
+- [`KrorngAI/fleurs_openslr42_mpwt`](https://huggingface.co/datasets/KrorngAI/fleurs_openslr42_mpwt) — 48000 Hz
+- [`Kukedlc/openslr61-es-ar-full`](https://huggingface.co/datasets/Kukedlc/openslr61-es-ar-full) — 48000 Hz
+- [`leduckhai/MultiMed`](https://huggingface.co/datasets/leduckhai/MultiMed) — 48000 Hz
+- [`leduckhai/MultiMed-ST`](https://huggingface.co/datasets/leduckhai/MultiMed-ST) — 48000 Hz
+- [`LeVy4/speech-to-text`](https://huggingface.co/datasets/LeVy4/speech-to-text) — 48000 Hz
+- [`lilgoose777/nepali_speech_english_translation_shuffle_dataset`](https://huggingface.co/datasets/lilgoose777/nepali_speech_english_translation_shuffle_dataset) — 48000 Hz
+- [`Lindarychwalski/pony-speech`](https://huggingface.co/datasets/Lindarychwalski/pony-speech) — 48000 Hz
+- [`longhim99/khm-asr-cultural`](https://huggingface.co/datasets/longhim99/khm-asr-cultural) — 48000 Hz
+- [`lyhourt-FSA/khm-asr-cultural`](https://huggingface.co/datasets/lyhourt-FSA/khm-asr-cultural) — 48000 Hz
+- [`maikezu/dowis`](https://huggingface.co/datasets/maikezu/dowis) — 48000 Hz
+- [`manassehzw/sna-manasseh-150-raw`](https://huggingface.co/datasets/manassehzw/sna-manasseh-150-raw) — 48000 Hz
+- [`masuidrive/cv-corpus-17.0-zh-TW-client_id-grouped`](https://huggingface.co/datasets/masuidrive/cv-corpus-17.0-zh-TW-client_id-grouped) — 48000 Hz
+- [`MatrixStudio/TTS-CCabNavMSC`](https://huggingface.co/datasets/MatrixStudio/TTS-CCabNavMSC) — 48000 Hz
+- [`MatrixStudio/TTS-CFCabNavSC`](https://huggingface.co/datasets/MatrixStudio/TTS-CFCabNavSC) — 48000 Hz
+- [`MatrixStudio/TTS-SCCusSerFSC`](https://huggingface.co/datasets/MatrixStudio/TTS-SCCusSerFSC) — 48000 Hz
+- [`MatrixStudio/TTS-SCDuFSC`](https://huggingface.co/datasets/MatrixStudio/TTS-SCDuFSC) — 48000 Hz
+- [`Max5ive/openslr-32-hq-SA-languages-Sesotho`](https://huggingface.co/datasets/Max5ive/openslr-32-hq-SA-languages-Sesotho) — 48000 Hz
+- [`mazesmazes/jenny-mimi`](https://huggingface.co/datasets/mazesmazes/jenny-mimi) — 48000 Hz
+- [`MikCil/f1-team-radio`](https://huggingface.co/datasets/MikCil/f1-team-radio) — 48000 Hz
+- [`mohamedmou/DATASET-darija-ASR-clean`](https://huggingface.co/datasets/mohamedmou/DATASET-darija-ASR-clean) — 48000 Hz
+- [`MohamedRashad/arabic-english-code-switching`](https://huggingface.co/datasets/MohamedRashad/arabic-english-code-switching) — 48000 Hz
+- [`MohamedRashad/common-voice-18-arabic`](https://huggingface.co/datasets/MohamedRashad/common-voice-18-arabic) — 48000 Hz
+- [`ngia/ASR_pulaar`](https://huggingface.co/datasets/ngia/ASR_pulaar) — 48000 Hz
+- [`ntaquan0125/steinsgate-voice`](https://huggingface.co/datasets/ntaquan0125/steinsgate-voice) — 48000 Hz
+- [`ntt123/VietBibleVox-aligned`](https://huggingface.co/datasets/ntt123/VietBibleVox-aligned) — 48000 Hz
+- [`OmarAhmedSobhy/egyption-with-emotion-dataset`](https://huggingface.co/datasets/OmarAhmedSobhy/egyption-with-emotion-dataset) — 48000 Hz
+- [`OmarAhmedSobhy/tts-egyption-dataset`](https://huggingface.co/datasets/OmarAhmedSobhy/tts-egyption-dataset) — 48000 Hz
+- [`omersaidd/tts_ahmet_deniz_tur`](https://huggingface.co/datasets/omersaidd/tts_ahmet_deniz_tur) — 48000 Hz
+- [`rahafvii/EGY2K`](https://huggingface.co/datasets/rahafvii/EGY2K) — 48000 Hz
+- [`ranbirchabungbam/meiteimayek-audio-parallel-corpus`](https://huggingface.co/datasets/ranbirchabungbam/meiteimayek-audio-parallel-corpus) — 48000 Hz
+- [`reapzor/neurologySTT`](https://huggingface.co/datasets/reapzor/neurologySTT) — 48000 Hz
+- [`RikkaBotan/nyan-jenny-format`](https://huggingface.co/datasets/RikkaBotan/nyan-jenny-format) — 48000 Hz
+- [`RobotsMali/transcription-scorer`](https://huggingface.co/datasets/RobotsMali/transcription-scorer) — 48000 Hz
+- [`SachinTelecmi/tts-hindi-stts2`](https://huggingface.co/datasets/SachinTelecmi/tts-hindi-stts2) — 48000 Hz
+- [`sartifyllc/Sukuma-Voices`](https://huggingface.co/datasets/sartifyllc/Sukuma-Voices) — 48000 Hz
+- [`scriptaudio/f1-team-radio`](https://huggingface.co/datasets/scriptaudio/f1-team-radio) — 48000 Hz
+- [`sdcsdccdsd/CSEMOTIONS`](https://huggingface.co/datasets/sdcsdccdsd/CSEMOTIONS) — 48000 Hz
+- [`shoron08/irodori-refs-10k`](https://huggingface.co/datasets/shoron08/irodori-refs-10k) — 48000 Hz
+- [`shreeshacharya/Dhravani`](https://huggingface.co/datasets/shreeshacharya/Dhravani) — 48000 Hz
+- [`siddiqiya/ar-eg-dataset`](https://huggingface.co/datasets/siddiqiya/ar-eg-dataset) — 48000 Hz
+- [`slprl/StressTest`](https://huggingface.co/datasets/slprl/StressTest) — 48000 Hz
+- [`smcproject/MSC`](https://huggingface.co/datasets/smcproject/MSC) — 48000 Hz
+- [`somu9/iisc_mono_hindi_female`](https://huggingface.co/datasets/somu9/iisc_mono_hindi_female) — 48000 Hz
+- [`somu9/iitm_mono_hindi_female`](https://huggingface.co/datasets/somu9/iitm_mono_hindi_female) — 48000 Hz
+- [`speech-uk/opentts-kateryna`](https://huggingface.co/datasets/speech-uk/opentts-kateryna) — 48000 Hz
+- [`speech-uk/opentts-oleksa`](https://huggingface.co/datasets/speech-uk/opentts-oleksa) — 48000 Hz
+- [`speech-uk/opentts-tetiana`](https://huggingface.co/datasets/speech-uk/opentts-tetiana) — 48000 Hz
+- [`speech-uk/tts-crh-abibullah`](https://huggingface.co/datasets/speech-uk/tts-crh-abibullah) — 48000 Hz
+- [`speech-uk/tts-crh-arslan`](https://huggingface.co/datasets/speech-uk/tts-crh-arslan) — 48000 Hz
+- [`speech-uk/tts-crh-sevil`](https://huggingface.co/datasets/speech-uk/tts-crh-sevil) — 48000 Hz
+- [`SPRINGLab/IndicTTS-Hindi`](https://huggingface.co/datasets/SPRINGLab/IndicTTS-Hindi) — 48000 Hz
+- [`SPRINGLab/IndicTTS_Assamese`](https://huggingface.co/datasets/SPRINGLab/IndicTTS_Assamese) — 48000 Hz
+- [`SPRINGLab/IndicTTS_Bengali`](https://huggingface.co/datasets/SPRINGLab/IndicTTS_Bengali) — 48000 Hz
+- [`SPRINGLab/IndicTTS_Kannada`](https://huggingface.co/datasets/SPRINGLab/IndicTTS_Kannada) — 48000 Hz
+- [`SPRINGLab/IndicTTS_Malayalam`](https://huggingface.co/datasets/SPRINGLab/IndicTTS_Malayalam) — 48000 Hz
+- [`SPRINGLab/IndicTTS_Manipuri`](https://huggingface.co/datasets/SPRINGLab/IndicTTS_Manipuri) — 48000 Hz
+- [`SPRINGLab/IndicTTS_Marathi`](https://huggingface.co/datasets/SPRINGLab/IndicTTS_Marathi) — 48000 Hz
+- [`SPRINGLab/IndicTTS_Odia`](https://huggingface.co/datasets/SPRINGLab/IndicTTS_Odia) — 48000 Hz
+- [`SPRINGLab/IndicTTS_Punjabi`](https://huggingface.co/datasets/SPRINGLab/IndicTTS_Punjabi) — 48000 Hz
+- [`SPRINGLab/IndicTTS_Rajasthani`](https://huggingface.co/datasets/SPRINGLab/IndicTTS_Rajasthani) — 48000 Hz
+- [`SPRINGLab/IndicTTS_Tamil`](https://huggingface.co/datasets/SPRINGLab/IndicTTS_Tamil) — 48000 Hz
+- [`SPRINGLab/IndicVoices-R_Hindi`](https://huggingface.co/datasets/SPRINGLab/IndicVoices-R_Hindi) — 48000 Hz
+- [`srezas/farsi_voice_dataset`](https://huggingface.co/datasets/srezas/farsi_voice_dataset) — 48000 Hz
+- [`SynDataLab-JA-Refs/Irodori-Ja-Spk1-10k`](https://huggingface.co/datasets/SynDataLab-JA-Refs/Irodori-Ja-Spk1-10k) — 48000 Hz
+- [`SynDataLab-JA-Refs/Irodori-Ja-Spk2-10k`](https://huggingface.co/datasets/SynDataLab-JA-Refs/Irodori-Ja-Spk2-10k) — 48000 Hz
+- [`SynDataLab-JA-Refs/Irodori-Ja-Spk3-10k`](https://huggingface.co/datasets/SynDataLab-JA-Refs/Irodori-Ja-Spk3-10k) — 48000 Hz
+- [`SynDataLab-JA-Refs/Irodori-Ja-Spk4-10k`](https://huggingface.co/datasets/SynDataLab-JA-Refs/Irodori-Ja-Spk4-10k) — 48000 Hz
+- [`SynDataLab-JA-Refs/irodori-refs-10k`](https://huggingface.co/datasets/SynDataLab-JA-Refs/irodori-refs-10k) — 48000 Hz
+- [`SynDataLab-JA-Refs/irodori-refs-10k-v2`](https://huggingface.co/datasets/SynDataLab-JA-Refs/irodori-refs-10k-v2) — 48000 Hz
+- [`SynDataLab-JA-Refs/irodori-tts-refs-12k`](https://huggingface.co/datasets/SynDataLab-JA-Refs/irodori-tts-refs-12k) — 48000 Hz
+- [`SynDataLab-JA/Irodori-Ja-500M-v2-vs-600M-v3-compare-20`](https://huggingface.co/datasets/SynDataLab-JA/Irodori-Ja-500M-v2-vs-600M-v3-compare-20) — 48000 Hz
+- [`synthbot/pony-singing`](https://huggingface.co/datasets/synthbot/pony-singing) — 48000 Hz
+- [`synthbot/pony-speech`](https://huggingface.co/datasets/synthbot/pony-speech) — 48000 Hz
+- [`Tamazight-NLP/TOSD`](https://huggingface.co/datasets/Tamazight-NLP/TOSD) — 48000 Hz
+- [`thennal/GMaSC`](https://huggingface.co/datasets/thennal/GMaSC) — 48000 Hz
+- [`thennal/indic_tts_ml`](https://huggingface.co/datasets/thennal/indic_tts_ml) — 48000 Hz
+- [`thennal/msc`](https://huggingface.co/datasets/thennal/msc) — 48000 Hz
+- [`Trelis/multimed-hard`](https://huggingface.co/datasets/Trelis/multimed-hard) — 48000 Hz
+- [`trysem/indicvoices_r-ML`](https://huggingface.co/datasets/trysem/indicvoices_r-ML) — 48000 Hz
+- [`ttthe/MultiMed`](https://huggingface.co/datasets/ttthe/MultiMed) — 48000 Hz
+- [`tunis-ai/arabic_speech_corpus`](https://huggingface.co/datasets/tunis-ai/arabic_speech_corpus) — 48000 Hz
+- [`vinaybabu/voice_tech_for_all_challenge_samples_output`](https://huggingface.co/datasets/vinaybabu/voice_tech_for_all_challenge_samples_output) — 48000 Hz
+- [`voice-biomarkers/openslr-32-hq-SA-languages-Afrikaans`](https://huggingface.co/datasets/voice-biomarkers/openslr-32-hq-SA-languages-Afrikaans) — 48000 Hz
+- [`voice-biomarkers/openslr-32-hq-SA-languages-isiXhosa`](https://huggingface.co/datasets/voice-biomarkers/openslr-32-hq-SA-languages-isiXhosa) — 48000 Hz
+- [`voice-biomarkers/openslr-32-hq-SA-languages-Sesotho`](https://huggingface.co/datasets/voice-biomarkers/openslr-32-hq-SA-languages-Sesotho) — 48000 Hz
+- [`voice-biomarkers/openslr-32-hq-SA-languages-Setswana`](https://huggingface.co/datasets/voice-biomarkers/openslr-32-hq-SA-languages-Setswana) — 48000 Hz
+- [`vrclc/openslr63`](https://huggingface.co/datasets/vrclc/openslr63) — 48000 Hz
+- [`wanasash/enwaucymraeg`](https://huggingface.co/datasets/wanasash/enwaucymraeg) — 48000 Hz
+- [`worldboss/ewe_bible_v2_tts`](https://huggingface.co/datasets/worldboss/ewe_bible_v2_tts) — 48000 Hz
+- [`worldboss/twi_bible_v2_tts`](https://huggingface.co/datasets/worldboss/twi_bible_v2_tts) — 48000 Hz
+- [`yasalma/tat_hackathon_asr`](https://huggingface.co/datasets/yasalma/tat_hackathon_asr) — 48000 Hz
+- [`Yehor/qirimtatar-tts`](https://huggingface.co/datasets/Yehor/qirimtatar-tts) — 48000 Hz
+- [`ylacombe/english_dialects`](https://huggingface.co/datasets/ylacombe/english_dialects) — 48000 Hz
+- [`ylacombe/google-chilean-spanish`](https://huggingface.co/datasets/ylacombe/google-chilean-spanish) — 48000 Hz
+- [`ylacombe/google-tamil`](https://huggingface.co/datasets/ylacombe/google-tamil) — 48000 Hz
+- [`ymoslem/CoVoST2-EN-AR`](https://huggingface.co/datasets/ymoslem/CoVoST2-EN-AR) — 48000 Hz
+- [`ymoslem/Living-Audio-Irish`](https://huggingface.co/datasets/ymoslem/Living-Audio-Irish) — 48000 Hz
+- [`zinc75/Vibravox_dummy`](https://huggingface.co/datasets/zinc75/Vibravox_dummy) — 48000 Hz
+- [`8Opt/clotho-dev-sample`](https://huggingface.co/datasets/8Opt/clotho-dev-sample) — 44100 Hz
+- [`aangelakis/STOMA`](https://huggingface.co/datasets/aangelakis/STOMA) — 44100 Hz
+- [`adiren7/darija_speech_to_text`](https://huggingface.co/datasets/adiren7/darija_speech_to_text) — 44100 Hz
+- [`ahmed220v/SCC22`](https://huggingface.co/datasets/ahmed220v/SCC22) — 44100 Hz
+- [`AigizK/bashkort_tts_dataset`](https://huggingface.co/datasets/AigizK/bashkort_tts_dataset) — 44100 Hz
+- [`aipanjab/speech-mendeley-pa`](https://huggingface.co/datasets/aipanjab/speech-mendeley-pa) — 44100 Hz
+- [`ALEKAS/ToneBooksPlus-Grigorii`](https://huggingface.co/datasets/ALEKAS/ToneBooksPlus-Grigorii) — 44100 Hz
+- [`alimetin/turkish-parliament-speech`](https://huggingface.co/datasets/alimetin/turkish-parliament-speech) — 44100 Hz
+- [`amine-khelif/DuBLaB-en-fr-0.7`](https://huggingface.co/datasets/amine-khelif/DuBLaB-en-fr-0.7) — 44100 Hz
+- [`amine-khelif/DuBLaB-en-fr-0.7-f-0.2`](https://huggingface.co/datasets/amine-khelif/DuBLaB-en-fr-0.7-f-0.2) — 44100 Hz
+- [`amine-khelif/DuBLaB-en-fr-0.7-f-0.5`](https://huggingface.co/datasets/amine-khelif/DuBLaB-en-fr-0.7-f-0.5) — 44100 Hz
+- [`amine-khelif/DuBLaB-en-fr-0.8`](https://huggingface.co/datasets/amine-khelif/DuBLaB-en-fr-0.8) — 44100 Hz
+- [`Anilosan15/YouTube_Video_Transkriptleri_TR`](https://huggingface.co/datasets/Anilosan15/YouTube_Video_Transkriptleri_TR) — 44100 Hz
+- [`AnonXx/Pidgin_ASR_Dataset_Combined`](https://huggingface.co/datasets/AnonXx/Pidgin_ASR_Dataset_Combined) — 44100 Hz
+- [`anzorq/kbd_speech`](https://huggingface.co/datasets/anzorq/kbd_speech) — 44100 Hz
+- [`archivartaunik/Jevanhielle_Zyhamont_outChecked`](https://huggingface.co/datasets/archivartaunik/Jevanhielle_Zyhamont_outChecked) — 44100 Hz
+- [`archivartaunik/output4Checked`](https://huggingface.co/datasets/archivartaunik/output4Checked) — 44100 Hz
+- [`Bateesa/rw-tts-dataset`](https://huggingface.co/datasets/Bateesa/rw-tts-dataset) — 44100 Hz
+- [`beratcmn/jessica-076`](https://huggingface.co/datasets/beratcmn/jessica-076) — 44100 Hz
+- [`bezzam/coraal`](https://huggingface.co/datasets/bezzam/coraal) — 44100 Hz
+- [`Bretagne/Lingua_Libre_br`](https://huggingface.co/datasets/Bretagne/Lingua_Libre_br) — 44100 Hz
+- [`BrunoHays/Bangor-Miami-Spanish-English-Corpus`](https://huggingface.co/datasets/BrunoHays/Bangor-Miami-Spanish-English-Corpus) — 44100 Hz
+- [`cagataydev/vlm-voice-audio`](https://huggingface.co/datasets/cagataydev/vlm-voice-audio) — 44100 Hz
+- [`CentificAIResearch/DialectalSpeech-ICL`](https://huggingface.co/datasets/CentificAIResearch/DialectalSpeech-ICL) — 44100 Hz
+- [`changelinglab/speechaccentarchive-pr`](https://huggingface.co/datasets/changelinglab/speechaccentarchive-pr) — 44100 Hz
+- [`chris-t-jansen/erasmian_greek_nt`](https://huggingface.co/datasets/chris-t-jansen/erasmian_greek_nt) — 44100 Hz
+- [`Codyfederer/fttrtest`](https://huggingface.co/datasets/Codyfederer/fttrtest) — 44100 Hz
+- [`Codyfederer/test3434234`](https://huggingface.co/datasets/Codyfederer/test3434234) — 44100 Hz
+- [`Codyfederer/tretret34543`](https://huggingface.co/datasets/Codyfederer/tretret34543) — 44100 Hz
+- [`CoRal-project/coral-tts`](https://huggingface.co/datasets/CoRal-project/coral-tts) — 44100 Hz
+- [`corti/med-term`](https://huggingface.co/datasets/corti/med-term) — 44100 Hz
+- [`ctaguchi/killkan`](https://huggingface.co/datasets/ctaguchi/killkan) — 44100 Hz
+- [`czyzi0/pwr-azon-speech-dataset`](https://huggingface.co/datasets/czyzi0/pwr-azon-speech-dataset) — 44100 Hz
+- [`czyzi0/the-mc-speech-dataset`](https://huggingface.co/datasets/czyzi0/the-mc-speech-dataset) — 44100 Hz
+- [`D00Movenok/russian-glados-portal2`](https://huggingface.co/datasets/D00Movenok/russian-glados-portal2) — 44100 Hz
+- [`daanbrugmans/ovb-huissen-1`](https://huggingface.co/datasets/daanbrugmans/ovb-huissen-1) — 44100 Hz
+- [`data-lab-voice/echo-tts-en-benchmarks-v1`](https://huggingface.co/datasets/data-lab-voice/echo-tts-en-benchmarks-v1) — 44100 Hz
+- [`DataStudio/Vietnamese_ASR_TestingData_Old`](https://huggingface.co/datasets/DataStudio/Vietnamese_ASR_TestingData_Old) — 44100 Hz
+- [`EMINES/Tamazight-Speech-to-Arabic-Text`](https://huggingface.co/datasets/EMINES/Tamazight-Speech-to-Arabic-Text) — 44100 Hz
+- [`fablevi/one_voice_FACEBOOK_PARQUET`](https://huggingface.co/datasets/fablevi/one_voice_FACEBOOK_PARQUET) — 44100 Hz
+- [`farbodbij/persian-words`](https://huggingface.co/datasets/farbodbij/persian-words) — 44100 Hz
+- [`fiifinketia/twi-trigrams-speech-text-parallel`](https://huggingface.co/datasets/fiifinketia/twi-trigrams-speech-text-parallel) — 44100 Hz
+- [`fosters/ales-krautsevich-karotkaia-gistoryia-belarusi-uladzimir-lisouski-output_original`](https://huggingface.co/datasets/fosters/ales-krautsevich-karotkaia-gistoryia-belarusi-uladzimir-lisouski-output_original) — 44100 Hz
+- [`fosters/ales-krautsevich-karotkaia-gistoryia-belarusi-uladzimir-lisouski_all`](https://huggingface.co/datasets/fosters/ales-krautsevich-karotkaia-gistoryia-belarusi-uladzimir-lisouski_all) — 44100 Hz
+- [`fosters/ales_razanau_all`](https://huggingface.co/datasets/fosters/ales_razanau_all) — 44100 Hz
+- [`fosters/ales_razanau_output_original`](https://huggingface.co/datasets/fosters/ales_razanau_output_original) — 44100 Hz
+- [`fosters/ales_zhuk_praklytaya_lyubow_all`](https://huggingface.co/datasets/fosters/ales_zhuk_praklytaya_lyubow_all) — 44100 Hz
+- [`fosters/ales_zhuk_praklytaya_lyubow_output_original`](https://huggingface.co/datasets/fosters/ales_zhuk_praklytaya_lyubow_output_original) — 44100 Hz
+- [`fosters/anatol_vyartsinski_pesnya_pra_hleb_all`](https://huggingface.co/datasets/fosters/anatol_vyartsinski_pesnya_pra_hleb_all) — 44100 Hz
+- [`fosters/anatol_vyartsinski_pesnya_pra_hleb_output_original`](https://huggingface.co/datasets/fosters/anatol_vyartsinski_pesnya_pra_hleb_output_original) — 44100 Hz
+- [`fosters/andre_marua_pakaranne_zolatam_all`](https://huggingface.co/datasets/fosters/andre_marua_pakaranne_zolatam_all) — 44100 Hz
+- [`fosters/andre_marua_pakaranne_zolatam_output_original`](https://huggingface.co/datasets/fosters/andre_marua_pakaranne_zolatam_output_original) — 44100 Hz
+- [`fosters/Antuan_de_Sent-Ekziupiery_Planieta_ludziei_all`](https://huggingface.co/datasets/fosters/Antuan_de_Sent-Ekziupiery_Planieta_ludziei_all) — 44100 Hz
+- [`fosters/Antuan_de_Sent-Ekziupiery_Planieta_ludziei_output_original`](https://huggingface.co/datasets/fosters/Antuan_de_Sent-Ekziupiery_Planieta_ludziei_output_original) — 44100 Hz
+- [`fosters/astryd_lindgren_braty_lvinae_sertsa_all`](https://huggingface.co/datasets/fosters/astryd_lindgren_braty_lvinae_sertsa_all) — 44100 Hz
+- [`fosters/astryd_lindgren_braty_lvinae_sertsa_output_original`](https://huggingface.co/datasets/fosters/astryd_lindgren_braty_lvinae_sertsa_output_original) — 44100 Hz
+- [`fosters/bely_klyck_all`](https://huggingface.co/datasets/fosters/bely_klyck_all) — 44100 Hz
+- [`fosters/dzhozef_redzyard_kipling_all`](https://huggingface.co/datasets/fosters/dzhozef_redzyard_kipling_all) — 44100 Hz
+- [`fosters/dzhozef_redzyard_kipling_output_original`](https://huggingface.co/datasets/fosters/dzhozef_redzyard_kipling_output_original) — 44100 Hz
+- [`fosters/dzintra_shultse_robertsik_all`](https://huggingface.co/datasets/fosters/dzintra_shultse_robertsik_all) — 44100 Hz
+- [`fosters/dzintra_shultse_robertsik_output_original`](https://huggingface.co/datasets/fosters/dzintra_shultse_robertsik_output_original) — 44100 Hz
+- [`fosters/ernest_heminguei_stary_chalavek_i_mora_all`](https://huggingface.co/datasets/fosters/ernest_heminguei_stary_chalavek_i_mora_all) — 44100 Hz
+- [`fosters/ernest_heminguei_stary_chalavek_i_mora_output_original`](https://huggingface.co/datasets/fosters/ernest_heminguei_stary_chalavek_i_mora_output_original) — 44100 Hz
+- [`fosters/eryh_maryya_remark_all`](https://huggingface.co/datasets/fosters/eryh_maryya_remark_all) — 44100 Hz
+- [`fosters/eryh_maryya_remark_output_original`](https://huggingface.co/datasets/fosters/eryh_maryya_remark_output_original) — 44100 Hz
+- [`fosters/eryh_raspe_prygody_barona_myunhau_zena_all`](https://huggingface.co/datasets/fosters/eryh_raspe_prygody_barona_myunhau_zena_all) — 44100 Hz
+- [`fosters/eryh_raspe_prygody_barona_myunhau_zena_output_original`](https://huggingface.co/datasets/fosters/eryh_raspe_prygody_barona_myunhau_zena_output_original) — 44100 Hz
+- [`fosters/genadz_pashkou_all`](https://huggingface.co/datasets/fosters/genadz_pashkou_all) — 44100 Hz
+- [`fosters/genadz_pashkou_output_original`](https://huggingface.co/datasets/fosters/genadz_pashkou_output_original) — 44100 Hz
+- [`fosters/iagan_frydryh_shyler_kubak_all`](https://huggingface.co/datasets/fosters/iagan_frydryh_shyler_kubak_all) — 44100 Hz
+- [`fosters/iagan_frydryh_shyler_kubak_output_original`](https://huggingface.co/datasets/fosters/iagan_frydryh_shyler_kubak_output_original) — 44100 Hz
+- [`fosters/iakub-kolas-kazki-zhytstsia-output_original`](https://huggingface.co/datasets/fosters/iakub-kolas-kazki-zhytstsia-output_original) — 44100 Hz
+- [`fosters/iakub-kolas-kazki-zhytstsia_all`](https://huggingface.co/datasets/fosters/iakub-kolas-kazki-zhytstsia_all) — 44100 Hz
+- [`fosters/ivan-melezh-podykh-navalnitsy-valer-budzevich-output_original`](https://huggingface.co/datasets/fosters/ivan-melezh-podykh-navalnitsy-valer-budzevich-output_original) — 44100 Hz
+- [`fosters/ivan-melezh-podykh-navalnitsy-valer-budzevich_all`](https://huggingface.co/datasets/fosters/ivan-melezh-podykh-navalnitsy-valer-budzevich_all) — 44100 Hz
+- [`fosters/ivan-melezh-zavei-snezhan-valer-budzevich-output_original`](https://huggingface.co/datasets/fosters/ivan-melezh-zavei-snezhan-valer-budzevich-output_original) — 44100 Hz
+- [`fosters/ivan-melezh-zavei-snezhan-valer-budzevich_all`](https://huggingface.co/datasets/fosters/ivan-melezh-zavei-snezhan-valer-budzevich_all) — 44100 Hz
+- [`fosters/ivan-navumenka-zhul-vern-output_original`](https://huggingface.co/datasets/fosters/ivan-navumenka-zhul-vern-output_original) — 44100 Hz
+- [`fosters/ivan-navumenka-zhul-vern_all`](https://huggingface.co/datasets/fosters/ivan-navumenka-zhul-vern_all) — 44100 Hz
+- [`fosters/ivan-ptashnikau-lvy-output_original`](https://huggingface.co/datasets/fosters/ivan-ptashnikau-lvy-output_original) — 44100 Hz
+- [`fosters/ivan-ptashnikau-lvy_all`](https://huggingface.co/datasets/fosters/ivan-ptashnikau-lvy_all) — 44100 Hz
+- [`fosters/ivan_navumenka_sasna_pry_daroze_all`](https://huggingface.co/datasets/fosters/ivan_navumenka_sasna_pry_daroze_all) — 44100 Hz
+- [`fosters/ivan_navumenka_sasna_pry_daroze_output_original`](https://huggingface.co/datasets/fosters/ivan_navumenka_sasna_pry_daroze_output_original) — 44100 Hz
+- [`fosters/ivan_ptashnikau_all`](https://huggingface.co/datasets/fosters/ivan_ptashnikau_all) — 44100 Hz
+- [`fosters/ivan_ptashnikau_output_original`](https://huggingface.co/datasets/fosters/ivan_ptashnikau_output_original) — 44100 Hz
+- [`fosters/ivan_shamyakin_sertsa_na_daloni_all`](https://huggingface.co/datasets/fosters/ivan_shamyakin_sertsa_na_daloni_all) — 44100 Hz
+- [`fosters/ivan_shamyakin_sertsa_na_daloni_output_original`](https://huggingface.co/datasets/fosters/ivan_shamyakin_sertsa_na_daloni_output_original) — 44100 Hz
+- [`fosters/ivan_shamyakin_tryvozhnae_shchastse_all`](https://huggingface.co/datasets/fosters/ivan_shamyakin_tryvozhnae_shchastse_all) — 44100 Hz
+- [`fosters/ivan_shamyakin_tryvozhnae_shchastse_output_original`](https://huggingface.co/datasets/fosters/ivan_shamyakin_tryvozhnae_shchastse_output_original) — 44100 Hz
+- [`fosters/knihi-be-arlou_tancy_nad_horadam_all`](https://huggingface.co/datasets/fosters/knihi-be-arlou_tancy_nad_horadam_all) — 44100 Hz
+- [`fosters/knihi-be-arlou_tancy_nad_horadam_output_original`](https://huggingface.co/datasets/fosters/knihi-be-arlou_tancy_nad_horadam_output_original) — 44100 Hz
+- [`fosters/kuzma_chorny_makarkavyh_volka_all`](https://huggingface.co/datasets/fosters/kuzma_chorny_makarkavyh_volka_all) — 44100 Hz
+- [`fosters/kuzma_chorny_makarkavyh_volka_output_original`](https://huggingface.co/datasets/fosters/kuzma_chorny_makarkavyh_volka_output_original) — 44100 Hz
+- [`fosters/kuzma_chorny_poshuki_buduchyni_all`](https://huggingface.co/datasets/fosters/kuzma_chorny_poshuki_buduchyni_all) — 44100 Hz
+- [`fosters/kuzma_chorny_poshuki_buduchyni_output_original`](https://huggingface.co/datasets/fosters/kuzma_chorny_poshuki_buduchyni_output_original) — 44100 Hz
+- [`fosters/kuzma_chorny_zyamlya_all`](https://huggingface.co/datasets/fosters/kuzma_chorny_zyamlya_all) — 44100 Hz
+- [`fosters/kuzma_chorny_zyamlya_output_original`](https://huggingface.co/datasets/fosters/kuzma_chorny_zyamlya_output_original) — 44100 Hz
+- [`fosters/legendy-i-padanni_all`](https://huggingface.co/datasets/fosters/legendy-i-padanni_all) — 44100 Hz
+- [`fosters/legendy-i-padanni_original`](https://huggingface.co/datasets/fosters/legendy-i-padanni_original) — 44100 Hz
+- [`fosters/maksim_tank_all`](https://huggingface.co/datasets/fosters/maksim_tank_all) — 44100 Hz
+- [`fosters/maksim_tank_output_original`](https://huggingface.co/datasets/fosters/maksim_tank_output_original) — 44100 Hz
+- [`fosters/mar_yan_duksa_all`](https://huggingface.co/datasets/fosters/mar_yan_duksa_all) — 44100 Hz
+- [`fosters/mar_yan_duksa_output_original`](https://huggingface.co/datasets/fosters/mar_yan_duksa_output_original) — 44100 Hz
+- [`fosters/raisa_baravikova_vasmiradkou_i_all`](https://huggingface.co/datasets/fosters/raisa_baravikova_vasmiradkou_i_all) — 44100 Hz
+- [`fosters/raisa_baravikova_vasmiradkou_i_output_original`](https://huggingface.co/datasets/fosters/raisa_baravikova_vasmiradkou_i_output_original) — 44100 Hz
+- [`fosters/raisa_baravikova_vershy_pra_kahanne_all`](https://huggingface.co/datasets/fosters/raisa_baravikova_vershy_pra_kahanne_all) — 44100 Hz
+- [`fosters/raisa_baravikova_vershy_pra_kahanne_output_original`](https://huggingface.co/datasets/fosters/raisa_baravikova_vershy_pra_kahanne_output_original) — 44100 Hz
+- [`fosters/shata_rustaveli_vitsyaz_u_tygravai_shkury_all`](https://huggingface.co/datasets/fosters/shata_rustaveli_vitsyaz_u_tygravai_shkury_all) — 44100 Hz
+- [`fosters/shata_rustaveli_vitsyaz_u_tygravai_shkury_output_original`](https://huggingface.co/datasets/fosters/shata_rustaveli_vitsyaz_u_tygravai_shkury_output_original) — 44100 Hz
+- [`fosters/stefan_tsvei_g_nyabachnaya_kalektsyya_all`](https://huggingface.co/datasets/fosters/stefan_tsvei_g_nyabachnaya_kalektsyya_all) — 44100 Hz
+- [`fosters/stefan_tsvei_g_nyabachnaya_kalektsyya_output_original`](https://huggingface.co/datasets/fosters/stefan_tsvei_g_nyabachnaya_kalektsyya_output_original) — 44100 Hz
+- [`fosters/taras_shau_chenka_vershy_paemy_all`](https://huggingface.co/datasets/fosters/taras_shau_chenka_vershy_paemy_all) — 44100 Hz
+- [`fosters/taras_shau_chenka_vershy_paemy_output_original`](https://huggingface.co/datasets/fosters/taras_shau_chenka_vershy_paemy_output_original) — 44100 Hz
+- [`fosters/uilyam_folkner_pah_verbeny_all`](https://huggingface.co/datasets/fosters/uilyam_folkner_pah_verbeny_all) — 44100 Hz
+- [`fosters/uilyam_folkner_pah_verbeny_output_original`](https://huggingface.co/datasets/fosters/uilyam_folkner_pah_verbeny_output_original) — 44100 Hz
+- [`fosters/uladzimir-karatkevich-dzikae-paliavanne-karalia-stakha-aleg-garbuz-output_original`](https://huggingface.co/datasets/fosters/uladzimir-karatkevich-dzikae-paliavanne-karalia-stakha-aleg-garbuz-output_original) — 44100 Hz
+- [`fosters/uladzimir-karatkevich-dzikae-paliavanne-karalia-stakha-aleg-garbuz_all`](https://huggingface.co/datasets/fosters/uladzimir-karatkevich-dzikae-paliavanne-karalia-stakha-aleg-garbuz_all) — 44100 Hz
+- [`fosters/vasil_bykau_all`](https://huggingface.co/datasets/fosters/vasil_bykau_all) — 44100 Hz
+- [`fosters/vasil_bykau_output_original`](https://huggingface.co/datasets/fosters/vasil_bykau_output_original) — 44100 Hz
+- [`fosters/vasil_zue_nok_syaliba_all`](https://huggingface.co/datasets/fosters/vasil_zue_nok_syaliba_all) — 44100 Hz
+- [`fosters/vasil_zue_nok_syaliba_output_original`](https://huggingface.co/datasets/fosters/vasil_zue_nok_syaliba_output_original) — 44100 Hz
+- [`fosters/viktar_prau_dzin_all`](https://huggingface.co/datasets/fosters/viktar_prau_dzin_all) — 44100 Hz
+- [`fosters/viktar_prau_dzin_output_original`](https://huggingface.co/datasets/fosters/viktar_prau_dzin_output_original) — 44100 Hz
+- [`fosters/yakub_kolas_novaya_zyamlya_all`](https://huggingface.co/datasets/fosters/yakub_kolas_novaya_zyamlya_all) — 44100 Hz
+- [`fosters/yakub_kolas_novaya_zyamlya_output_original`](https://huggingface.co/datasets/fosters/yakub_kolas_novaya_zyamlya_output_original) — 44100 Hz
+- [`fosters/yanka_bryl_ptushki_i_gne_zdy_all`](https://huggingface.co/datasets/fosters/yanka_bryl_ptushki_i_gne_zdy_all) — 44100 Hz
+- [`fosters/yanka_bryl_ptushki_i_gne_zdy_output_original`](https://huggingface.co/datasets/fosters/yanka_bryl_ptushki_i_gne_zdy_output_original) — 44100 Hz
+- [`fosters/yanka_sipakou_odzium_all`](https://huggingface.co/datasets/fosters/yanka_sipakou_odzium_all) — 44100 Hz
+- [`fosters/yanka_sipakou_odzium_output_original`](https://huggingface.co/datasets/fosters/yanka_sipakou_odzium_output_original) — 44100 Hz
+- [`futureDoctor/turkic_tts_dataset`](https://huggingface.co/datasets/futureDoctor/turkic_tts_dataset) — 44100 Hz
+- [`ghananlpcommunity/asante-twi-bible-speech-phonemes`](https://huggingface.co/datasets/ghananlpcommunity/asante-twi-bible-speech-phonemes) — 44100 Hz
+- [`ghananlpcommunity/twi-trigrams-speech-text-parallel`](https://huggingface.co/datasets/ghananlpcommunity/twi-trigrams-speech-text-parallel) — 44100 Hz
+- [`grandhigh/sample-id`](https://huggingface.co/datasets/grandhigh/sample-id) — 44100 Hz
+- [`grider-transwithai/nekopara-speech`](https://huggingface.co/datasets/grider-transwithai/nekopara-speech) — 44100 Hz
+- [`hananeek2/STT-algerian-dialect`](https://huggingface.co/datasets/hananeek2/STT-algerian-dialect) — 44100 Hz
+- [`hhim8826/japanese-anime-speech-v2-split`](https://huggingface.co/datasets/hhim8826/japanese-anime-speech-v2-split) — 44100 Hz
+- [`humairawan/AnimeSpeech`](https://huggingface.co/datasets/humairawan/AnimeSpeech) — 44100 Hz
+- [`jdapaah/asante-twi-bible`](https://huggingface.co/datasets/jdapaah/asante-twi-bible) — 44100 Hz
+- [`joujiboi/kuroyukihime-speech`](https://huggingface.co/datasets/joujiboi/kuroyukihime-speech) — 44100 Hz
+- [`kizuna-intelligence/AItuber-Persona-Voices-JA`](https://huggingface.co/datasets/kizuna-intelligence/AItuber-Persona-Voices-JA) — 44100 Hz
+- [`langswap/dialogs-ru-emotional-conversations`](https://huggingface.co/datasets/langswap/dialogs-ru-emotional-conversations) — 44100 Hz
+- [`MatrixStudio/TTS-SCFChilSC`](https://huggingface.co/datasets/MatrixStudio/TTS-SCFChilSC) — 44100 Hz
+- [`metricv/tl-whisper`](https://huggingface.co/datasets/metricv/tl-whisper) — 44100 Hz
+- [`Michel21/rick-sanchez`](https://huggingface.co/datasets/Michel21/rick-sanchez) — 44100 Hz
+- [`MikhailT/hifi-tts`](https://huggingface.co/datasets/MikhailT/hifi-tts) — 44100 Hz
+- [`MohamedRashad/SCC22`](https://huggingface.co/datasets/MohamedRashad/SCC22) — 44100 Hz
+- [`MothersTongue/mother_tongue_dataset`](https://huggingface.co/datasets/MothersTongue/mother_tongue_dataset) — 44100 Hz
+- [`msnowchanj/pvariant-EQ`](https://huggingface.co/datasets/msnowchanj/pvariant-EQ) — 44100 Hz
+- [`Pragmaticl/Trys2`](https://huggingface.co/datasets/Pragmaticl/Trys2) — 44100 Hz
+- [`Pragmaticl/TuyenVanHoa2`](https://huggingface.co/datasets/Pragmaticl/TuyenVanHoa2) — 44100 Hz
+- [`Pragmaticl/TuyenVanHoa4`](https://huggingface.co/datasets/Pragmaticl/TuyenVanHoa4) — 44100 Hz
+- [`Professor/kinyarwanda-tts-dataset-kin`](https://huggingface.co/datasets/Professor/kinyarwanda-tts-dataset-kin) — 44100 Hz
+- [`ray0rf1re/GLaDOS-audio-v2`](https://huggingface.co/datasets/ray0rf1re/GLaDOS-audio-v2) — 44100 Hz
+- [`sachin6624/malayalam-tts-pro-voice`](https://huggingface.co/datasets/sachin6624/malayalam-tts-pro-voice) — 44100 Hz
+- [`shannonnonshan/ViMedCSS-Cop`](https://huggingface.co/datasets/shannonnonshan/ViMedCSS-Cop) — 44100 Hz
+- [`ShoukanLabs/AniSpeech`](https://huggingface.co/datasets/ShoukanLabs/AniSpeech) — 44100 Hz
+- [`SoufianeDahimi/Tamazight-ASR-Dataset-v2`](https://huggingface.co/datasets/SoufianeDahimi/Tamazight-ASR-Dataset-v2) — 44100 Hz
+- [`sudoping01/bam-asr-benchmark`](https://huggingface.co/datasets/sudoping01/bam-asr-benchmark) — 44100 Hz
+- [`SynDataLab-EN-Refs/echo-ref-speakers-4k-en`](https://huggingface.co/datasets/SynDataLab-EN-Refs/echo-ref-speakers-4k-en) — 44100 Hz
+- [`SynDataLab-EN-Refs/tts-pretrain-refs-3k-mos`](https://huggingface.co/datasets/SynDataLab-EN-Refs/tts-pretrain-refs-3k-mos) — 44100 Hz
+- [`SynDataLab-EN/EchoTTS-OmniVoice-En`](https://huggingface.co/datasets/SynDataLab-EN/EchoTTS-OmniVoice-En) — 44100 Hz
+- [`tensorxt/ViMedCSS`](https://huggingface.co/datasets/tensorxt/ViMedCSS) — 44100 Hz
+- [`Thorsten-Voice/TV-44kHz-Full`](https://huggingface.co/datasets/Thorsten-Voice/TV-44kHz-Full) — 44100 Hz
+- [`timniel/Pidgin_ASR_Dataset_Combined`](https://huggingface.co/datasets/timniel/Pidgin_ASR_Dataset_Combined) — 44100 Hz
+- [`trysem/malayalam-tts-pro-voice`](https://huggingface.co/datasets/trysem/malayalam-tts-pro-voice) — 44100 Hz
+- [`TutlaytAI/kabyle_asr`](https://huggingface.co/datasets/TutlaytAI/kabyle_asr) — 44100 Hz
+- [`TutlaytAI/Kabyle_ASR-En_Translation`](https://huggingface.co/datasets/TutlaytAI/Kabyle_ASR-En_Translation) — 44100 Hz
+- [`TutlaytAI/Kabyle_ASR-Fr_Translation`](https://huggingface.co/datasets/TutlaytAI/Kabyle_ASR-Fr_Translation) — 44100 Hz
+- [`vsisik/voice-dataset-lili`](https://huggingface.co/datasets/vsisik/voice-dataset-lili) — 44100 Hz
+- [`wcwxyz/test-audio`](https://huggingface.co/datasets/wcwxyz/test-audio) — 44100 Hz
+- [`WhissleAI/Meta_STT_ZH_AIShell3`](https://huggingface.co/datasets/WhissleAI/Meta_STT_ZH_AIShell3) — 44100 Hz
+- [`yasalma/audiobooks`](https://huggingface.co/datasets/yasalma/audiobooks) — 44100 Hz
+- [`ymoslem/BitesizeIrish-GA-EN`](https://huggingface.co/datasets/ymoslem/BitesizeIrish-GA-EN) — 44100 Hz
+- [`yuriilaba/toronto-tv-ukrainian`](https://huggingface.co/datasets/yuriilaba/toronto-tv-ukrainian) — 44100 Hz
+
+</details>
+
+## Usage
+
+See the canonical
+**Load from Hugging Face**
+section in the source repo. **`decoder_depth=20` is required** — the weights are a
+depth-20 decoder, so loading with any other depth mismatches the architecture.
+
+```python
+import soundfile as sf
+
+# the `neucodec/` package is bundled in this repo (see 'Inference (self-contained)')
+from neucodec import NeuCodec
+
+# decoder_depth=20 MUST match this repo; pass token=... (or hf login) for access
+model = NeuCodec._from_pretrained(model_id="Scicom-intl/WideCodec", decoder_depth=20)
+model = model.eval().cuda()
+
+# encode (16 kHz path, frozen) -> codes -> decode (44.1 kHz, this finetune)
+codes = model.encode_code("input.wav")                   # [1, 1, T], identical to base NeuCodec
+recon_44k = model.decode_code(codes).squeeze().cpu().numpy()
+sf.write("recon.wav", recon_44k, model.sample_rate)      # 44100
+```
+
+The discrete codes are **identical to base `neuphonic/neucodec`** — only the reconstruction
+sample rate and fidelity differ.

infer_widecodec.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""WideCodec — self-contained inference (44.1 kHz neural codec, depth-20 decoder).
+
+Encode -> decode any audio to a 44.1 kHz reconstruction. The encoder ingests mono
+16 kHz; the frozen FSQ codebook (single codebook, 50 tokens/s, ~0.8 kbps) yields the
+code stream; the depth-20 decoder renders it back to 44.1 kHz.
+
+This script + the bundled `neucodec/` package are ALL you need — no other source
+repo. Weights (`pytorch_model.bin`) are pulled from the HF model repo on first run.
+
+  pip install torch transformers huggingface_hub local-attention einops librosa soundfile
+  huggingface-cli login          # if the repo is private (or export HF_TOKEN=hf_...)
+  python infer_widecodec.py --input my.wav --out-dir out
+  python infer_widecodec.py --input folder/ --out-dir out    # batch a directory
+"""
+import argparse
+import glob
+import os
+import sys
+
+# make the bundled `neucodec/` package importable regardless of CWD
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+os.environ.setdefault("HF_HUB_DISABLE_XET", "1")  # plain HTTPS: Xet can hang on some networks
+
+import librosa
+import soundfile as sf
+import torch
+
+from neucodec import NeuCodec
+
+AUDIO_EXTS = (".wav", ".mp3", ".flac", ".m4a", ".ogg", ".opus")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--input", required=True, help="audio file OR a directory of audio")
+    ap.add_argument("--out-dir", default="out")
+    ap.add_argument("--repo", default="Scicom-intl/WideCodec")
+    ap.add_argument("--depth", type=int, default=20, help="decoder depth (WideCodec=20)")
+    ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
+    a = ap.parse_args()
+
+    os.makedirs(a.out_dir, exist_ok=True)
+    print(f"[infer] loading {a.repo} (decoder_depth={a.depth}) on {a.device} …")
+    model = NeuCodec._from_pretrained(
+        model_id=a.repo, decoder_depth=a.depth, token=os.environ.get("HF_TOKEN")
+    ).eval().to(a.device)
+    sr_out = model.sample_rate
+    print(f"[infer] output sample_rate = {sr_out}")
+
+    if os.path.isdir(a.input):
+        files = sorted(f for f in glob.glob(os.path.join(a.input, "*"))
+                       if f.lower().endswith(AUDIO_EXTS))
+    else:
+        files = [a.input]
+    print(f"[infer] {len(files)} file(s)")
+
+    for f in files:
+        wav16, _ = librosa.load(f, sr=16000, mono=True)  # frozen encoder wants 16 kHz mono
+        x = torch.from_numpy(wav16).float().view(1, 1, -1).to(a.device)
+        with torch.no_grad():
+            codes = model.encode_code(x)
+            wav = model.decode_code(codes).squeeze().detach().cpu().float().numpy()
+        base = os.path.splitext(os.path.basename(f))[0]
+        out = os.path.join(a.out_dir, f"{base}_44k.wav")
+        sf.write(out, wav, sr_out)
+        print(f"[infer] {f} -> {out}  ({len(wav) / sr_out:.2f}s @ {sr_out} Hz)")
+
+
+if __name__ == "__main__":
+    main()

last.ckpt

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

neucodec/__init__.py

@@ -0,0 +1 @@
+from .model import NeuCodec

neucodec/activations.py

@@ -0,0 +1,126 @@
+# Implementation adapted from https://github.com/EdwardDixon/snake under the MIT license.
+#   LICENSE is in incl_licenses directory.
+
+import torch
+from torch import nn, sin, pow
+from torch.nn import Parameter
+
+
+class Snake(nn.Module):
+    """
+    Implementation of a sine-based periodic activation function
+    Shape:
+        - Input: (B, C, T)
+        - Output: (B, C, T), same shape as the input
+    Parameters:
+        - alpha - trainable parameter
+    References:
+        - This activation function is from this paper by Liu Ziyin, Tilman Hartwig, Masahito Ueda:
+        https://arxiv.org/abs/2006.08195
+    Examples:
+        >>> a1 = snake(256)
+        >>> x = torch.randn(256)
+        >>> x = a1(x)
+    """
+
+    def __init__(
+        self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=False
+    ):
+        """
+        Initialization.
+        INPUT:
+            - in_features: shape of the input
+            - alpha: trainable parameter
+            alpha is initialized to 1 by default, higher values = higher-frequency.
+            alpha will be trained along with the rest of your model.
+        """
+        super(Snake, self).__init__()
+        self.in_features = in_features
+
+        # initialize alpha
+        self.alpha_logscale = alpha_logscale
+        if self.alpha_logscale:  # log scale alphas initialized to zeros
+            self.alpha = Parameter(torch.zeros(in_features) * alpha)
+        else:  # linear scale alphas initialized to ones
+            self.alpha = Parameter(torch.ones(in_features) * alpha)
+
+        self.alpha.requires_grad = alpha_trainable
+
+        self.no_div_by_zero = 0.000000001
+
+    def forward(self, x):
+        """
+        Forward pass of the function.
+        Applies the function to the input elementwise.
+        Snake ∶= x + 1/a * sin^2 (xa)
+        """
+        alpha = self.alpha.unsqueeze(0).unsqueeze(-1)  # line up with x to [B, C, T]
+        if self.alpha_logscale:
+            alpha = torch.exp(alpha)
+        x = x + (1.0 / (alpha + self.no_div_by_zero)) * pow(sin(x * alpha), 2)
+
+        return x
+
+
+class SnakeBeta(nn.Module):
+    """
+    A modified Snake function which uses separate parameters for the magnitude of the periodic components
+    Shape:
+        - Input: (B, C, T)
+        - Output: (B, C, T), same shape as the input
+    Parameters:
+        - alpha - trainable parameter that controls frequency
+        - beta - trainable parameter that controls magnitude
+    References:
+        - This activation function is a modified version based on this paper by Liu Ziyin, Tilman Hartwig, Masahito Ueda:
+        https://arxiv.org/abs/2006.08195
+    Examples:
+        >>> a1 = snakebeta(256)
+        >>> x = torch.randn(256)
+        >>> x = a1(x)
+    """
+
+    def __init__(
+        self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=False
+    ):
+        """
+        Initialization.
+        INPUT:
+            - in_features: shape of the input
+            - alpha - trainable parameter that controls frequency
+            - beta - trainable parameter that controls magnitude
+            alpha is initialized to 1 by default, higher values = higher-frequency.
+            beta is initialized to 1 by default, higher values = higher-magnitude.
+            alpha will be trained along with the rest of your model.
+        """
+        super(SnakeBeta, self).__init__()
+        self.in_features = in_features
+
+        # initialize alpha
+        self.alpha_logscale = alpha_logscale
+        if self.alpha_logscale:  # log scale alphas initialized to zeros
+            self.alpha = Parameter(torch.zeros(in_features) * alpha)
+            self.beta = Parameter(torch.zeros(in_features) * alpha)
+        else:  # linear scale alphas initialized to ones
+            self.alpha = Parameter(torch.ones(in_features) * alpha)
+            self.beta = Parameter(torch.ones(in_features) * alpha)
+
+        self.alpha.requires_grad = alpha_trainable
+        self.beta.requires_grad = alpha_trainable
+
+        self.no_div_by_zero = 0.000000001
+
+    def forward(self, x):
+        """
+        Forward pass of the function.
+        Applies the function to the input elementwise.
+        SnakeBeta ∶= x + 1/b * sin^2 (xa)
+        """
+        alpha = self.alpha.unsqueeze(0).unsqueeze(-1)  # line up with x to [B, C, T]
+        beta = self.beta.unsqueeze(0).unsqueeze(-1)
+        if self.alpha_logscale:
+            alpha = torch.exp(alpha)
+            beta = torch.exp(beta)
+        x = x + (1.0 / (beta + self.no_div_by_zero)) * pow(sin(x * alpha), 2)
+
+        return x

neucodec/alias_free_torch/__init__.py

@@ -0,0 +1,6 @@
+# Adapted from https://github.com/junjun3518/alias-free-torch under the Apache License 2.0
+#   LICENSE is in incl_licenses directory.
+
+from .filter import *
+from .resample import *
+from .act import *

neucodec/alias_free_torch/act.py

@@ -0,0 +1,30 @@
+# Adapted from https://github.com/junjun3518/alias-free-torch under the Apache License 2.0
+#   LICENSE is in incl_licenses directory.
+
+import torch.nn as nn
+from .resample import UpSample1d, DownSample1d
+
+
+class Activation1d(nn.Module):
+    def __init__(
+        self,
+        activation,
+        up_ratio: int = 2,
+        down_ratio: int = 2,
+        up_kernel_size: int = 12,
+        down_kernel_size: int = 12,
+    ):
+        super().__init__()
+        self.up_ratio = up_ratio
+        self.down_ratio = down_ratio
+        self.act = activation
+        self.upsample = UpSample1d(up_ratio, up_kernel_size)
+        self.downsample = DownSample1d(down_ratio, down_kernel_size)
+
+    # x: [B,C,T]
+    def forward(self, x):
+        x = self.upsample(x)
+        x = self.act(x)
+        x = self.downsample(x)
+
+        return x

neucodec/alias_free_torch/filter.py

@@ -0,0 +1,99 @@
+# Adapted from https://github.com/junjun3518/alias-free-torch under the Apache License 2.0
+#   LICENSE is in incl_licenses directory.
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+
+if "sinc" in dir(torch):
+    sinc = torch.sinc
+else:
+    # This code is adopted from adefossez's julius.core.sinc under the MIT License
+    # https://adefossez.github.io/julius/julius/core.html
+    #   LICENSE is in incl_licenses directory.
+    def sinc(x: torch.Tensor):
+        """
+        Implementation of sinc, i.e. sin(pi * x) / (pi * x)
+        __Warning__: Different to julius.sinc, the input is multiplied by `pi`!
+        """
+        return torch.where(
+            x == 0,
+            torch.tensor(1.0, device=x.device, dtype=x.dtype),
+            torch.sin(math.pi * x) / math.pi / x,
+        )
+
+
+# This code is adopted from adefossez's julius.lowpass.LowPassFilters under the MIT License
+# https://adefossez.github.io/julius/julius/lowpass.html
+#   LICENSE is in incl_licenses directory.
+def kaiser_sinc_filter1d(
+    cutoff, half_width, kernel_size
+):  # return filter [1,1,kernel_size]
+    even = kernel_size % 2 == 0
+    half_size = kernel_size // 2
+
+    # For kaiser window
+    delta_f = 4 * half_width
+    A = 2.285 * (half_size - 1) * math.pi * delta_f + 7.95
+    if A > 50.0:
+        beta = 0.1102 * (A - 8.7)
+    elif A >= 21.0:
+        beta = 0.5842 * (A - 21) ** 0.4 + 0.07886 * (A - 21.0)
+    else:
+        beta = 0.0
+    window = torch.kaiser_window(kernel_size, beta=beta, periodic=False)
+
+    # ratio = 0.5/cutoff -> 2 * cutoff = 1 / ratio
+    if even:
+        time = torch.arange(-half_size, half_size) + 0.5
+    else:
+        time = torch.arange(kernel_size) - half_size
+    if cutoff == 0:
+        filter_ = torch.zeros_like(time)
+    else:
+        filter_ = 2 * cutoff * window * sinc(2 * cutoff * time)
+        # Normalize filter to have sum = 1, otherwise we will have a small leakage
+        # of the constant component in the input signal.
+        filter_ /= filter_.sum()
+        filter = filter_.view(1, 1, kernel_size)
+
+    return filter
+
+
+class LowPassFilter1d(nn.Module):
+    def __init__(
+        self,
+        cutoff=0.5,
+        half_width=0.6,
+        stride: int = 1,
+        padding: bool = True,
+        padding_mode: str = "replicate",
+        kernel_size: int = 12,
+    ):
+        # kernel_size should be even number for stylegan3 setup,
+        # in this implementation, odd number is also possible.
+        super().__init__()
+        if cutoff < -0.0:
+            raise ValueError("Minimum cutoff must be larger than zero.")
+        if cutoff > 0.5:
+            raise ValueError("A cutoff above 0.5 does not make sense.")
+        self.kernel_size = kernel_size
+        self.even = kernel_size % 2 == 0
+        self.pad_left = kernel_size // 2 - int(self.even)
+        self.pad_right = kernel_size // 2
+        self.stride = stride
+        self.padding = padding
+        self.padding_mode = padding_mode
+        filter = kaiser_sinc_filter1d(cutoff, half_width, kernel_size)
+        self.register_buffer("filter", filter)
+
+    # input [B, C, T]
+    def forward(self, x):
+        _, C, _ = x.shape
+
+        if self.padding:
+            x = F.pad(x, (self.pad_left, self.pad_right), mode=self.padding_mode)
+        out = F.conv1d(x, self.filter.expand(C, -1, -1), stride=self.stride, groups=C)
+
+        return out

neucodec/alias_free_torch/resample.py

@@ -0,0 +1,58 @@
+# Adapted from https://github.com/junjun3518/alias-free-torch under the Apache License 2.0
+#   LICENSE is in incl_licenses directory.
+
+import torch.nn as nn
+from torch.nn import functional as F
+from .filter import LowPassFilter1d
+from .filter import kaiser_sinc_filter1d
+
+
+class UpSample1d(nn.Module):
+    def __init__(self, ratio=2, kernel_size=None):
+        super().__init__()
+        self.ratio = ratio
+        self.kernel_size = (
+            int(6 * ratio // 2) * 2 if kernel_size is None else kernel_size
+        )
+        self.stride = ratio
+        self.pad = self.kernel_size // ratio - 1
+        self.pad_left = self.pad * self.stride + (self.kernel_size - self.stride) // 2
+        self.pad_right = (
+            self.pad * self.stride + (self.kernel_size - self.stride + 1) // 2
+        )
+        filter = kaiser_sinc_filter1d(
+            cutoff=0.5 / ratio, half_width=0.6 / ratio, kernel_size=self.kernel_size
+        )
+        self.register_buffer("filter", filter)
+
+    # x: [B, C, T]
+    def forward(self, x):
+        _, C, _ = x.shape
+
+        x = F.pad(x, (self.pad, self.pad), mode="replicate")
+        x = self.ratio * F.conv_transpose1d(
+            x, self.filter.expand(C, -1, -1), stride=self.stride, groups=C
+        )
+        x = x[..., self.pad_left : -self.pad_right]
+
+        return x
+
+
+class DownSample1d(nn.Module):
+    def __init__(self, ratio=2, kernel_size=None):
+        super().__init__()
+        self.ratio = ratio
+        self.kernel_size = (
+            int(6 * ratio // 2) * 2 if kernel_size is None else kernel_size
+        )
+        self.lowpass = LowPassFilter1d(
+            cutoff=0.5 / ratio,
+            half_width=0.6 / ratio,
+            stride=ratio,
+            kernel_size=self.kernel_size,
+        )
+
+    def forward(self, x):
+        xx = self.lowpass(x)
+
+        return xx

neucodec/bs_roformer5.py

@@ -0,0 +1,118 @@
+import torch
+import torch.nn as nn
+from einops import rearrange
+from torchtune.modules import RotaryPositionalEmbeddings
+
+
+class RMSNorm(torch.nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-6):
+        r"""https://github.com/meta-llama/llama/blob/main/llama/model.py"""
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x):
+        norm_x = torch.mean(x**2, dim=-1, keepdim=True)
+        output = x * torch.rsqrt(norm_x + self.eps) * self.weight
+        return output
+
+
+class MLP(nn.Module):
+    def __init__(self, dim: int) -> None:
+        super().__init__()
+
+        self.fc1 = nn.Linear(dim, 4 * dim, bias=False)
+        self.silu = nn.SiLU()
+        self.fc2 = nn.Linear(4 * dim, dim, bias=False)
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.silu(x)
+        x = self.fc2(x)
+        return x
+
+
+class Attention(nn.Module):
+    def __init__(
+        self, dim: int, n_heads: int, rotary_embed: RotaryPositionalEmbeddings
+    ):
+        super().__init__()
+
+        assert dim % n_heads == 0
+
+        self.n_heads = n_heads
+        self.dim = dim
+        self.rotary_embed = rotary_embed
+
+        self.flash = hasattr(torch.nn.functional, "scaled_dot_product_attention")
+        assert self.flash, "Must have flash attention."
+
+        self.c_attn = nn.Linear(dim, 3 * dim, bias=False)
+        self.c_proj = nn.Linear(dim, dim, bias=False)
+
+    def forward(self, x):
+        r"""
+        Args:
+            x: (b, t, h*d)
+
+        Constants:
+            b: batch_size
+            t: time steps
+            r: 3
+            h: heads_num
+            d: heads_dim
+        """
+        B, T, C = x.size()
+
+        q, k, v = rearrange(
+            self.c_attn(x), "b t (r h d) -> r b h t d", r=3, h=self.n_heads
+        )
+        # q, k, v: (b, h, t, d)
+
+        q = self.rotary_embed(q)
+        k = self.rotary_embed(k)
+
+        if self.flash:
+            y = torch.nn.functional.scaled_dot_product_attention(
+                q, k, v, attn_mask=None, dropout_p=0, is_causal=False
+            )
+
+        y = rearrange(y, "b h t d -> b t (h d)")
+
+        y = self.c_proj(y)
+        # shape: (b, t, h*d)
+
+        return y
+
+
+class TransformerBlock(nn.Module):
+    def __init__(
+        self, dim: int, n_heads: int, rotary_embed: RotaryPositionalEmbeddings
+    ):
+        super().__init__()
+        self.dim = dim
+        self.n_heads = n_heads
+
+        self.att_norm = RMSNorm(dim)
+        self.ffn_norm = RMSNorm(dim)
+        self.att = Attention(dim=dim, n_heads=n_heads, rotary_embed=rotary_embed)
+        self.mlp = MLP(dim=dim)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+    ):
+        x = x + self.att(self.att_norm(x))
+        x = x + self.mlp(self.ffn_norm(x))
+        return x
+
+
+if __name__ == "__main__":
+    rotary_embed_128 = RotaryPositionalEmbeddings(dim=128)
+    transformer_block = TransformerBlock(
+        dim=1024, n_heads=8, rotary_embed=rotary_embed_128
+    )
+    x = torch.randn(2, 128, 1024)
+    y = transformer_block(x)
+    print(y.shape)
+    c = 1

neucodec/codec_decoder_vocos.py

@@ -0,0 +1,431 @@
+import torch
+import torch.nn as nn
+
+from typing import List
+from torchtune.modules import RotaryPositionalEmbeddings
+from vector_quantize_pytorch import ResidualFSQ
+
+from .bs_roformer5 import TransformerBlock
+
+
+class ISTFT(nn.Module):
+    """
+    Custom implementation of ISTFT since torch.istft doesn't allow custom padding (other than `center=True`) with
+    windowing. This is because the NOLA (Nonzero Overlap Add) check fails at the edges.
+    See issue: https://github.com/pytorch/pytorch/issues/62323
+    Specifically, in the context of neural vocoding we are interested in "same" padding analogous to CNNs.
+    The NOLA constraint is met as we trim padded samples anyway.
+
+    Args:
+        n_fft (int): Size of Fourier transform.
+        hop_length (int): The distance between neighboring sliding window frames.
+        win_length (int): The size of window frame and STFT filter.
+        padding (str, optional): Type of padding. Options are "center" or "same". Defaults to "same".
+    """
+
+    def __init__(
+        self, n_fft: int, hop_length: int, win_length: int, padding: str = "same"
+    ):
+        super().__init__()
+        if padding not in ["center", "same"]:
+            raise ValueError("Padding must be 'center' or 'same'.")
+        self.padding = padding
+        self.n_fft = n_fft
+        self.hop_length = hop_length
+        self.win_length = win_length
+        window = torch.hann_window(win_length)
+        self.register_buffer("window", window)
+
+    def forward(self, spec: torch.Tensor) -> torch.Tensor:
+        """
+        Compute the Inverse Short Time Fourier Transform (ISTFT) of a complex spectrogram.
+
+        Args:
+            spec (Tensor): Input complex spectrogram of shape (B, N, T), where B is the batch size,
+                            N is the number of frequency bins, and T is the number of time frames.
+
+        Returns:
+            Tensor: Reconstructed time-domain signal of shape (B, L), where L is the length of the output signal.
+        """
+        if self.padding == "center":
+            # Fallback to pytorch native implementation
+            return torch.istft(
+                spec,
+                self.n_fft,
+                self.hop_length,
+                self.win_length,
+                self.window,
+                center=True,
+            )
+        elif self.padding == "same":
+            pad = (self.win_length - self.hop_length) // 2
+        else:
+            raise ValueError("Padding must be 'center' or 'same'.")
+
+        assert spec.dim() == 3, "Expected a 3D tensor as input"
+        B, N, T = spec.shape
+
+        # Inverse FFT
+        ifft = torch.fft.irfft(spec, self.n_fft, dim=1, norm="backward")
+        ifft = ifft * self.window[None, :, None]
+
+        # Overlap and Add
+        output_size = (T - 1) * self.hop_length + self.win_length
+        y = torch.nn.functional.fold(
+            ifft,
+            output_size=(1, output_size),
+            kernel_size=(1, self.win_length),
+            stride=(1, self.hop_length),
+        )[:, 0, 0, pad:-pad]
+
+        # Window envelope
+        window_sq = self.window.square().expand(1, T, -1).transpose(1, 2)
+        window_envelope = torch.nn.functional.fold(
+            window_sq,
+            output_size=(1, output_size),
+            kernel_size=(1, self.win_length),
+            stride=(1, self.hop_length),
+        ).squeeze()[pad:-pad]
+
+        # Normalize
+        assert (window_envelope > 1e-11).all()
+        y = y / window_envelope
+
+        return y
+
+
+class FourierHead(nn.Module):
+    """Base class for inverse fourier modules."""
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            x (Tensor): Input tensor of shape (B, L, H), where B is the batch size,
+                        L is the sequence length, and H denotes the model dimension.
+
+        Returns:
+            Tensor: Reconstructed time-domain audio signal of shape (B, T), where T is the length of the output signal.
+        """
+        raise NotImplementedError("Subclasses must implement the forward method.")
+
+
+class ISTFTHead(FourierHead):
+    """
+    ISTFT Head module for predicting STFT complex coefficients.
+
+    Args:
+        dim (int): Hidden dimension of the model.
+        n_fft (int): Size of Fourier transform.
+        hop_length (int): The distance between neighboring sliding window frames, which should align with
+                          the resolution of the input features.
+        padding (str, optional): Type of padding. Options are "center" or "same". Defaults to "same".
+    """
+
+    def __init__(self, dim: int, n_fft: int, hop_length: int, padding: str = "same"):
+        super().__init__()
+        out_dim = n_fft + 2
+        self.out = torch.nn.Linear(dim, out_dim)
+        self.istft = ISTFT(
+            n_fft=n_fft, hop_length=hop_length, win_length=n_fft, padding=padding
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Forward pass of the ISTFTHead module.
+
+        Args:
+            x (Tensor): Input tensor of shape (B, L, H), where B is the batch size,
+                        L is the sequence length, and H denotes the model dimension.
+
+        Returns:
+            Tensor: Reconstructed time-domain audio signal of shape (B, T), where T is the length of the output signal.
+        """
+        x_pred = self.out(x)
+        # x_pred = x
+        x_pred = x_pred.transpose(1, 2)
+        mag, p = x_pred.chunk(2, dim=1)
+        mag = torch.exp(mag)
+        mag = torch.clip(
+            mag, max=1e2
+        )  # safeguard to prevent excessively large magnitudes
+        # wrapping happens here. These two lines produce real and imaginary value
+        x = torch.cos(p)
+        y = torch.sin(p)
+        # recalculating phase here does not produce anything new
+        # only costs time
+        # phase = torch.atan2(y, x)
+        # S = mag * torch.exp(phase * 1j)
+        # better directly produce the complex value
+        S = mag * (x + 1j * y)
+        audio = self.istft(S)
+        return audio.unsqueeze(1), x_pred
+
+
+def nonlinearity(x):
+    # swish
+    return x * torch.sigmoid(x)
+
+
+def Normalize(in_channels, num_groups=32):
+    return torch.nn.GroupNorm(
+        num_groups=num_groups, num_channels=in_channels, eps=1e-6, affine=True
+    )
+
+
+class ResnetBlock(nn.Module):
+    def __init__(
+        self,
+        *,
+        in_channels,
+        out_channels=None,
+        conv_shortcut=False,
+        dropout,
+        temb_channels=512,
+    ):
+        super().__init__()
+        self.in_channels = in_channels
+        out_channels = in_channels if out_channels is None else out_channels
+        self.out_channels = out_channels
+        self.use_conv_shortcut = conv_shortcut
+
+        self.norm1 = Normalize(in_channels)
+        self.conv1 = torch.nn.Conv1d(
+            in_channels, out_channels, kernel_size=3, stride=1, padding=1
+        )
+        if temb_channels > 0:
+            self.temb_proj = torch.nn.Linear(temb_channels, out_channels)
+        self.norm2 = Normalize(out_channels)
+        self.dropout = torch.nn.Dropout(dropout)
+        self.conv2 = torch.nn.Conv1d(
+            out_channels, out_channels, kernel_size=3, stride=1, padding=1
+        )
+        if self.in_channels != self.out_channels:
+            if self.use_conv_shortcut:
+                self.conv_shortcut = torch.nn.Conv1d(
+                    in_channels, out_channels, kernel_size=3, stride=1, padding=1
+                )
+            else:
+                self.nin_shortcut = torch.nn.Conv1d(
+                    in_channels, out_channels, kernel_size=1, stride=1, padding=0
+                )
+
+    def forward(self, x, temb=None):
+        h = x
+        h = self.norm1(h)
+        h = nonlinearity(h)
+        h = self.conv1(h)
+
+        if temb is not None:
+            h = h + self.temb_proj(nonlinearity(temb))[:, :, None, None]
+
+        h = self.norm2(h)
+        h = nonlinearity(h)
+        h = self.dropout(h)
+        h = self.conv2(h)
+
+        if self.in_channels != self.out_channels:
+            if self.use_conv_shortcut:
+                x = self.conv_shortcut(x)
+            else:
+                x = self.nin_shortcut(x)
+
+        return x + h
+
+
+class Backbone(nn.Module):
+    """Base class for the generator's backbone. It preserves the same temporal resolution across all layers."""
+
+    def forward(self, x: torch.Tensor, **kwargs) -> torch.Tensor:
+        """
+        Args:
+            x (Tensor): Input tensor of shape (B, C, L), where B is the batch size,
+                        C denotes output features, and L is the sequence length.
+
+        Returns:
+            Tensor: Output of shape (B, L, H), where B is the batch size, L is the sequence length,
+                    and H denotes the model dimension.
+        """
+        raise NotImplementedError("Subclasses must implement the forward method.")
+
+
+class VocosBackbone(Backbone):
+    """
+    Vocos backbone module built with ConvNeXt blocks. Supports additional conditioning with Adaptive Layer Normalization
+
+    Args:
+        input_channels (int): Number of input features channels.
+        dim (int): Hidden dimension of the model.
+        intermediate_dim (int): Intermediate dimension used in ConvNeXtBlock.
+        num_layers (int): Number of ConvNeXtBlock layers.
+        layer_scale_init_value (float, optional): Initial value for layer scaling. Defaults to `1 / num_layers`.
+        adanorm_num_embeddings (int, optional): Number of embeddings for AdaLayerNorm.
+                                                None means non-conditional model. Defaults to None.
+    """
+
+    def __init__(self, hidden_dim=1024, depth=12, heads=16, pos_meb_dim=64):
+        super().__init__()
+
+        self.embed = nn.Conv1d(hidden_dim, hidden_dim, kernel_size=7, padding=3)
+
+        self.temb_ch = 0
+        block_in = hidden_dim
+        dropout = 0.1
+
+        prior_net: List[nn.Module] = [
+            ResnetBlock(
+                in_channels=block_in,
+                out_channels=block_in,
+                temb_channels=self.temb_ch,
+                dropout=dropout,
+            ),
+            ResnetBlock(
+                in_channels=block_in,
+                out_channels=block_in,
+                temb_channels=self.temb_ch,
+                dropout=dropout,
+            ),
+        ]
+        self.prior_net = nn.Sequential(*prior_net)
+
+        depth = depth
+        time_rotary_embed = RotaryPositionalEmbeddings(dim=pos_meb_dim)
+
+        transformer_blocks = [
+            TransformerBlock(
+                dim=hidden_dim, n_heads=heads, rotary_embed=time_rotary_embed
+            )
+            for _ in range(depth)
+        ]
+
+        self.transformers = nn.Sequential(*transformer_blocks)
+        self.final_layer_norm = nn.LayerNorm(hidden_dim, eps=1e-6)
+        post_net: List[nn.Module] = [
+            ResnetBlock(
+                in_channels=block_in,
+                out_channels=block_in,
+                temb_channels=self.temb_ch,
+                dropout=dropout,
+            ),
+            ResnetBlock(
+                in_channels=block_in,
+                out_channels=block_in,
+                temb_channels=self.temb_ch,
+                dropout=dropout,
+            ),
+        ]
+        self.post_net = nn.Sequential(*post_net)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = x.transpose(1, 2)
+        x = self.embed(x)
+        x = self.prior_net(x)
+        x = x.transpose(1, 2)
+        x = self.transformers(x)
+        x = x.transpose(1, 2)
+        x = self.post_net(x)
+        x = x.transpose(1, 2)
+        x = self.final_layer_norm(x)
+        return x
+
+
+def init_weights(m):
+    if isinstance(m, nn.Conv1d):
+        nn.init.trunc_normal_(m.weight, std=0.02)
+        nn.init.constant_(m.bias, 0)
+
+
+class CodecDecoderVocos(nn.Module):
+    def __init__(
+        self,
+        hidden_dim=1024,
+        depth=12,
+        heads=16,
+        pos_meb_dim=64,
+        hop_length=320,
+        vq_num_quantizers=1,
+        vq_dim=2048,  # 1024 2048
+        vq_commit_weight=0.25,
+        vq_weight_init=False,
+        vq_full_commit_loss=False,
+        codebook_size=16384,
+        codebook_dim=16,
+    ):
+        super().__init__()
+        self.hop_length = hop_length
+
+        self.quantizer = ResidualFSQ(
+            dim=vq_dim, levels=[4, 4, 4, 4, 4, 4, 4, 4], num_quantizers=1
+        )
+
+        self.backbone = VocosBackbone(
+            hidden_dim=hidden_dim, depth=depth, heads=heads, pos_meb_dim=pos_meb_dim
+        )
+
+        self.head = ISTFTHead(
+            dim=hidden_dim,
+            n_fft=self.hop_length * 4,
+            hop_length=self.hop_length,
+            padding="same",
+        )
+
+        self.reset_parameters()
+
+    def forward(self, x, vq=True):
+        if vq is True:
+            # x, q, commit_loss = self.quantizer(x)
+            x = x.permute(0, 2, 1)
+            x, q = self.quantizer(x)
+            x = x.permute(0, 2, 1)
+            q = q.permute(0, 2, 1)
+            return x, q, None
+        x = self.backbone(x)
+        x, _ = self.head(x)
+
+        return x, _
+
+    def vq2emb(self, vq):
+        self.quantizer = self.quantizer.eval()
+        x = self.quantizer.vq2emb(vq)
+        return x
+
+    def get_emb(self):
+        self.quantizer = self.quantizer.eval()
+        embs = self.quantizer.get_emb()
+        return embs
+
+    def inference_vq(self, vq):
+        x = vq[None, :, :]
+        x = self.model(x)
+        return x
+
+    def inference_0(self, x):
+        x, q, loss, perp = self.quantizer(x)
+        x = self.model(x)
+        return x, None
+
+    def inference(self, x):
+        x = self.model(x)
+        return x, None
+
+    def remove_weight_norm(self):
+        """Remove weight normalization module from all of the layers."""
+
+        def _remove_weight_norm(m):
+            try:
+                torch.nn.utils.remove_weight_norm(m)
+            except ValueError:  # this module didn't have weight norm
+                return
+
+        self.apply(_remove_weight_norm)
+
+    def apply_weight_norm(self):
+        """Apply weight normalization module from all of the layers."""
+
+        def _apply_weight_norm(m):
+            if isinstance(m, nn.Conv1d) or isinstance(m, nn.ConvTranspose1d):
+                torch.nn.utils.weight_norm(m)
+
+        self.apply(_apply_weight_norm)
+
+    def reset_parameters(self):
+        self.apply(init_weights)

neucodec/codec_encoder.py

@@ -0,0 +1,84 @@
+import torch
+import numpy as np
+
+from torch import nn
+
+from .module import WNConv1d, EncoderBlock
+from .alias_free_torch import Activation1d
+from . import activations
+
+
+def init_weights(m):
+    if isinstance(m, nn.Conv1d):
+        nn.init.trunc_normal_(m.weight, std=0.02)
+        nn.init.constant_(m.bias, 0)
+
+
+class CodecEncoder(nn.Module):
+    def __init__(
+        self,
+        ngf=48,
+        up_ratios=[2, 2, 4, 4, 5],
+        dilations=(1, 3, 9),
+        hidden_dim=1024,
+        depth=12,
+        heads=12,
+        pos_meb_dim=64,
+    ):
+        super().__init__()
+        self.hop_length = np.prod(up_ratios)
+        self.ngf = ngf
+        self.up_ratios = up_ratios
+
+        d_model = ngf
+        self.conv_blocks = [WNConv1d(1, d_model, kernel_size=7, padding=3)]
+
+        for i, stride in enumerate(up_ratios):
+            d_model *= 2
+            self.conv_blocks += [
+                EncoderBlock(d_model, stride=stride, dilations=dilations)
+            ]
+
+        self.conv_blocks = nn.Sequential(*self.conv_blocks)
+
+        self.conv_final_block = [
+            Activation1d(
+                activation=activations.SnakeBeta(d_model, alpha_logscale=True)
+            ),
+            WNConv1d(d_model, hidden_dim, kernel_size=3, padding=1),
+        ]
+        self.conv_final_block = nn.Sequential(*self.conv_final_block)
+
+        self.reset_parameters()
+
+    def forward(self, x):
+        x = self.conv_blocks(x)
+        x = self.conv_final_block(x)
+        x = x.permute(0, 2, 1)
+        return x
+
+    def inference(self, x):
+        return self.block(x)
+
+    def remove_weight_norm(self):
+        """Remove weight normalization module from all of the layers."""
+
+        def _remove_weight_norm(m):
+            try:
+                torch.nn.utils.remove_weight_norm(m)
+            except ValueError:  # this module didn't have weight norm
+                return
+
+        self.apply(_remove_weight_norm)
+
+    def apply_weight_norm(self):
+        """Apply weight normalization module from all of the layers."""
+
+        def _apply_weight_norm(m):
+            if isinstance(m, nn.Conv1d):
+                torch.nn.utils.weight_norm(m)
+
+        self.apply(_apply_weight_norm)
+
+    def reset_parameters(self):
+        self.apply(init_weights)

neucodec/codec_encoder_distill.py

@@ -0,0 +1,388 @@
+import torch
+from torch import Tensor
+from torch import nn
+from local_attention.transformer import DynamicPositionBias, LocalMHA, FeedForward
+from .distill_layers import ChannelNorm, Conv1d, Linear, GRN, Snake1d
+from .tconv.t_first import FirstBlock
+
+
+class LocalTrans(nn.Module):
+    def __init__(
+        self,
+        dim=512,
+        depth=6,
+        causal=True,
+        local_attn_window_size=512,
+        dim_head=64,
+        heads=8,
+        ff_mult=4,
+        attn_dropout=0.0,
+        ff_dropout=0.0,
+        use_dynamic_pos_bias=False,
+        qk_rmsnorm=False,
+    ):
+        super().__init__()
+
+        self.layers = nn.ModuleList([])
+
+        self.window_size = local_attn_window_size
+        self.use_rotary_pos_emb = not use_dynamic_pos_bias
+        self.dynamic_pos_bias = (
+            None
+            if self.use_rotary_pos_emb
+            else DynamicPositionBias(dim=dim // 2, heads=heads)
+        )
+
+        for _ in range(depth):
+            self.layers.append(
+                nn.ModuleList(
+                    [
+                        LocalMHA(
+                            dim=dim,
+                            dim_head=dim_head,
+                            heads=heads,
+                            dropout=attn_dropout,
+                            causal=causal,
+                            window_size=self.window_size,
+                            use_xpos=False,
+                            xpos_scale_base=None,
+                            use_rotary_pos_emb=self.use_rotary_pos_emb,
+                            prenorm=True,
+                            qk_rmsnorm=qk_rmsnorm,
+                            exact_windowsize=False,
+                        ),
+                        FeedForward(dim=dim, mult=ff_mult, dropout=ff_dropout),
+                    ]
+                )
+            )
+
+    def forward(self, x, mask=None):
+        attn_bias = (
+            None
+            if self.use_rotary_pos_emb
+            else self.dynamic_pos_bias(self.window_size, self.window_size * 2)
+        )
+        for attn, ff in self.layers:
+            x = attn(x, mask=mask, attn_bias=attn_bias) + x
+            x = ff(x) + x
+
+        return x
+
+    @classmethod
+    def builder(
+        cls, feature_dim=128, depth=2, local_window_size=200, use_dynamic_pos_bias=False
+    ):
+        return cls(
+            dim=feature_dim,
+            depth=depth,
+            dim_head=feature_dim // 4,
+            heads=6,
+            ff_mult=4,
+            causal=True,
+            local_attn_window_size=local_window_size,
+            use_dynamic_pos_bias=use_dynamic_pos_bias,
+        )
+
+
+class LocalEncoder(nn.Module):
+    def __init__(
+        self,
+        feature_dim=128,
+        depth=2,
+        local_window_size=200,
+        use_dynamic_pos_bias=False,
+    ):
+        super().__init__()
+        self.local_trans = LocalTrans.builder(
+            feature_dim=feature_dim,
+            depth=depth,
+            local_window_size=local_window_size,
+            use_dynamic_pos_bias=use_dynamic_pos_bias,
+        )
+
+    def forward(self, feature):
+        """
+        Args:
+            feature: (B, C, T)
+        Returns:
+            local_feature: (B, T, C)
+        """
+        feature = feature.permute(0, 2, 1)
+        feature = self.local_trans(feature)
+        return feature
+
+
+class DownTrans(nn.Module):
+    def __init__(
+        self, feature_dim=128, window_size=200, compress_rate=2, depth=2, **kwargs
+    ):
+        super().__init__()
+        assert window_size % compress_rate == 0
+        self.feature_dim = feature_dim
+        self.compress_rate = compress_rate
+        self.trans = LocalTrans.builder(
+            feature_dim, local_window_size=window_size, depth=depth, **kwargs
+        )
+        self.down_layer = Conv1d(
+            feature_dim, feature_dim, kernel_size=compress_rate, stride=compress_rate
+        )
+
+    def forward(self, x):
+        x = self.trans(x)
+        # x = x[:, ::self.compress_rate, :]  # v1
+        x = self.down_layer(x.permute(0, 2, 1)).permute(0, 2, 1)  # v2
+        return x
+
+
+class CompressedLocalEncoderWithCache(nn.Module):
+    def __init__(
+        self,
+        feature_dim=128,
+        local_window_size=200,
+        compress_rate=2,
+        cache_size=3,
+        depth=4,
+        **kwargs,
+    ):
+        super().__init__()
+        self.local_window_size = local_window_size
+        self.cache_size = cache_size
+        self.compress_rate = compress_rate
+        self.trans_window_size = local_window_size + cache_size
+
+        self.cache_token = nn.Parameter(
+            torch.randn(1, self.cache_size * self.compress_rate, feature_dim)
+        )
+
+        self.down_trans = DownTrans(
+            feature_dim,
+            window_size=self.trans_window_size * compress_rate,
+            compress_rate=compress_rate,
+            depth=2,
+            **kwargs,
+        )
+
+        self.local_trans = LocalTrans.builder(
+            feature_dim,
+            local_window_size=self.trans_window_size,
+            depth=depth - 2,
+            **kwargs,
+        )
+
+    def forward(self, feature):
+        feature = feature.permute(0, 2, 1)
+        split_feature = torch.split(
+            feature, self.local_window_size * self.compress_rate, dim=1
+        )
+        cache_token = self.cache_token.expand(feature.shape[0], -1, -1)
+        feature = torch.cat(
+            [
+                f
+                for fs in split_feature
+                for f in (
+                    cache_token,
+                    fs,
+                )
+            ],
+            dim=1,
+        )
+        # assert feature[:, self.down_trans_window_size: 2*self.down_trans_window_size, :].equal(
+        #     feature.reshape(B, -1, self.down_trans_window_size, C)[:, 1, :, :])
+        feature = self.down_trans(feature)
+        feature = self.local_trans(feature)
+        return feature
+
+
+class ConvUnit(nn.Module):
+    """
+    Args:
+        dim (int): Number of input channels.
+    """
+
+    def __init__(self, dim, snake_act=True, norm=False, dilation=1, kernel_size=7):
+        super().__init__()
+        total_pad = (kernel_size - 1) * dilation
+        self.dw_conv = Conv1d(
+            dim,
+            dim,
+            kernel_size=kernel_size,
+            dilation=dilation,
+            padding=total_pad // 2,
+            groups=dim,
+        )  # depth-wise conv
+
+        self.norm = (
+            ChannelNorm(dim, data_format="channels_last") if norm else nn.Identity()
+        )
+        self.pw_conv1 = Linear(
+            dim, 4 * dim
+        )  # point-wise/1x1 conv, implemented with linear layer
+
+        if snake_act:
+            self.act = Snake1d(4 * dim, data_format="channels_last")
+        else:
+            self.act = nn.GELU()
+        self.grn = GRN(4 * dim)
+        self.pw_conv2 = Linear(4 * dim, dim)
+
+    def forward(self, x):
+        x = self.dw_conv(x)
+        x = x.permute(0, 2, 1)  # (N, C, T) -> (N, T, C)
+        x = self.norm(x)
+        x = self.pw_conv1(x)
+        x = self.act(x)
+        x = self.grn(x)
+        x = self.pw_conv2(x)
+        x = x.permute(0, 2, 1)  # (N, T, C) -> (N, C, T)
+        return x
+
+
+class Residual(nn.Module):
+    def __init__(
+        self, module: nn.Module, drop_prob: float = 0.0, scale_by_keep: bool = True
+    ):
+        super().__init__()
+        assert 0 <= drop_prob < 1
+        self.module = module
+        self.drop_prob = drop_prob
+        self.scale_by_keep = scale_by_keep
+
+    def drop_path(self, x_side: Tensor):
+        if self.drop_prob == 0.0 or not self.training:
+            return x_side
+        keep_prob = 1 - self.drop_prob
+        shape = (x_side.shape[0],) + (1,) * (x_side.ndim - 1)
+        keep_mask = x_side.new_empty(shape).bernoulli_(keep_prob)
+        if self.scale_by_keep:
+            keep_mask.div_(keep_prob)
+        return x_side * keep_mask
+
+    def forward(self, x: Tensor):
+        x_side = self.module(x)
+        x_side = self.drop_path(x_side)
+        return x + x_side
+
+
+ResidualUnit = lambda *args, drop_rate=0.0, **kwargs: Residual(
+    ConvUnit(*args, **kwargs), drop_prob=drop_rate
+)
+
+
+class LegacyUnit(nn.Module):
+    def __init__(self, dim, snake_act=True, norm=False, dilation=1, kernel_size=7):
+        super().__init__()
+        assert snake_act, "LegacyUnit only supports snake_act=True"
+        assert norm == False, "LegacyUnit only supports norm=False"
+        total_pad = (kernel_size - 1) * dilation
+        self.block = nn.Sequential(
+            Snake1d(dim),
+            Conv1d(
+                dim,
+                dim,
+                kernel_size=kernel_size,
+                dilation=dilation,
+                padding=total_pad // 2,
+            ),
+            Snake1d(dim),
+            Conv1d(dim, dim, kernel_size=1),
+        )
+
+    def forward(self, x):
+        return self.block(x)
+
+
+ResidualLegacyUnit = lambda *args, **kwargs: Residual(
+    LegacyUnit(*args, **kwargs), drop_prob=0.0
+)
+
+BaseUnit = ResidualUnit
+
+
+class Encoder(nn.Module):
+    def __init__(
+        self,
+        feature_dim: int = 512,
+        strides: tuple = (2, 2, 2, 2),
+        depths: tuple = (1, 1, 1, 1, 1),
+        dims: tuple = (32, 64, 128, 256, 512),
+        drop_path_rate: float = 0.0,
+        use_norm=False,
+        use_snake_act=True,
+    ):
+        super().__init__()
+        # Create first convolution
+        blocks = [
+            # Conv1d(1, dims[0], kernel_size=7, padding=3),
+            FirstBlock(dims[0]),
+        ]
+
+        drop_path_rates = [
+            x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))
+        ]
+        cur = 0
+        for i_d, o_d, stride, depth in zip(dims[:-1], dims[1:], strides, depths):
+            stage = nn.Sequential(
+                *[
+                    BaseUnit(
+                        dim=i_d,
+                        drop_rate=drop_path_rates[cur + j],
+                        snake_act=use_snake_act,
+                        norm=use_norm,
+                    )
+                    for j in range(depth)
+                ]
+            )
+            down_layer = nn.Sequential(
+                Conv1d(i_d, o_d, kernel_size=stride, stride=stride),
+                ChannelNorm(o_d, data_format="channels_first")
+                if use_norm
+                else nn.Identity(),
+            )
+            blocks += [stage, down_layer]
+            cur += depth
+
+        # Create last convolution
+        blocks += [
+            nn.Sequential(
+                *[
+                    BaseUnit(
+                        dim=dims[-1],
+                        drop_rate=drop_path_rates[cur + j],
+                        snake_act=use_snake_act,
+                        norm=use_norm,
+                    )
+                    for j in range(depths[-1])
+                ]
+            ),
+            # Snake1d(dims[-1]),
+            Conv1d(dims[-1], feature_dim, kernel_size=3, padding=1),
+        ]
+
+        self.blocks = nn.Sequential(*blocks)
+
+    def forward(self, x):
+        return self.blocks(x)
+
+
+class DistillCodecEncoder(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.encoder = Encoder(
+            feature_dim=512,
+            strides=(4, 4, 4, 4),
+            depths=(1, 1, 1, 2),
+            dims=(32, 64, 128, 256),
+        )
+        self.en_encoder = CompressedLocalEncoderWithCache(
+            feature_dim=512,
+            local_window_size=300,
+            compress_rate=5,
+            cache_size=0,
+            depth=5,
+            use_dynamic_pos_bias=True,
+        )
+
+    def forward(self, x):
+        x = self.encoder(x)
+        x = self.en_encoder(x)
+        return x

neucodec/distill_layers.py

@@ -0,0 +1,155 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+from torch.nn.utils.parametrizations import weight_norm
+
+
+def get_eps(data_type):
+    return torch.finfo(data_type).eps
+
+
+EPS = get_eps(torch.float32)
+
+
+def nn_wrapper(nn_class, norm_weight=True, init_weight=True):
+    def nn_builder(*args, **kwargs):
+        nn_instance = nn_class(*args, **kwargs)
+        if init_weight:
+            nn.init.trunc_normal_(nn_instance.weight, std=0.02)
+            nn.init.constant_(nn_instance.bias, 0)
+        if norm_weight:
+            nn_instance = weight_norm(nn_instance)
+        return nn_instance
+
+    return nn_builder
+
+
+Conv1d = nn_wrapper(nn.Conv1d, norm_weight=True, init_weight=True)
+Linear = nn_wrapper(nn.Linear, norm_weight=True, init_weight=True)
+
+
+class Residual(nn.Module):
+    def __init__(
+        self, module: nn.Module, drop_prob: float = 0.0, scale_by_keep: bool = True
+    ):
+        super().__init__()
+        assert 0 <= drop_prob < 1
+        self.module = module
+        self.drop_prob = drop_prob
+        self.scale_by_keep = scale_by_keep
+
+    def drop_path(self, x_side: Tensor):
+        if self.drop_prob == 0.0 or not self.training:
+            return x_side
+        keep_prob = 1 - self.drop_prob
+        shape = (x_side.shape[0],) + (1,) * (x_side.ndim - 1)
+        keep_mask = x_side.new_empty(shape).bernoulli_(keep_prob)
+        if self.scale_by_keep:
+            keep_mask.div_(keep_prob)
+        return x_side * keep_mask
+
+    def forward(self, x: Tensor):
+        x_side = self.module(x)
+        x_side = self.drop_path(x_side)
+        return x + x_side
+
+
+class GRN(nn.Module):
+    """GRN (Global Response Normalization) layer
+    Which supports two data formats: channels_last (default) or channels_first.
+    Channels_last corresponds to inputs with shape (batch_size, Sequence, channels)
+    while channels_first corresponds to inputs with shape (batch_size, channels, Sequence).
+    """
+
+    def __init__(self, n_channels, eps=EPS, data_format="channels_last"):
+        super().__init__()
+        self.n_channels = n_channels
+        self.data_format = data_format
+        if data_format == "channels_last":
+            self.gamma = nn.Parameter(torch.zeros(1, n_channels))
+            self.beta = nn.Parameter(torch.zeros(1, n_channels))
+            self.channel_dim = -1
+        elif data_format == "channels_first":
+            self.gamma = nn.Parameter(torch.zeros(n_channels, 1))
+            self.beta = nn.Parameter(torch.zeros(n_channels, 1))
+            self.channel_dim = 1
+        else:
+            raise ValueError(f"Unsupported data_format: {data_format}")
+        self.eps = torch.tensor(eps)
+
+    def forward(self, x):
+        g_x = torch.norm(x, p=2, dim=[1, 2], keepdim=True)
+        n_x = g_x / (g_x.mean(dim=self.channel_dim, keepdim=True) + self.eps)
+        return self.gamma * (x * n_x) + self.beta + x
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(n_channels={self.n_channels}, {self.data_format})"
+
+
+# Scripting this brings model speed up 1.4x
+@torch.jit.script
+def snake(x, alpha):
+    # torch.clamp_(alpha, 0.05, 50.)
+    eps = 1.1920928955078125e-07
+    x = x + (alpha + eps).reciprocal() * torch.sin(alpha * x).pow(2)
+    return x
+
+
+class Snake1d(nn.Module):
+    def __init__(self, channels, data_format="channels_first"):
+        super().__init__()
+        if data_format == "channels_first":
+            self.alpha = nn.Parameter(torch.ones(1, channels, 1))
+        elif data_format == "channels_last":
+            self.alpha = nn.Parameter(torch.ones(1, 1, channels))
+        else:
+            raise NotImplementedError
+
+    def forward(self, x):
+        return snake(x, self.alpha)
+
+
+@torch.jit.script
+def channel_norm(x, weight, bias, eps):
+    u = x.mean(1, keepdim=True)
+    s = (x - u).pow(2).mean(1, keepdim=True)
+    x = (x - u) / torch.sqrt(s + eps)
+    x = weight * x + bias
+    return x
+
+
+class ChannelNorm(nn.Module):
+    """ChannelNorm that supports two data formats: channels_last (default) or channels_first.
+    Channels_last corresponds to inputs with shape (batch_size, ..., channels)
+    while channels_first corresponds to inputs with shape (batch_size, channels, ...).
+    """
+
+    def __init__(self, n_channels, eps=EPS, data_format="channels_last"):
+        super().__init__()
+        self.n_channels = n_channels
+        self.data_format = data_format
+        self.weight = nn.Parameter(torch.ones(n_channels))
+        self.bias = nn.Parameter(torch.zeros(n_channels))
+        self.eps = torch.tensor(eps)
+
+    def forward(self, x):
+        if self.data_format == "channels_first":
+            extend_dims = (1,) * len(x.shape[2:])
+            return channel_norm(
+                x,
+                self.weight.view(-1, *extend_dims),
+                self.bias.view(-1, *extend_dims),
+                self.eps,
+            )
+
+        elif self.data_format == "channels_last":
+            return F.layer_norm(
+                x, (self.n_channels,), self.weight, self.bias, self.eps.item()
+            )
+
+        else:
+            raise NotImplementedError
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(n_channels={self.n_channels}, {self.data_format})"

neucodec/model.py

@@ -0,0 +1,218 @@
+from typing import Optional, Dict
+from pathlib import Path
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchaudio
+from torchaudio import transforms as T
+from huggingface_hub import PyTorchModelHubMixin, ModelHubMixin, hf_hub_download
+from transformers import AutoFeatureExtractor, HubertModel, Wav2Vec2BertModel
+
+from .codec_encoder import CodecEncoder
+from .codec_encoder_distill import DistillCodecEncoder
+from .codec_decoder_vocos import CodecDecoderVocos
+from .module import SemanticEncoder
+
+
+class NeuCodec(
+    nn.Module,
+    PyTorchModelHubMixin,
+    repo_url="https://github.com/neuphonic/neucodec",
+    license="apache-2.0",
+):
+
+    def __init__(self, sample_rate: int, hop_length: int, decoder_depth: int = 12):
+        super().__init__()
+        self.sample_rate = sample_rate
+        self.hop_length = hop_length
+        self.semantic_model = Wav2Vec2BertModel.from_pretrained(
+            "facebook/w2v-bert-2.0", output_hidden_states=True
+        )
+        self.feature_extractor = AutoFeatureExtractor.from_pretrained(
+            "facebook/w2v-bert-2.0"
+        )
+        self.SemanticEncoder_module = SemanticEncoder(1024, 1024, 1024)
+        self.CodecEnc = CodecEncoder()
+        self.generator = CodecDecoderVocos(hop_length=hop_length, depth=decoder_depth)
+        self.fc_prior = nn.Linear(2048, 2048)
+        self.fc_post_a = nn.Linear(2048, 1024)
+
+    @property
+    def device(self):
+        return next(self.parameters()).device
+
+    @classmethod
+    def _from_pretrained(
+        cls,
+        *,
+        model_id: str = None,
+        revision: Optional[str] = None,
+        cache_dir: Optional[str] = None,
+        force_download: bool = False,
+        proxies: Optional[Dict] = None,
+        resume_download: bool = False,
+        local_files_only: bool = False,
+        token: Optional[str] = None,
+        map_location: str = "cpu",
+        strict: bool = False,
+        local_ckpt_path: str = None,
+        **model_kwargs,
+    ):
+        if model_id == "neuphonic/neucodec":
+            ignore_keys = ["fc_post_s", "SemanticDecoder"]
+        elif model_id == "neuphonic/distill-neucodec":
+            ignore_keys = []
+        else:
+            ignore_keys = []
+
+        if model_id is not None:
+            ckpt_path = hf_hub_download(
+                repo_id=model_id,
+                filename="pytorch_model.bin",
+                revision=revision,
+                cache_dir=cache_dir,
+                force_download=force_download,
+                proxies=proxies,
+                resume_download=resume_download,
+                local_files_only=local_files_only,
+                token=token,
+            )
+        else:
+            # incase we interpolate the weight to become 960 instead train from scratch 
+            ckpt_path = local_ckpt_path
+
+        # initialize model
+        decoder_depth = model_kwargs.pop('decoder_depth', 12)
+        model = cls(44_100, 882, decoder_depth=decoder_depth)
+
+        # load weights
+        state_dict = torch.load(ckpt_path, map_location)
+        contains_list = lambda s, l: any(i in s for i in l)
+        state_dict = {
+            k:v for k, v in state_dict.items() 
+            if not contains_list(k, ignore_keys)
+        }
+
+        # Filter out keys with shape mismatches (e.g. 48k model vs 24k checkpoint)
+        model_state = model.state_dict()
+        state_dict = {
+            k: v for k, v in state_dict.items()
+            if k in model_state and v.shape == model_state[k].shape
+        }
+
+        model.load_state_dict(state_dict, strict=False)
+
+        return model
+    
+    def _prepare_audio(self, audio_or_path: torch.Tensor | Path | str):
+        
+        # load from file
+        if isinstance(audio_or_path, (Path, str)):
+            y, sr = torchaudio.load(audio_or_path)
+            if sr != 16_000:
+                y, sr = (T.Resample(sr, 16_000)(y), 16_000)
+                y = y[None, :]  # [1, T] -> [B, 1, T]
+
+        # ensure input tensor is of correct shape
+        elif isinstance(audio_or_path, torch.Tensor):
+            y = audio_or_path
+            if len(y.shape) == 3:
+                y = audio_or_path
+            else:
+                raise ValueError(
+                    f"NeuCodec expects tensor audio input to be of shape [B, 1, T] -- received shape: {y.shape}"
+                )
+
+        # pad audio
+        pad_for_wav = 320 - (y.shape[-1] % 320)
+        y = torch.nn.functional.pad(y, (0, pad_for_wav))
+        
+        return y
+        
+    def encode_code(self, audio_or_path: torch.Tensor | Path | str) -> torch.Tensor:
+        """
+        Args:
+            audio_or_path: torch.Tensor [B, 1, T] | Path | str, input audio
+
+        Returns:
+            fsq_codes: torch.Tensor [B, 1, F], 50hz FSQ codes
+        """
+         
+        # prepare inputs
+        y = self._prepare_audio(audio_or_path)
+        semantic_features = self.feature_extractor(
+            [w for w in y.squeeze(1).cpu()], sampling_rate=16_000, return_tensors="pt"
+        ).input_features.to(self.device)
+
+        # acoustic encoding
+        acoustic_emb = self.CodecEnc(y.to(self.device))
+        acoustic_emb = acoustic_emb.transpose(1, 2)
+
+        # semantic encoding
+        semantic_output = (
+            self.semantic_model(semantic_features).hidden_states[16].transpose(1, 2)
+        )
+        semantic_encoded = self.SemanticEncoder_module(semantic_output)
+
+        # concatenate embeddings
+        if acoustic_emb.shape[-1] != semantic_encoded.shape[-1]:
+            min_len = min(acoustic_emb.shape[-1], semantic_encoded.shape[-1])
+            acoustic_emb = acoustic_emb[:, :, :min_len]
+            semantic_encoded = semantic_encoded[:, :, :min_len]        
+        concat_emb = torch.cat([semantic_encoded, acoustic_emb], dim=1)
+        concat_emb = self.fc_prior(concat_emb.transpose(1, 2)).transpose(1, 2)
+
+        # quantize
+        _, fsq_codes, _ = self.generator(concat_emb, vq=True)
+        return fsq_codes
+
+    def encode_code_from_features(self, audio: torch.Tensor, semantic_features: torch.Tensor) -> torch.Tensor:
+        """Encode using pre-computed semantic features, avoiding CPU feature extraction.
+
+        Args:
+            audio: torch.Tensor [B, 1, T], 16kHz input audio
+            semantic_features: torch.Tensor [B, seq_len, feat_dim], pre-computed features
+
+        Returns:
+            fsq_codes: torch.Tensor [B, 1, F], 50hz FSQ codes
+        """
+        y = self._prepare_audio(audio)
+        semantic_features = semantic_features.to(self.device)
+
+        # acoustic encoding
+        acoustic_emb = self.CodecEnc(y.to(self.device))
+        acoustic_emb = acoustic_emb.transpose(1, 2)
+
+        # semantic encoding
+        semantic_output = (
+            self.semantic_model(semantic_features).hidden_states[16].transpose(1, 2)
+        )
+        semantic_encoded = self.SemanticEncoder_module(semantic_output)
+
+        # concatenate embeddings
+        if acoustic_emb.shape[-1] != semantic_encoded.shape[-1]:
+            min_len = min(acoustic_emb.shape[-1], semantic_encoded.shape[-1])
+            acoustic_emb = acoustic_emb[:, :, :min_len]
+            semantic_encoded = semantic_encoded[:, :, :min_len]
+        concat_emb = torch.cat([semantic_encoded, acoustic_emb], dim=1)
+        concat_emb = self.fc_prior(concat_emb.transpose(1, 2)).transpose(1, 2)
+
+        # quantize
+        _, fsq_codes, _ = self.generator(concat_emb, vq=True)
+        return fsq_codes
+
+    def decode_code(self, fsq_codes: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            fsq_codes: torch.Tensor [B, 1, F], 50hz FSQ codes
+
+        Returns:
+            recon: torch.Tensor [B, 1, T], reconstructed 48kHz audio
+        """
+
+        fsq_post_emb = self.generator.quantizer.get_output_from_indices(fsq_codes.transpose(1, 2))
+        fsq_post_emb = fsq_post_emb.transpose(1, 2)
+        fsq_post_emb = self.fc_post_a(fsq_post_emb.transpose(1, 2)).transpose(1, 2) 
+        recon = self.generator(fsq_post_emb.transpose(1, 2), vq=False)[0]
+        return recon

neucodec/module.py

@@ -0,0 +1,102 @@
+import torch.nn as nn
+
+from torch.nn.utils import weight_norm
+
+from .activations import SnakeBeta
+from .alias_free_torch import Activation1d
+
+
+def WNConv1d(*args, **kwargs):
+    return weight_norm(nn.Conv1d(*args, **kwargs))
+
+
+class ResidualUnit(nn.Module):
+    def __init__(self, dim: int = 16, dilation: int = 1):
+        super().__init__()
+        pad = ((7 - 1) * dilation) // 2
+        self.block = nn.Sequential(
+            Activation1d(activation=SnakeBeta(dim, alpha_logscale=True)),
+            WNConv1d(dim, dim, kernel_size=7, dilation=dilation, padding=pad),
+            Activation1d(activation=SnakeBeta(dim, alpha_logscale=True)),
+            WNConv1d(dim, dim, kernel_size=1),
+        )
+
+    def forward(self, x):
+        return x + self.block(x)
+
+
+class EncoderBlock(nn.Module):
+    def __init__(self, dim: int = 16, stride: int = 1, dilations=(1, 3, 9)):
+        super().__init__()
+        runits = [ResidualUnit(dim // 2, dilation=d) for d in dilations]
+        self.block = nn.Sequential(
+            *runits,
+            Activation1d(activation=SnakeBeta(dim // 2, alpha_logscale=True)),
+            WNConv1d(
+                dim // 2,
+                dim,
+                kernel_size=2 * stride,
+                stride=stride,
+                padding=stride // 2 + stride % 2,
+            ),
+        )
+
+    def forward(self, x):
+        return self.block(x)
+
+
+class SemanticEncoder(nn.Module):
+    def __init__(
+        self,
+        input_channels: int,
+        code_dim: int,
+        encode_channels: int,
+        kernel_size: int = 3,
+        bias: bool = True,
+    ):
+        super(SemanticEncoder, self).__init__()
+
+        self.initial_conv = nn.Conv1d(
+            in_channels=input_channels,
+            out_channels=encode_channels,
+            kernel_size=kernel_size,
+            stride=1,
+            padding=(kernel_size - 1) // 2,
+            bias=False,
+        )
+
+        self.residual_blocks = nn.Sequential(
+            nn.ReLU(inplace=True),
+            nn.Conv1d(
+                encode_channels,
+                encode_channels,
+                kernel_size=kernel_size,
+                stride=1,
+                padding=(kernel_size - 1) // 2,
+                bias=bias,
+            ),
+            nn.ReLU(inplace=True),
+            nn.Conv1d(
+                encode_channels,
+                encode_channels,
+                kernel_size=kernel_size,
+                stride=1,
+                padding=(kernel_size - 1) // 2,
+                bias=bias,
+            ),
+        )
+
+        self.final_conv = nn.Conv1d(
+            in_channels=encode_channels,
+            out_channels=code_dim,
+            kernel_size=kernel_size,
+            stride=1,
+            padding=(kernel_size - 1) // 2,
+            bias=False,
+        )
+
+    def forward(self, x):
+        x = self.initial_conv(x)  # (Batch, Encode_channels, Length)
+        x = self.residual_blocks(x) + x  # 残差连接
+        x = self.final_conv(x)  # (Batch, Code_dim, Length)
+        return x

neucodec/tconv/base.py

@@ -0,0 +1,92 @@
+import einops
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+from ..distill_layers import Conv1d
+
+
+def trend_pool(x, kernel_size):
+    if kernel_size > 1:
+        pool_args = dict(kernel_size=kernel_size, stride=1, padding=kernel_size // 2)
+        return F.avg_pool1d(F.max_pool1d(x.abs(), **pool_args), **pool_args)
+        # return F.avg_pool1d(F.max_pool1d(x, **pool_args), **pool_args)  # woabs
+    else:
+        return x
+
+
+class TrendPool(nn.Module):
+    def __init__(self, kernel_size=5):
+        super().__init__()
+        self.kernel_size = kernel_size
+
+    def forward(self, x):
+        return trend_pool(x, self.kernel_size)
+
+
+class FirstBlock(nn.Module):
+    def __init__(
+        self,
+        target_dim,
+        conv_kernels=(7, 7, 7, 7),
+        pool_kernels=(1, 3, 5, 9),
+        dilation_rate=2,
+    ):
+        super().__init__()
+        assert target_dim % len(pool_kernels) == 0
+        each_dim = target_dim // len(pool_kernels)
+        blocks = []
+        for conv_kernel, pool_kernel in zip(conv_kernels, pool_kernels):
+            conv_dilation = pool_kernel // dilation_rate + 1
+            conv_padding = (conv_kernel - 1) * conv_dilation // 2
+            blocks.append(
+                nn.Sequential(
+                    TrendPool(pool_kernel),
+                    Conv1d(
+                        1,
+                        each_dim,
+                        kernel_size=conv_kernel,
+                        dilation=conv_dilation,
+                        padding=conv_padding,
+                    ),
+                )
+            )
+        self.blocks = nn.ModuleList(blocks)
+
+    def forward(self, x):
+        return torch.cat([block(x) for block in self.blocks], dim=1)
+
+
+class EnhanceBlock(FirstBlock):
+    def __init__(self, dim):
+        super().__init__(4, conv_kernels=(7, 7, 7, 7), pool_kernels=(1, 3, 5, 9))
+        self.dim = dim
+        self.merge_layer = nn.Sequential(
+            # nn.LeakyReLU(),  # ! if active or use InstanceNorm1d
+            nn.InstanceNorm1d(4, affine=True),
+            nn.Conv1d(4, 1, kernel_size=1),
+        )
+
+    def forward(self, x):
+        x = einops.rearrange(x, "b c t -> (b c) 1 t", c=self.dim)
+        y = super().forward(x)
+        y = self.merge_layer(y)
+        y = einops.rearrange(y, "(b c) 1 t -> b c t", c=self.dim)
+        return y  # ! x + y or x + y * x
+
+
+class SimpleEnhanceBlock(FirstBlock):
+    def __init__(self, dim):
+        super().__init__(4, conv_kernels=(7, 7, 7, 7), pool_kernels=(1, 3, 5, 9))
+        self.dim = dim
+        self.merge_layer = nn.Sequential(
+            # nn.LeakyReLU(),  # ! if active or use InstanceNorm1d
+            nn.InstanceNorm1d(4, affine=True),
+            nn.Conv1d(4, self.dim, kernel_size=1),
+        )
+
+    def forward(self, x):
+        xi = x[:, :1, :]
+        yi = super().forward(xi)
+        y = self.merge_layer(yi)
+        return x + y * x

neucodec/tconv/t_first.py

@@ -0,0 +1,38 @@
+import torch
+from torch import nn
+
+from ..distill_layers import Conv1d
+from . import base
+
+
+class V3FirstBlock(base.FirstBlock):  # (1, 5, 11, 21, 45)
+    def __init__(
+        self,
+        target_dim,
+        conv_kernels=(7, 7, 7, 7, 7),
+        pool_kernels=(1, 5, 11, 21, 45),
+        dilation_rate=7,
+    ):
+        h_dim = len(pool_kernels) * 4
+        super().__init__(h_dim, conv_kernels, pool_kernels, dilation_rate=dilation_rate)
+        self.conv_1 = Conv1d(h_dim, h_dim * 4, kernel_size=1)
+        self.act = nn.GELU()
+        self.conv_2 = Conv1d(h_dim * 4 + 1, target_dim, kernel_size=1)
+
+    def forward(self, x):
+        h = super().forward(x)
+        h = self.conv_1(h)
+        h = self.act(h)
+        y = torch.cat([h, x], dim=1)
+        y = self.conv_2(y)
+        return y
+
+
+FirstBlock = lambda dim: (
+    V3FirstBlock(
+        dim,
+        conv_kernels=(7, 7, 7, 7, 7),
+        pool_kernels=(1, 5, 11, 21, 45),
+        dilation_rate=99,
+    )  # fv36
+)

neucodec/token_interpolator.py

@@ -0,0 +1,112 @@
+"""
+TokenInterpolator: Upsample low-rate (25/12 TPS) token embeddings back to 50 TPS.
+
+The original 50 TPS NeuCodec codebook is completely frozen and unchanged.
+This module operates purely in embedding space (after quantizer lookup).
+
+Encode at 25 TPS:
+    audio -> NeuCodec.encode_code() -> 50 TPS codes [B, 1, T]
+          -> take every 2nd token   -> 25 TPS codes [B, 1, T//2]
+
+Decode from 25 TPS:
+    25 TPS codes -> quantizer.get_output_from_indices -> 25 TPS embeddings [B, T//2, 1024]
+                -> TokenInterpolator(factor=2) -> 50 TPS embeddings [B, T, 1024]
+                -> NeuCodec decoder backbone + ISTFT -> audio
+
+Training:
+    Freeze entire NeuCodec. Only train TokenInterpolator.
+    Loss: MSE on the predicted (odd-position) embeddings vs the true 50 TPS embeddings.
+    Optional: reconstruction loss via frozen decoder.
+"""
+
+import torch
+import torch.nn as nn
+from torchtune.modules import RotaryPositionalEmbeddings
+from .bs_roformer5 import TransformerBlock
+
+
+class TokenInterpolator(nn.Module):
+    """
+    Upsamples from low-rate token embeddings to 50 TPS embeddings.
+
+    Args:
+        dim:    embedding dimension (1024, matching fc_post_a output)
+        factor: upsample factor — 2 for 25->50 TPS, 4 for 12->50 TPS
+        depth:  number of transformer layers
+        heads:  attention heads
+    """
+
+    def __init__(self, dim: int = 1024, factor: int = 2, depth: int = 4, heads: int = 8):
+        super().__init__()
+        assert factor in (2, 4), "factor must be 2 (25 TPS) or 4 (12 TPS)"
+        self.factor = factor
+        self.dim = dim
+
+        # Learned sub-position embeddings to distinguish slots within each group.
+        # e.g. factor=2: slot 0 = known token, slot 1 = to be predicted.
+        self.sub_pos_embed = nn.Embedding(factor, dim)
+
+        rotary_embed = RotaryPositionalEmbeddings(dim=64)
+        self.transformer = nn.Sequential(*[
+            TransformerBlock(dim=dim, n_heads=heads, rotary_embed=rotary_embed)
+            for _ in range(depth)
+        ])
+        self.norm = nn.LayerNorm(dim)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            x: [B, T_low, dim]  — embeddings at 25 or 12 TPS
+
+        Returns:
+            out: [B, T_low * factor, dim]  — embeddings at 50 TPS
+        """
+        B, T, D = x.shape
+
+        # Repeat each embedding `factor` times along time axis
+        # [B, T, D] -> [B, T, factor, D] -> [B, T*factor, D]
+        x = x.unsqueeze(2).expand(B, T, self.factor, D).reshape(B, T * self.factor, D)
+
+        # Add sub-position embedding so the model knows which slot it's filling.
+        # sub_idx: [0,1,0,1,...] for factor=2; [0,1,2,3,0,1,2,3,...] for factor=4
+        sub_idx = torch.arange(self.factor, device=x.device).repeat(T)  # [T*factor]
+        x = x + self.sub_pos_embed(sub_idx)  # broadcast over batch
+
+        x = self.transformer(x)
+        x = self.norm(x)
+        return x  # [B, T*factor, D]
+
+
+def encode_low_rate(neucodec, audio, factor: int = 2) -> torch.Tensor:
+    """
+    Encode audio to low-rate codes.
+
+    Returns:
+        codes: [B, 1, T//factor]  integer token indices
+    """
+    codes = neucodec.encode_code(audio)          # [B, 1, T] at 50 TPS
+    codes = codes[:, :, ::factor]                # [B, 1, T//factor]
+    return codes
+
+
+def decode_low_rate(neucodec, interpolator: TokenInterpolator, codes: torch.Tensor) -> torch.Tensor:
+    """
+    Decode low-rate codes back to 48kHz audio via interpolation.
+
+    Args:
+        codes: [B, 1, T_low]  — 25 or 12 TPS codes
+
+    Returns:
+        audio: [B, 1, T_audio]  — 48kHz audio
+    """
+    # 1. Lookup embeddings for the known tokens [B, T_low, 2048]
+    emb = neucodec.generator.quantizer.get_output_from_indices(codes.transpose(1, 2))
+    # 2. Project to 1024-dim space [B, T_low, 1024]
+    emb = neucodec.fc_post_a(emb)
+
+    # 3. Interpolate to 50 TPS [B, T_high, 1024]
+    emb = interpolator(emb)
+
+    # 4. Decode with existing frozen backbone + ISTFT
+    audio, _ = neucodec.generator(emb, vq=False)
+    return audio

pytorch_model.bin

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

samples/boboiboy/boboiboy-after.wav

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

samples/common-voice/after/ab_recon44k_d20.wav

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

samples/common-voice/after/af_recon44k_d20.wav

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

samples/common-voice/after/am_recon44k_d20.wav

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

samples/common-voice/after/ar_recon44k_d20.wav

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

samples/common-voice/after/as_recon44k_d20.wav

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

samples/common-voice/after/ast_recon44k_d20.wav

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

samples/common-voice/after/az_recon44k_d20.wav

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

samples/common-voice/after/ba_recon44k_d20.wav

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

samples/common-voice/after/bas_recon44k_d20.wav

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

samples/common-voice/after/be_recon44k_d20.wav

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

samples/common-voice/after/bg_recon44k_d20.wav

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

samples/common-voice/after/bn_recon44k_d20.wav

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

samples/common-voice/after/br_recon44k_d20.wav

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

samples/common-voice/after/ca_recon44k_d20.wav

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

samples/common-voice/after/ckb_recon44k_d20.wav

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

samples/common-voice/after/cnh_recon44k_d20.wav

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

samples/common-voice/after/cs_recon44k_d20.wav

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

samples/common-voice/after/cv_recon44k_d20.wav

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

samples/common-voice/after/cy_recon44k_d20.wav

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

samples/common-voice/after/da_recon44k_d20.wav

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

samples/common-voice/after/dav_recon44k_d20.wav

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

samples/common-voice/after/de_recon44k_d20.wav

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

samples/common-voice/after/dv_recon44k_d20.wav

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

samples/common-voice/after/dyu_recon44k_d20.wav

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

samples/common-voice/after/el_recon44k_d20.wav

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