diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..8b34e9e7234ced9f83a5ad90fbb153b36a79e3ce 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,20 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +data/data-bin/train.mni_Beng-eng_Latn.eng_Latn.idx filter=lfs diff=lfs merge=lfs -text +data/data-bin/train.mni_Beng-eng_Latn.mni_Beng.idx filter=lfs diff=lfs merge=lfs -text +data/fairseq/alignment_train_cpu_binding.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +data/fairseq/docs/fairseq.gif filter=lfs diff=lfs merge=lfs -text +data/fairseq/examples/MMPT/vlm.png filter=lfs diff=lfs merge=lfs -text +data/fairseq/examples/MMPT/videoclip.png filter=lfs diff=lfs merge=lfs -text +data/fairseq/examples/hubert/tests/6313-76958-0021.flac filter=lfs diff=lfs merge=lfs -text +data/fairseq/examples/textless_nlp/speech-resynth/img/fig.png filter=lfs diff=lfs merge=lfs -text +data/fairseq/fairseq/libbleu.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +data/fairseq/fairseq/libbase.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +data/fairseq/fairseq/libnat.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +data/fairseq/fairseq/data/data_utils_fast.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +data/fairseq/fairseq/data/token_block_utils_fast.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +.ipython/profile_default/history.sqlite filter=lfs diff=lfs merge=lfs -text +nllb-mni-lsftl/checkpoint-26112/tokenizer.json filter=lfs diff=lfs merge=lfs -text +data-bin/train.eng_Latn-mni_Beng.mni_Beng.idx filter=lfs diff=lfs merge=lfs -text +data-bin/train.eng_Latn-mni_Beng.eng_Latn.idx filter=lfs diff=lfs merge=lfs -text diff --git a/.ipython/profile_default/history.sqlite b/.ipython/profile_default/history.sqlite new file mode 100644 index 0000000000000000000000000000000000000000..8d80f19a23844b08ffba27b93900be3b1b6014bb --- /dev/null +++ b/.ipython/profile_default/history.sqlite @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2df9221c1acdbb269ec8f884d3ce00aa5bff2cf29e713cff62f8600873e967e7 +size 196608 diff --git a/checkpoints/checkpoint1.pt b/checkpoints/checkpoint1.pt new file mode 100644 index 0000000000000000000000000000000000000000..490c70a83e42945bf4d86f8371e15f10ec07a217 --- /dev/null +++ b/checkpoints/checkpoint1.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f85ee129aa2f584ba4ff6e1d711f2124847b2a054f32256bf5dad961575c9e33 +size 2540407244 diff --git a/checkpoints/checkpoint10.pt b/checkpoints/checkpoint10.pt new file mode 100644 index 0000000000000000000000000000000000000000..69e56eaa88e992ab931df5aa142845f76633171b --- /dev/null +++ b/checkpoints/checkpoint10.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:53c420d876317de12d404bd96432156506a84f45d0047868ca53631d46c1925f +size 2540407308 diff --git a/checkpoints/checkpoint11.pt b/checkpoints/checkpoint11.pt new file mode 100644 index 0000000000000000000000000000000000000000..f790e1cd29335f4768ea64243079b4c3a06f634b --- /dev/null +++ b/checkpoints/checkpoint11.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8e3d68b2ec0d2ee1193f0d0ffd418eacd5fe0a7bff26fe71774ec271e2f7cfa6 +size 2540407308 diff --git a/checkpoints/checkpoint12.pt b/checkpoints/checkpoint12.pt new file mode 100644 index 0000000000000000000000000000000000000000..809753b127266e05176efe3c75c66387f2875418 --- /dev/null +++ b/checkpoints/checkpoint12.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5023db973ec2351924003e7bb627ab7c48c8bcd8f5016ad41de37966a9c3f4b6 +size 2540407308 diff --git a/checkpoints/checkpoint13.pt b/checkpoints/checkpoint13.pt new file mode 100644 index 0000000000000000000000000000000000000000..3e23a18557c00072a58e006e2bf5481647754ecd --- /dev/null +++ b/checkpoints/checkpoint13.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b335b2ab6dcebf2242d98cdb5767851fda383c78a2165e0a70e97a797ba42b6 +size 2540407308 diff --git a/checkpoints/checkpoint14.pt b/checkpoints/checkpoint14.pt new file mode 100644 index 0000000000000000000000000000000000000000..5c21cd59d8c32321cab2a48fc00d180cc9d21355 --- /dev/null +++ b/checkpoints/checkpoint14.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e6ee1bdd7b073ac7d28c3ec1f8b00ef73d3a4ede6bb6510d469f5caca07c2de4 +size 2540407308 diff --git a/checkpoints/checkpoint15.pt b/checkpoints/checkpoint15.pt new file mode 100644 index 0000000000000000000000000000000000000000..17d0af0d3255b1fd03ebcfadaaa005a449fb8444 --- /dev/null +++ b/checkpoints/checkpoint15.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3cfdbeef92c7071441a6c13a7f8c1aa4ecc172a78179343e222769f5903c5fde +size 2540407308 diff --git a/checkpoints/checkpoint16.pt b/checkpoints/checkpoint16.pt new file mode 100644 index 0000000000000000000000000000000000000000..2d5ed1e1d7f1a4134c772a9c166d6904d864eb02 --- /dev/null +++ b/checkpoints/checkpoint16.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dde6a406f86c784e72a2316cdd56916642eb798344400fc54a22426920e700c8 +size 2540407308 diff --git a/checkpoints/checkpoint17.pt b/checkpoints/checkpoint17.pt new file mode 100644 index 0000000000000000000000000000000000000000..cca9391f7cecf0caa40d78ddb073e0a625433789 --- /dev/null +++ b/checkpoints/checkpoint17.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:25b8203eaa0b76cc5c9aec77ab399a2011a59d334f6c0526551f682b8f82b594 +size 2540407308 diff --git a/checkpoints/checkpoint18.pt b/checkpoints/checkpoint18.pt new file mode 100644 index 0000000000000000000000000000000000000000..4ededdfdc28e170ec86f413dae6cbf8531af00b8 --- /dev/null +++ b/checkpoints/checkpoint18.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6b3104bae231af180d20c56cc3ff89ddfe903ae8bfbc92579bde64edda3ecf0e +size 2540407308 diff --git a/checkpoints/checkpoint19.pt b/checkpoints/checkpoint19.pt new file mode 100644 index 0000000000000000000000000000000000000000..dfde4aa302ccf745a30a10d247876030ab1509a2 --- /dev/null +++ b/checkpoints/checkpoint19.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:be618b9804a4c5a6ac2aa36a5de5883b6e3f28009d6d468f74e8b48474fd1020 +size 2540407308 diff --git a/checkpoints/checkpoint2.pt b/checkpoints/checkpoint2.pt new file mode 100644 index 0000000000000000000000000000000000000000..d75ff6d98e375af57db936eaa0084b0f7e9aa61a --- /dev/null +++ b/checkpoints/checkpoint2.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b336d6a7946252e3fe40dc6cb0d914f8eb0206daf951dc606baf7bc964c1aa06 +size 2540407308 diff --git a/checkpoints/checkpoint20.pt b/checkpoints/checkpoint20.pt new file mode 100644 index 0000000000000000000000000000000000000000..1125b78b12780d4bc888fa361107d1e18e408db0 --- /dev/null +++ b/checkpoints/checkpoint20.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:61d33d371edefa81765a400e8916186753d39f5f6a710652bee3b7ff3a5cf54f +size 2540407308 diff --git a/checkpoints/checkpoint3.pt b/checkpoints/checkpoint3.pt new file mode 100644 index 0000000000000000000000000000000000000000..09f9ca08cf1cdee36af80f78f53da6fa8922710f --- /dev/null +++ b/checkpoints/checkpoint3.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1f07fb795a4d4ede0cc2ba9df5c862a4b3ad163a6f6aed0755f925188214c66a +size 2540407308 diff --git a/checkpoints/checkpoint4.pt b/checkpoints/checkpoint4.pt new file mode 100644 index 0000000000000000000000000000000000000000..9f05ed599ec08c4772bf0b27280811f34a4fa48e --- /dev/null +++ b/checkpoints/checkpoint4.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0bdca15d26d0677f5195a2841f3bf4eb031e190b5c4f27344b8c709be9e5b95d +size 2540407308 diff --git a/checkpoints/checkpoint5.pt b/checkpoints/checkpoint5.pt new file mode 100644 index 0000000000000000000000000000000000000000..0055162a4bd92b1cebd73d76fb2beeb7d2a82556 --- /dev/null +++ b/checkpoints/checkpoint5.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d404ae9e8bfa8e464b692be33fe848d837f30bed0ffc89bca21fa137d6092d34 +size 2540407308 diff --git a/checkpoints/checkpoint6.pt b/checkpoints/checkpoint6.pt new file mode 100644 index 0000000000000000000000000000000000000000..bd4a7b16748a3d495f6e44efdf5e4e8cc80b61ca --- /dev/null +++ b/checkpoints/checkpoint6.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f353aeb220e3684bcb394e11f4f61c632fcdacf4551376932f7ed9ba448a6e9b +size 2540407308 diff --git a/checkpoints/checkpoint7.pt b/checkpoints/checkpoint7.pt new file mode 100644 index 0000000000000000000000000000000000000000..a9e206ae788597216ad67487b2e4a08c67044e6a --- /dev/null +++ b/checkpoints/checkpoint7.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dc4cbf60282c3beab51e46537826af5ea9878d96f7da978be8e60da9642add52 +size 2540407308 diff --git a/checkpoints/checkpoint8.pt b/checkpoints/checkpoint8.pt new file mode 100644 index 0000000000000000000000000000000000000000..5bd3e77c4ab9d8fcc65fcee212f9f229977e6bff --- /dev/null +++ b/checkpoints/checkpoint8.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fa6207b478e2f6644eb0eb6b46b2f3ff37b1a89081f246e835774614cd0e4ed6 +size 2540407308 diff --git a/checkpoints/checkpoint9.pt b/checkpoints/checkpoint9.pt new file mode 100644 index 0000000000000000000000000000000000000000..0982cab28edf655f0db343fbfeb33c4b92d3d6d2 --- /dev/null +++ b/checkpoints/checkpoint9.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e8c5f464a6b7d1a79401f64b8acd514e57a73641ca33befc708fbb8fb186c627 +size 2540407308 diff --git a/checkpoints/checkpoint_best.pt b/checkpoints/checkpoint_best.pt new file mode 100644 index 0000000000000000000000000000000000000000..1125b78b12780d4bc888fa361107d1e18e408db0 --- /dev/null +++ b/checkpoints/checkpoint_best.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:61d33d371edefa81765a400e8916186753d39f5f6a710652bee3b7ff3a5cf54f +size 2540407308 diff --git a/checkpoints/checkpoint_last.pt b/checkpoints/checkpoint_last.pt new file mode 100644 index 0000000000000000000000000000000000000000..1125b78b12780d4bc888fa361107d1e18e408db0 --- /dev/null +++ b/checkpoints/checkpoint_last.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:61d33d371edefa81765a400e8916186753d39f5f6a710652bee3b7ff3a5cf54f +size 2540407308 diff --git a/data-bin/test.eng_Latn-mni_Beng.eng_Latn.bin b/data-bin/test.eng_Latn-mni_Beng.eng_Latn.bin new file mode 100644 index 0000000000000000000000000000000000000000..99d10d27852d8c3f41f00579fc71769d2690e1c5 --- /dev/null +++ b/data-bin/test.eng_Latn-mni_Beng.eng_Latn.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c73197c70f5e62f29dd385a37612f1a5985b772807389f20341d4a68919b2036 +size 95492 diff --git a/data-bin/test.eng_Latn-mni_Beng.mni_Beng.bin b/data-bin/test.eng_Latn-mni_Beng.mni_Beng.bin new file mode 100644 index 0000000000000000000000000000000000000000..d2a30b9f69aba4ab890a277b21c2e5841d5fa278 --- /dev/null +++ b/data-bin/test.eng_Latn-mni_Beng.mni_Beng.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7d256d39506ed6357917b0953f865784dac822fc5ba68e4a7a053c88ba8c0ba0 +size 80120 diff --git a/data-bin/train.eng_Latn-mni_Beng.eng_Latn.bin b/data-bin/train.eng_Latn-mni_Beng.eng_Latn.bin new file mode 100644 index 0000000000000000000000000000000000000000..baffa7d04a884cceeec1f9a7e5a53a1011a0d75a --- /dev/null +++ b/data-bin/train.eng_Latn-mni_Beng.eng_Latn.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fa91a5fe810ad4a61983115dbe4a181b3ff526b2f758b48547c9850074788ac1 +size 11406672 diff --git a/data-bin/train.eng_Latn-mni_Beng.eng_Latn.idx b/data-bin/train.eng_Latn-mni_Beng.eng_Latn.idx new file mode 100644 index 0000000000000000000000000000000000000000..a2463e8063b2c1557e9ad95177e3c2cfcc103148 --- /dev/null +++ b/data-bin/train.eng_Latn-mni_Beng.eng_Latn.idx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:debccdfcd644f75811f67921e011ded1dc372de57b1080a1003a511d069e2481 +size 1671218 diff --git a/data-bin/train.eng_Latn-mni_Beng.mni_Beng.bin b/data-bin/train.eng_Latn-mni_Beng.mni_Beng.bin new file mode 100644 index 0000000000000000000000000000000000000000..7eb95e3ca1441b25b1d84c8f7c0041ba3fcedc31 --- /dev/null +++ b/data-bin/train.eng_Latn-mni_Beng.mni_Beng.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:350e5a813696f93c6f7ce2070597eba8a2f5b246bd0bec0dd17c52d930be5025 +size 9675092 diff --git a/data-bin/train.eng_Latn-mni_Beng.mni_Beng.idx b/data-bin/train.eng_Latn-mni_Beng.mni_Beng.idx new file mode 100644 index 0000000000000000000000000000000000000000..f8dde97a188ef4c31f8adf61463ffc3acb77b0cc --- /dev/null +++ b/data-bin/train.eng_Latn-mni_Beng.mni_Beng.idx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:805d0d4abbbda5d6ad89d8d9fe2bdd0998a523dda371d5e5c16a188b330f7168 +size 1671218 diff --git a/data-bin/valid.eng_Latn-mni_Beng.eng_Latn.bin b/data-bin/valid.eng_Latn-mni_Beng.eng_Latn.bin new file mode 100644 index 0000000000000000000000000000000000000000..47f89c487ea7715b22fcefbb6d2d4dfe84b52335 --- /dev/null +++ b/data-bin/valid.eng_Latn-mni_Beng.eng_Latn.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:09c9c60b5ac448f168203bc4e2070f649ff83048d421f320bebcb7156df70667 +size 195996 diff --git a/data-bin/valid.eng_Latn-mni_Beng.mni_Beng.bin b/data-bin/valid.eng_Latn-mni_Beng.mni_Beng.bin new file mode 100644 index 0000000000000000000000000000000000000000..04f9f84de94b8c957913ca2580e53a82678462aa --- /dev/null +++ b/data-bin/valid.eng_Latn-mni_Beng.mni_Beng.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f76ac663203619de060fa8b093abd1a2b81f4ad12a00173c5be64fd4f5d3cf1b +size 165404 diff --git a/data/checkpoints/checkpoint1.pt b/data/checkpoints/checkpoint1.pt new file mode 100644 index 0000000000000000000000000000000000000000..775b168e8ae9473b991a647a7b5a875c016066b4 --- /dev/null +++ b/data/checkpoints/checkpoint1.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab7931ec1e085750994f83a752711ef9e323160568be7d254b9f649f84e343de +size 2374486476 diff --git a/data/checkpoints/checkpoint10.pt b/data/checkpoints/checkpoint10.pt new file mode 100644 index 0000000000000000000000000000000000000000..524dd36e7222501093c331d01ebdc083b05f9549 --- /dev/null +++ b/data/checkpoints/checkpoint10.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a6f2da37e59e5fbfcac2a9421237fe901358c6a749ff71d82a874630cd93ce0a +size 2374486540 diff --git a/data/checkpoints/checkpoint11.pt b/data/checkpoints/checkpoint11.pt new file mode 100644 index 0000000000000000000000000000000000000000..34986f7bd65dbde9c4506d0a25606badfc08c352 --- /dev/null +++ b/data/checkpoints/checkpoint11.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8180ac82006304e710241b0aaafc40a2c890b036c69933b558aae87153438502 +size 2374486540 diff --git a/data/checkpoints/checkpoint12.pt b/data/checkpoints/checkpoint12.pt new file mode 100644 index 0000000000000000000000000000000000000000..6b1ca9ad2b4c85c8aa9941928975cd4da32fc6d4 --- /dev/null +++ b/data/checkpoints/checkpoint12.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d8da2405ba9607f5a7ea9e9b005a3fac47022f60d0d438b6568bb32b392575be +size 2374486540 diff --git a/data/checkpoints/checkpoint13.pt b/data/checkpoints/checkpoint13.pt new file mode 100644 index 0000000000000000000000000000000000000000..4dce267af86053964d32c4793a59980444704691 --- /dev/null +++ b/data/checkpoints/checkpoint13.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:489412883e66764442f5a45d7ffabc70a0678a98f3478160aa3e6f94b5e92aa6 +size 2374486540 diff --git a/data/checkpoints/checkpoint14.pt b/data/checkpoints/checkpoint14.pt new file mode 100644 index 0000000000000000000000000000000000000000..0aa96bc31623c1388b6332a41f39b058f2c1c5d3 --- /dev/null +++ b/data/checkpoints/checkpoint14.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9f0d2dd66e8329ab8a054cace3330be000c3bb82d0758ba0b81d9a116e82e24 +size 2374486540 diff --git a/data/checkpoints/checkpoint15.pt b/data/checkpoints/checkpoint15.pt new file mode 100644 index 0000000000000000000000000000000000000000..214a11ef9ac411c5b00676adb82324ce0d141068 --- /dev/null +++ b/data/checkpoints/checkpoint15.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2bbe875313da8177dd3031a6d84685ce0a63e6148cbaf001890b82619625715a +size 2374486540 diff --git a/data/checkpoints/checkpoint16.pt b/data/checkpoints/checkpoint16.pt new file mode 100644 index 0000000000000000000000000000000000000000..21b36dba61f310ece0ea5a996f4d9798f3f43c47 --- /dev/null +++ b/data/checkpoints/checkpoint16.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1534052144b83ed97ff0919200a24c97d3a22f715224ee434a69a4c77edba22b +size 2374486540 diff --git a/data/checkpoints/checkpoint17.pt b/data/checkpoints/checkpoint17.pt new file mode 100644 index 0000000000000000000000000000000000000000..f400978eb2be5f73be0ef7ef80657bc19d32f424 --- /dev/null +++ b/data/checkpoints/checkpoint17.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d014694c7a170a3cc89a02e5c6cc69f11c635fe2f098d798e3c910cc9366aebf +size 2374486540 diff --git a/data/checkpoints/checkpoint18.pt b/data/checkpoints/checkpoint18.pt new file mode 100644 index 0000000000000000000000000000000000000000..b92a02fc1ba51de8fe084b89fd2566a905b58710 --- /dev/null +++ b/data/checkpoints/checkpoint18.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f57f2425e92909bd3d9d26120362327aba56687f16831d798acb1e5c4e0516d7 +size 2374486540 diff --git a/data/checkpoints/checkpoint19.pt b/data/checkpoints/checkpoint19.pt new file mode 100644 index 0000000000000000000000000000000000000000..cf79f843efc5668391362a12b3e6aed484dd391b --- /dev/null +++ b/data/checkpoints/checkpoint19.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8d698b16e3ed84ed2108d4af6260bdd05602c816a449074d485abbb59ce57d34 +size 2374486540 diff --git a/data/checkpoints/checkpoint2.pt b/data/checkpoints/checkpoint2.pt new file mode 100644 index 0000000000000000000000000000000000000000..5eb37b007a609b71de4aad293aaa76b42f0d3f6a --- /dev/null +++ b/data/checkpoints/checkpoint2.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7928ea217b725f33c796738c7942795159fc11fd6a40b44bdd068a6015cc2841 +size 2374486540 diff --git a/data/checkpoints/checkpoint3.pt b/data/checkpoints/checkpoint3.pt new file mode 100644 index 0000000000000000000000000000000000000000..9d2308804c66f4d8c60e2562eaa532f29c04b1c8 --- /dev/null +++ b/data/checkpoints/checkpoint3.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bf5e861dc8bbc71807b10f3bd769091a9974c07625110278ef7291fdff01e198 +size 2374486540 diff --git a/data/checkpoints/checkpoint4.pt b/data/checkpoints/checkpoint4.pt new file mode 100644 index 0000000000000000000000000000000000000000..dbe096d34650ed55b2d7a7133c7359cfa0905147 --- /dev/null +++ b/data/checkpoints/checkpoint4.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aac410a42903adb30dea2173b579864a4d15b3e88f47506758804cb3226ffbb6 +size 2374486540 diff --git a/data/checkpoints/checkpoint5.pt b/data/checkpoints/checkpoint5.pt new file mode 100644 index 0000000000000000000000000000000000000000..2bf801f740ce60e853f5773645c04b3ee2dee5e3 --- /dev/null +++ b/data/checkpoints/checkpoint5.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:973b9b6cace3b8e134972777679e37a57b4c406481680cfad0d343a3151ac0ef +size 2374486540 diff --git a/data/checkpoints/checkpoint6.pt b/data/checkpoints/checkpoint6.pt new file mode 100644 index 0000000000000000000000000000000000000000..397d96ec1bf70c8199215897f7ffd16bb1b7a817 --- /dev/null +++ b/data/checkpoints/checkpoint6.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ecb0cf3bf4081742c39776a73bc79143b16192584c8106889245a3aa7bc62c3 +size 2374486540 diff --git a/data/checkpoints/checkpoint7.pt b/data/checkpoints/checkpoint7.pt new file mode 100644 index 0000000000000000000000000000000000000000..c562fa436cc9515db8010d5b385fd37f8a79295a --- /dev/null +++ b/data/checkpoints/checkpoint7.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c867196a36be6c6734b61cb42c857d1f7feeedf92187f64441b75f49b6389fe6 +size 2374486540 diff --git a/data/checkpoints/checkpoint8.pt b/data/checkpoints/checkpoint8.pt new file mode 100644 index 0000000000000000000000000000000000000000..a873b06adcbe3711fa5720bfa644c1bd5ef89a76 --- /dev/null +++ b/data/checkpoints/checkpoint8.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9dd00724e0b901a6b9c47b5d4066ca0d738c930f2a48e8bc3a29d36590f9548d +size 2374486540 diff --git a/data/checkpoints/checkpoint9.pt b/data/checkpoints/checkpoint9.pt new file mode 100644 index 0000000000000000000000000000000000000000..52a608574fd4cc956a028fd7b7592593915a87e5 --- /dev/null +++ b/data/checkpoints/checkpoint9.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d543df884c11fbd94dfca15c6215fd3281a199d0343d7c3ba13d2b85d37b026c +size 2374486540 diff --git a/data/checkpoints/checkpoint_best.pt b/data/checkpoints/checkpoint_best.pt new file mode 100644 index 0000000000000000000000000000000000000000..c9a6e82b2ed9278729b39a320feaef70d066a2bf --- /dev/null +++ b/data/checkpoints/checkpoint_best.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e3361510c3efb318842eb60fc657c10d6d6ba8317acb38fc212f8dacd52efd20 +size 2374486540 diff --git a/data/checkpoints/checkpoint_last.pt b/data/checkpoints/checkpoint_last.pt new file mode 100644 index 0000000000000000000000000000000000000000..c9a6e82b2ed9278729b39a320feaef70d066a2bf --- /dev/null +++ b/data/checkpoints/checkpoint_last.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e3361510c3efb318842eb60fc657c10d6d6ba8317acb38fc212f8dacd52efd20 +size 2374486540 diff --git a/data/data-bin/test.mni_Beng-eng_Latn.eng_Latn.bin b/data/data-bin/test.mni_Beng-eng_Latn.eng_Latn.bin new file mode 100644 index 0000000000000000000000000000000000000000..99d10d27852d8c3f41f00579fc71769d2690e1c5 --- /dev/null +++ b/data/data-bin/test.mni_Beng-eng_Latn.eng_Latn.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c73197c70f5e62f29dd385a37612f1a5985b772807389f20341d4a68919b2036 +size 95492 diff --git a/data/data-bin/test.mni_Beng-eng_Latn.mni_Beng.bin b/data/data-bin/test.mni_Beng-eng_Latn.mni_Beng.bin new file mode 100644 index 0000000000000000000000000000000000000000..d2a30b9f69aba4ab890a277b21c2e5841d5fa278 --- /dev/null +++ b/data/data-bin/test.mni_Beng-eng_Latn.mni_Beng.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7d256d39506ed6357917b0953f865784dac822fc5ba68e4a7a053c88ba8c0ba0 +size 80120 diff --git a/data/data-bin/train.mni_Beng-eng_Latn.eng_Latn.bin b/data/data-bin/train.mni_Beng-eng_Latn.eng_Latn.bin new file mode 100644 index 0000000000000000000000000000000000000000..baffa7d04a884cceeec1f9a7e5a53a1011a0d75a --- /dev/null +++ b/data/data-bin/train.mni_Beng-eng_Latn.eng_Latn.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fa91a5fe810ad4a61983115dbe4a181b3ff526b2f758b48547c9850074788ac1 +size 11406672 diff --git a/data/data-bin/train.mni_Beng-eng_Latn.eng_Latn.idx b/data/data-bin/train.mni_Beng-eng_Latn.eng_Latn.idx new file mode 100644 index 0000000000000000000000000000000000000000..a2463e8063b2c1557e9ad95177e3c2cfcc103148 --- /dev/null +++ b/data/data-bin/train.mni_Beng-eng_Latn.eng_Latn.idx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:debccdfcd644f75811f67921e011ded1dc372de57b1080a1003a511d069e2481 +size 1671218 diff --git a/data/data-bin/train.mni_Beng-eng_Latn.mni_Beng.bin b/data/data-bin/train.mni_Beng-eng_Latn.mni_Beng.bin new file mode 100644 index 0000000000000000000000000000000000000000..7eb95e3ca1441b25b1d84c8f7c0041ba3fcedc31 --- /dev/null +++ b/data/data-bin/train.mni_Beng-eng_Latn.mni_Beng.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:350e5a813696f93c6f7ce2070597eba8a2f5b246bd0bec0dd17c52d930be5025 +size 9675092 diff --git a/data/data-bin/train.mni_Beng-eng_Latn.mni_Beng.idx b/data/data-bin/train.mni_Beng-eng_Latn.mni_Beng.idx new file mode 100644 index 0000000000000000000000000000000000000000..f8dde97a188ef4c31f8adf61463ffc3acb77b0cc --- /dev/null +++ b/data/data-bin/train.mni_Beng-eng_Latn.mni_Beng.idx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:805d0d4abbbda5d6ad89d8d9fe2bdd0998a523dda371d5e5c16a188b330f7168 +size 1671218 diff --git a/data/data-bin/valid.mni_Beng-eng_Latn.eng_Latn.bin b/data/data-bin/valid.mni_Beng-eng_Latn.eng_Latn.bin new file mode 100644 index 0000000000000000000000000000000000000000..47f89c487ea7715b22fcefbb6d2d4dfe84b52335 --- /dev/null +++ b/data/data-bin/valid.mni_Beng-eng_Latn.eng_Latn.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:09c9c60b5ac448f168203bc4e2070f649ff83048d421f320bebcb7156df70667 +size 195996 diff --git a/data/data-bin/valid.mni_Beng-eng_Latn.mni_Beng.bin b/data/data-bin/valid.mni_Beng-eng_Latn.mni_Beng.bin new file mode 100644 index 0000000000000000000000000000000000000000..04f9f84de94b8c957913ca2580e53a82678462aa --- /dev/null +++ b/data/data-bin/valid.mni_Beng-eng_Latn.mni_Beng.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f76ac663203619de060fa8b093abd1a2b81f4ad12a00173c5be64fd4f5d3cf1b +size 165404 diff --git a/data/fairseq/alignment_train_cpu_binding.cpython-38-x86_64-linux-gnu.so b/data/fairseq/alignment_train_cpu_binding.cpython-38-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..fe3c499618643a1ff1de7146faa7a4665d2226f9 --- /dev/null +++ b/data/fairseq/alignment_train_cpu_binding.cpython-38-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2a86c03d32f0a1e2a9636b12d46ae123bb98e993feffeb4c26b7a02ffe4bfad4 +size 9032568 diff --git a/data/fairseq/docs/fairseq.gif b/data/fairseq/docs/fairseq.gif new file mode 100644 index 0000000000000000000000000000000000000000..8701763fa799e18f99ecf255f9cadb058724ab0a --- /dev/null +++ b/data/fairseq/docs/fairseq.gif @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b7551e9682c816fca1fa00458f3b657177c8d90d2e87db31e42197cb3ae80fca +size 2664833 diff --git a/data/fairseq/examples/MMPT/videoclip.png b/data/fairseq/examples/MMPT/videoclip.png new file mode 100644 index 0000000000000000000000000000000000000000..2b6f8d959fcfe3ce229df16a52c5c8230950b582 --- /dev/null +++ b/data/fairseq/examples/MMPT/videoclip.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1d54fe18d1259ade9332e78fdb74f834fdfbdb0b0486517e6a7cd48956b30663 +size 385871 diff --git a/data/fairseq/examples/MMPT/vlm.png b/data/fairseq/examples/MMPT/vlm.png new file mode 100644 index 0000000000000000000000000000000000000000..c702b32b12d7d630c25af96a98ded4f83378bcb4 --- /dev/null +++ b/data/fairseq/examples/MMPT/vlm.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:722852ed6258ac9f7ffd3e3913fa1a370702c4d989ef6d881847432d59ade4e5 +size 418405 diff --git a/data/fairseq/examples/hubert/tests/6313-76958-0021.flac b/data/fairseq/examples/hubert/tests/6313-76958-0021.flac new file mode 100644 index 0000000000000000000000000000000000000000..a3de1e1e9d7ea573e77cbbc33895178908622bb5 --- /dev/null +++ b/data/fairseq/examples/hubert/tests/6313-76958-0021.flac @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0dd89e2bf8c60e05264bf2539f0ec35bc65efb55cd952b3510fa243de9cc16ff +size 223912 diff --git a/data/fairseq/examples/hubert/tests/sample.base.L9.npy b/data/fairseq/examples/hubert/tests/sample.base.L9.npy new file mode 100644 index 0000000000000000000000000000000000000000..7a2b109228036a1de485a3bb942e1df869999c55 --- /dev/null +++ b/data/fairseq/examples/hubert/tests/sample.base.L9.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b44dc3a0519f6adb670a5da7410c1405f4fdb0e4866e5fc4983b136480212f34 +size 1831104 diff --git a/data/fairseq/examples/hubert/tests/sample.large.L20.npy b/data/fairseq/examples/hubert/tests/sample.large.L20.npy new file mode 100644 index 0000000000000000000000000000000000000000..f5a7dcf1a9ccaa6d8e78a75e3ed749a05775a4e5 --- /dev/null +++ b/data/fairseq/examples/hubert/tests/sample.large.L20.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4c82839134cc2340355eb49b41e7e3517e8e9dfdfaa6fc28f0464cc8ae9569ee +size 2441408 diff --git a/data/fairseq/examples/hubert/tests/sample.xlarge.L30.npy b/data/fairseq/examples/hubert/tests/sample.xlarge.L30.npy new file mode 100644 index 0000000000000000000000000000000000000000..b617c3876654a69d73e3f9bd2ad7ff01b764cf24 --- /dev/null +++ b/data/fairseq/examples/hubert/tests/sample.xlarge.L30.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bbe9f0929ecd4c58786be55215d83f85787ff0d81196bc2e73414f82a8939806 +size 3051712 diff --git a/data/fairseq/examples/textless_nlp/speech-resynth/img/fig.png b/data/fairseq/examples/textless_nlp/speech-resynth/img/fig.png new file mode 100644 index 0000000000000000000000000000000000000000..f92509bcfef84a7f5ead19f3b224ff89f9ee0a30 --- /dev/null +++ b/data/fairseq/examples/textless_nlp/speech-resynth/img/fig.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c19c570f3671d88551f5d5b908e270e69bd75d304c5d358868fa19f342979c17 +size 307833 diff --git a/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_baevski_gbw.yaml b/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_baevski_gbw.yaml new file mode 100644 index 0000000000000000000000000000000000000000..30b1a4f1e0f5e7f7c2671ff8ec995cc32363f10f --- /dev/null +++ b/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_baevski_gbw.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "relu" +dropout: 0.1 +attention_dropout: 0.1 +activation_dropout: 0.0 +relu_dropout: 0.0 +decoder_embed_dim: 512 +decoder_output_dim: 512 +decoder_input_dim: 512 +decoder_ffn_embed_dim: 4096 +decoder_layers: 12 +decoder_attention_heads: 16 +decoder_normalize_before: true +no_decoder_final_norm: true +adaptive_softmax_cutoff: null +adaptive_softmax_dropout: 0 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: false +adaptive_input_factor: 4 +adaptive_input_cutoff: null +tie_adaptive_weights: false +tie_adaptive_proj: false +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_baevski_wiki103.yaml b/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_baevski_wiki103.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1154cfa660ee5ce6a272cd1a0049eead1e92c117 --- /dev/null +++ b/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_baevski_wiki103.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "relu" +dropout: 0.3 +attention_dropout: 0.1 +activation_dropout: 0.1 +relu_dropout: 0.1 +decoder_embed_dim: 1024 +decoder_output_dim: 1024 +decoder_input_dim: 1024 +decoder_ffn_embed_dim: 4096 +decoder_layers: 16 +decoder_attention_heads: 8 +decoder_normalize_before: true +no_decoder_final_norm: true +adaptive_softmax_cutoff: "20000,60000" +adaptive_softmax_dropout: 0.2 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: true +adaptive_input_factor: 4 +adaptive_input_cutoff: "20000,60000" +tie_adaptive_weights: true +tie_adaptive_proj: true +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_big.yaml b/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_big.yaml new file mode 100644 index 0000000000000000000000000000000000000000..309575310bfc5d9c5cde31563073bef18abc646e --- /dev/null +++ b/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_big.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "relu" +dropout: 0.1 +attention_dropout: 0.0 +activation_dropout: 0.0 +relu_dropout: 0.0 +decoder_embed_dim: 1024 +decoder_output_dim: 1024 +decoder_input_dim: 1024 +decoder_ffn_embed_dim: 4096 +decoder_layers: 12 +decoder_attention_heads: 16 +decoder_normalize_before: true +no_decoder_final_norm: false +adaptive_softmax_cutoff: null +adaptive_softmax_dropout: 0 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: false +adaptive_input_factor: 4 +adaptive_input_cutoff: null +tie_adaptive_weights: false +tie_adaptive_proj: false +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_big.yaml b/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_big.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a08769a1781abdb13302bf57bf1338bcaf68a0ec --- /dev/null +++ b/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_big.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "gelu" +dropout: 0.1 +attention_dropout: 0.1 +activation_dropout: 0.0 +relu_dropout: 0.0 +decoder_embed_dim: 1600 +decoder_output_dim: 1600 +decoder_input_dim: 1600 +decoder_ffn_embed_dim: 6400 +decoder_layers: 48 +decoder_attention_heads: 25 +decoder_normalize_before: true +no_decoder_final_norm: false +adaptive_softmax_cutoff: null +adaptive_softmax_dropout: 0 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: false +adaptive_input_factor: 4 +adaptive_input_cutoff: null +tie_adaptive_weights: false +tie_adaptive_proj: false +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_medium.yaml b/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_medium.yaml new file mode 100644 index 0000000000000000000000000000000000000000..64261d793c0f1ae091c9bf5c8c77093a07326137 --- /dev/null +++ b/data/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_medium.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "gelu" +dropout: 0.1 +attention_dropout: 0.1 +activation_dropout: 0.0 +relu_dropout: 0.0 +decoder_embed_dim: 1280 +decoder_output_dim: 1280 +decoder_input_dim: 1280 +decoder_ffn_embed_dim: 5120 +decoder_layers: 36 +decoder_attention_heads: 20 +decoder_normalize_before: true +no_decoder_final_norm: false +adaptive_softmax_cutoff: null +adaptive_softmax_dropout: 0 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: false +adaptive_input_factor: 4 +adaptive_input_cutoff: null +tie_adaptive_weights: false +tie_adaptive_proj: false +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/data/fairseq/fairseq/config/model/wav2vec/vq_wav2vec_gumbel.yaml b/data/fairseq/fairseq/config/model/wav2vec/vq_wav2vec_gumbel.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ee1329bf4612d8bb295c6cc3d8bc0a3bcef1777d --- /dev/null +++ b/data/fairseq/fairseq/config/model/wav2vec/vq_wav2vec_gumbel.yaml @@ -0,0 +1,5 @@ +# @package _group_ +activation: gelu +vq_type: gumbel +vq_depth: 2 +combine_groups: true diff --git a/data/fairseq/fairseq/config/model/wav2vec2/wav2vec2_base.yaml b/data/fairseq/fairseq/config/model/wav2vec2/wav2vec2_base.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ce65499b808b9a3821cee4ca87c36e84d09005a1 --- /dev/null +++ b/data/fairseq/fairseq/config/model/wav2vec2/wav2vec2_base.yaml @@ -0,0 +1,8 @@ +# @package _group_ + +quantize_targets: true +final_dim: 256 +encoder_layerdrop: 0.05 +dropout_input: 0.1 +dropout_features: 0.1 +feature_grad_mult: 0.1 diff --git a/data/fairseq/fairseq/config/model/wav2vec2/wav2vec2_large.yaml b/data/fairseq/fairseq/config/model/wav2vec2/wav2vec2_large.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5846f75243f27f201c85bfe6820815c015971275 --- /dev/null +++ b/data/fairseq/fairseq/config/model/wav2vec2/wav2vec2_large.yaml @@ -0,0 +1,20 @@ +# @package _group_ + +quantize_targets: true +extractor_mode: layer_norm +layer_norm_first: true +final_dim: 768 +latent_temp: [2.0,0.1,0.999995] +encoder_layerdrop: 0.0 +dropout_input: 0.0 +dropout_features: 0.0 +dropout: 0.0 +attention_dropout: 0.0 +conv_bias: true + +encoder_layers: 24 +encoder_embed_dim: 1024 +encoder_ffn_embed_dim: 4096 +encoder_attention_heads: 16 + +feature_grad_mult: 1.0 diff --git a/data/fairseq/fairseq/data/data_utils_fast.cpython-38-x86_64-linux-gnu.so b/data/fairseq/fairseq/data/data_utils_fast.cpython-38-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..ef54e82e4eb42683c6788961c5221d9bcc362b66 --- /dev/null +++ b/data/fairseq/fairseq/data/data_utils_fast.cpython-38-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8003eec4c60a6243d36f77482d8145d90f3424961ac0d5f6c4d9d257d2dc9847 +size 1311776 diff --git a/data/fairseq/fairseq/data/token_block_utils_fast.cpython-38-x86_64-linux-gnu.so b/data/fairseq/fairseq/data/token_block_utils_fast.cpython-38-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..08a74ebce8d393b50ab2406d6d0aae411bba6751 --- /dev/null +++ b/data/fairseq/fairseq/data/token_block_utils_fast.cpython-38-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3f175e6ab8b08a2e5733a01f571e09e43e4f891fff2fa81acd873b214517091f +size 1374952 diff --git a/data/fairseq/fairseq/distributed/__init__.py b/data/fairseq/fairseq/distributed/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9130db8f5d039519d663ee16c7ff2c102f5481f5 --- /dev/null +++ b/data/fairseq/fairseq/distributed/__init__.py @@ -0,0 +1,25 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .distributed_timeout_wrapper import DistributedTimeoutWrapper +from .fully_sharded_data_parallel import ( + fsdp_enable_wrap, + fsdp_wrap, + FullyShardedDataParallel, +) +from .legacy_distributed_data_parallel import LegacyDistributedDataParallel +from .module_proxy_wrapper import ModuleProxyWrapper +from .tpu_distributed_data_parallel import TPUDistributedDataParallel + + +__all__ = [ + "DistributedTimeoutWrapper", + "fsdp_enable_wrap", + "fsdp_wrap", + "FullyShardedDataParallel", + "LegacyDistributedDataParallel", + "ModuleProxyWrapper", + "TPUDistributedDataParallel", +] diff --git a/data/fairseq/fairseq/distributed/__pycache__/distributed_timeout_wrapper.cpython-38.pyc b/data/fairseq/fairseq/distributed/__pycache__/distributed_timeout_wrapper.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1448a9c2b3067b336f0c6c91e3c77834957d3458 Binary files /dev/null and b/data/fairseq/fairseq/distributed/__pycache__/distributed_timeout_wrapper.cpython-38.pyc differ diff --git a/data/fairseq/fairseq/distributed/__pycache__/legacy_distributed_data_parallel.cpython-38.pyc b/data/fairseq/fairseq/distributed/__pycache__/legacy_distributed_data_parallel.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..621b14345209cd93da87b6638887f32e753016f6 Binary files /dev/null and b/data/fairseq/fairseq/distributed/__pycache__/legacy_distributed_data_parallel.cpython-38.pyc differ diff --git a/data/fairseq/fairseq/distributed/distributed_timeout_wrapper.py b/data/fairseq/fairseq/distributed/distributed_timeout_wrapper.py new file mode 100644 index 0000000000000000000000000000000000000000..6e06b4b6dd9a5fedd5d72bde02ceb7aaf74833d7 --- /dev/null +++ b/data/fairseq/fairseq/distributed/distributed_timeout_wrapper.py @@ -0,0 +1,97 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import signal +import threading + +from torch import nn + + +logger = logging.getLogger(__name__) + + +class DistributedTimeoutWrapper(nn.Module): + """ + A wrapper that kills the process if no progress is made within a given + *timeout*. The timer is reset every time :func:`forward` is called. + + Usage:: + + module = DistributedTimeoutWrapper(module, timeout=30) + x = module(input) + time.sleep(20) # safe + x = module(input) + time.sleep(45) # job will be killed before this returns + + Args: + module (nn.Module): module to wrap + timeout (int): number of seconds before killing the process + (set to a value <= 0 to disable the timeout) + signal (Optional): signal to send once timeout is triggered + """ + + def __init__(self, module: nn.Module, timeout: int, signal=signal.SIGINT): + super().__init__() + self.module = module + self.timeout = timeout + self.signal = signal + + if timeout > 0: + self._heartbeat = threading.Event() + self._heartbeat_thread = threading.Thread( + target=self._check_heartbeat, + args=(os.getpid(),), + daemon=True, + ) + self._heartbeat_thread.start() + self._terminated = False + else: + self._heartbeat = None + self._heartbeat_thread = None + + def __del__(self): + self.stop_timeout() + + def __getattr__(self, name): + """Forward missing attributes to wrapped module.""" + try: + return super().__getattr__(name) # defer to nn.Module's logic + except AttributeError: + return getattr(self.module, name) + + def stop_timeout(self): + if self._heartbeat_thread is not None: + self._terminated = True + self._heartbeat_thread.join() + + def state_dict(self, *args, **kwargs): + return self.module.state_dict(*args, **kwargs) + + def load_state_dict(self, *args, **kwargs): + return self.module.load_state_dict(*args, **kwargs) + + def forward(self, *args, **kwargs): + if self._heartbeat is not None: + self._heartbeat.set() + return self.module(*args, **kwargs) + + def _check_heartbeat(self, parent_pid): + self._heartbeat.wait() # wait for the first forward pass + while True: + self._heartbeat.clear() + success = self._heartbeat.wait(timeout=self.timeout) + if self._terminated: + break + elif not success: + logger.error( + ( + "Killing job for not making progress in {} seconds. " + "Set --heartbeat-timeout=-1 to disable this timeout." + ).format(int(self.timeout)) + ) + os.kill(parent_pid, self.signal) + return diff --git a/data/fairseq/fairseq/distributed/fully_sharded_data_parallel.py b/data/fairseq/fairseq/distributed/fully_sharded_data_parallel.py new file mode 100644 index 0000000000000000000000000000000000000000..1c508b05dd2c5aa4a3aa586a6998e04dbbbbb918 --- /dev/null +++ b/data/fairseq/fairseq/distributed/fully_sharded_data_parallel.py @@ -0,0 +1,145 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import contextlib +from typing import Optional + +import torch +from fairseq.dataclass.configs import DistributedTrainingConfig +from fairseq.distributed import utils as dist_utils + + +try: + from fairscale.nn.data_parallel import FullyShardedDataParallel as FSDP + + has_FSDP = True +except ImportError: + FSDP = torch.nn.Module + has_FSDP = False + + +class FullyShardedDataParallel(FSDP): + """ + A small wrapper around fairscale's FullyShardedDataParallel (FSDP) with some + fairseq-specific checkpoint saving/loading logic. + + Args: + use_sharded_state (bool): if True, then ``state_dict`` will return + ``FSDP.local_state_dict`` and ``load_state_dict`` will call + ``FSDP.load_local_state_dict``. Otherwise, ``state_dict`` will + return the full model weights on data parallel rank 0 (empty on + other ranks) and ``load_state_dict`` will broadcast model weights + from rank 0 to other ranks. + """ + + def __init__(self, *args, use_sharded_state: bool = False, **kwargs): + if not has_FSDP: + raise ImportError( + "Cannot find FullyShardedDataParallel. " + "Please install fairscale with: pip install fairscale" + ) + super().__init__(*args, **kwargs) + self.use_sharded_state = use_sharded_state + + @property + def unwrapped_module(self) -> torch.nn.Module: + if self.flatten_parameters: + return self.module.module + else: + return self.module + + def state_dict(self, destination=None, prefix="", keep_vars=False): + if self.use_sharded_state: + return super().local_state_dict( + destination=destination, prefix=prefix, keep_vars=keep_vars + ) + else: + if self.rank == 0: + return super().state_dict( + destination=destination, prefix=prefix, keep_vars=keep_vars + ) + else: + # We must call state_dict() due to use of communication + # primitives. But we don't use the result. + super().state_dict() + return destination or {} + + def load_state_dict(self, state_dict, strict=True, model_cfg=None): + if self.use_sharded_state: + return super().load_local_state_dict(state_dict, strict=strict) + else: + state_dict = dist_utils.broadcast_object( + state_dict, src_rank=0, group=self.process_group + ) + return super().load_state_dict(state_dict, strict=strict) + + +class DummyProcessGroup: + def __init__(self, rank: int, size: int): + self._rank = rank + self._size = size + + def rank(self) -> int: + return self._rank + + def size(self) -> int: + return self._size + + +@contextlib.contextmanager +def fsdp_enable_wrap(cfg: DistributedTrainingConfig): + try: + from fairscale.nn import enable_wrap + except ImportError: + raise ImportError( + "Cannot find FullyShardedDataParallel. " + "Please install fairscale with: pip install fairscale" + ) + if cfg.memory_efficient_fp16: + assert cfg.fp16 # memory_efficient_fp16 should imply fp16 + group = dist_utils.get_data_parallel_group() + if group is None and cfg.distributed_world_size == 1: + group = DummyProcessGroup(rank=0, size=1) + fsdp_config = { + "process_group": group, + "reshard_after_forward": not cfg.no_reshard_after_forward, + "mixed_precision": cfg.fp16 and not cfg.memory_efficient_fp16, + "fp32_reduce_scatter": cfg.fp32_reduce_scatter, + "flatten_parameters": not cfg.not_fsdp_flatten_parameters, + "cpu_offload": cfg.cpu_offload, + "compute_dtype": torch.float16 if cfg.fp16 else torch.float32, + "bucket_cap_mb": cfg.bucket_cap_mb, + "state_dict_device": torch.device("cpu"), # reduce GPU mem usage + } + with enable_wrap( + wrapper_cls=FullyShardedDataParallel, + use_sharded_state=cfg.use_sharded_state, + **fsdp_config, + ): + yield + + +def fsdp_wrap(module, min_num_params: Optional[int] = None, **kwargs): + """ + Helper to wrap layers/modules in FSDP. This falls back to a no-op if + fairscale is not available. + + Args: + module (nn.Module): module to (maybe) wrap + min_num_params (int, Optional): minimum number of layer params to wrap + """ + try: + from fairscale.nn import wrap + + if min_num_params is not None: + num_params = sum(p.numel() for p in module.parameters()) + if num_params >= min_num_params: + return wrap(module, **kwargs) + else: + return module + else: + return wrap(module, **kwargs) + except ImportError: + return module diff --git a/data/fairseq/fairseq/distributed/legacy_distributed_data_parallel.py b/data/fairseq/fairseq/distributed/legacy_distributed_data_parallel.py new file mode 100644 index 0000000000000000000000000000000000000000..cd434c7372ba30ea0e6f87e084230448f53480e9 --- /dev/null +++ b/data/fairseq/fairseq/distributed/legacy_distributed_data_parallel.py @@ -0,0 +1,165 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +A modified version of the legacy DistributedDataParallel module that uses c10d +communication primitives. This version is simpler than the latest PyTorch +version and is useful for debugging. Notably it does not overlap gradient +communication with the backward pass, which makes it slower but more robust +than the PyTorch version. + +This version also supports the *no_sync* context manager, which allows faster +training with `--update-freq`. +""" + +from collections import OrderedDict +from contextlib import contextmanager + +import torch +from torch import nn + +from fairseq.distributed import utils + + +class LegacyDistributedDataParallel(nn.Module): + """Implements distributed data parallelism at the module level. + + A simplified version of :class:`torch.nn.parallel.DistributedDataParallel`. + This version uses a c10d process group for communication and does not + broadcast buffers. + + Args: + module (~torch.nn.Module): module to be parallelized + process_group: the c10d process group to be used for distributed data + parallel all-reduction. + buffer_size (int, optional): number of elements to buffer before + performing all-reduce (default: 256M). + """ + + def __init__(self, module, process_group, buffer_size=2**28): + super().__init__() + + self.module = module + self.process_group = process_group + self.world_size = utils.get_world_size(self.process_group) + + # Never use a bigger buffer than the number of model params + self.buffer_size = min(buffer_size, sum(p.numel() for p in module.parameters())) + self.buffer = None + + # We can also forcibly accumulate grads locally and only do the + # all-reduce at some later time + self.accumulate_grads = False + + # make per-device lists of parameters + paramlists = OrderedDict() + for param in self.module.parameters(): + device = param.device + if paramlists.get(device) is None: + paramlists[device] = [] + paramlists[device] += [param] + self.per_device_params = list(paramlists.values()) + + @contextmanager + def no_sync(self): + """A context manager to disable gradient synchronization.""" + old_accumulate_grads = self.accumulate_grads + self.accumulate_grads = True + yield + self.accumulate_grads = old_accumulate_grads + + def forward(self, *inputs, **kwargs): + return self.module(*inputs, **kwargs) + + def all_reduce_grads(self): + """ + This function must be called explicitly after backward to reduce + gradients. There is no automatic hook like c10d. + """ + + def all_reduce_params(params): + buffer = self.buffer + nonzero_buffer = False + if len(params) > 1: + offset = 0 + for p in params: + sz = p.numel() + if p.grad is not None: + buffer[offset : offset + sz].copy_(p.grad.data.view(-1)) + nonzero_buffer = True + else: + buffer[offset : offset + sz].zero_() + offset += sz + else: + # we only have a single grad to all-reduce + p = params[0] + if p.grad is not None: + buffer = p.grad.data + nonzero_buffer = True + elif p.numel() <= self.buffer.numel(): + buffer = buffer[: p.numel()] + buffer.zero_() + else: + buffer = torch.zeros_like(p) + + if nonzero_buffer: + buffer.div_(self.world_size) + + utils.all_reduce(buffer, self.process_group) + + # copy all-reduced grads back into their original place + offset = 0 + for p in params: + sz = p.numel() + if p.grad is not None: + p.grad.data.copy_(buffer[offset : offset + sz].view_as(p)) + else: + p.grad = buffer[offset : offset + sz].view_as(p).clone() + offset += sz + + def reduction_fn(): + # This function only needs to be called once + if self.accumulate_grads: + return + + if self.buffer is None: + self.buffer = next(self.module.parameters()).new(self.buffer_size) + + for params in self.per_device_params: + # All-reduce the gradients in buckets + offset = 0 + buffered_params = [] + for param in params: + if not param.requires_grad: + continue + if param.grad is None: + param.grad = torch.zeros_like(param) + + if hasattr(param, "expert"): + # Skip gradient sync for unshared parameters + continue + + if param.grad.requires_grad: + raise RuntimeError( + "DistributedDataParallel only works " + "with gradients that don't require " + "grad" + ) + sz = param.numel() + if sz > self.buffer.numel(): + # all-reduce big params directly + all_reduce_params([param]) + else: + if offset + sz > self.buffer.numel(): + all_reduce_params(buffered_params) + offset = 0 + buffered_params.clear() + buffered_params.append(param) + offset += sz + + if len(buffered_params) > 0: + all_reduce_params(buffered_params) + + reduction_fn() diff --git a/data/fairseq/fairseq/distributed/module_proxy_wrapper.py b/data/fairseq/fairseq/distributed/module_proxy_wrapper.py new file mode 100644 index 0000000000000000000000000000000000000000..904dc0c202e09db244518836c0f061e0850cad61 --- /dev/null +++ b/data/fairseq/fairseq/distributed/module_proxy_wrapper.py @@ -0,0 +1,56 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from torch import nn + + +class ModuleProxyWrapper(nn.Module): + """ + Wrap a DistributedDataParallel module and forward requests for missing + attributes to the module wrapped by DDP (the twice-wrapped module). + Also forward calls to :func:`state_dict` and :func:`load_state_dict`. + + Usage:: + + module.xyz = "hello world" + wrapped_module = DistributedDataParallel(module, **ddp_args) + wrapped_module = ModuleProxyWrapper(wrapped_module) + assert wrapped_module.xyz == "hello world" + assert wrapped_module.state_dict().keys() == module.state_dict().keys() + + Args: + module (nn.Module): module to wrap + """ + + def __init__(self, module: nn.Module): + super().__init__() + assert hasattr( + module, "module" + ), "ModuleProxyWrapper expects input to wrap another module" + self.module = module + + def __getattr__(self, name): + """Forward missing attributes to twice-wrapped module.""" + try: + # defer to nn.Module's logic + return super().__getattr__(name) + except AttributeError: + try: + # forward to the once-wrapped module + return getattr(self.module, name) + except AttributeError: + # forward to the twice-wrapped module + return getattr(self.module.module, name) + + def state_dict(self, *args, **kwargs): + """Forward to the twice-wrapped module.""" + return self.module.module.state_dict(*args, **kwargs) + + def load_state_dict(self, *args, **kwargs): + """Forward to the twice-wrapped module.""" + return self.module.module.load_state_dict(*args, **kwargs) + + def forward(self, *args, **kwargs): + return self.module(*args, **kwargs) diff --git a/data/fairseq/fairseq/distributed/tpu_distributed_data_parallel.py b/data/fairseq/fairseq/distributed/tpu_distributed_data_parallel.py new file mode 100644 index 0000000000000000000000000000000000000000..3b9e1033011db87100c64ec39845e81228a26381 --- /dev/null +++ b/data/fairseq/fairseq/distributed/tpu_distributed_data_parallel.py @@ -0,0 +1,43 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from torch import nn + +from fairseq.distributed import utils + + +class TPUDistributedDataParallel(nn.Module): + def __init__(self, module, process_group): + super().__init__() + self.module = module + self.process_group = process_group + self.world_size = utils.get_world_size(self.process_group) + + def forward(self, *inputs, **kwargs): + return self.module(*inputs, **kwargs) + + def all_reduce_grads(self): + gradients = [] + for p in self.parameters(): + if not p.requires_grad: + continue + if p.grad is None: + p.grad = torch.zeros_like(p) + if p.grad.requires_grad: + raise RuntimeError( + "TPUDistributedDataParallel only works with gradients that don't " + "require grad" + ) + gradients.append(p.grad) + + import torch_xla.core.xla_model as xm + + xm.all_reduce( + "sum", + gradients, + scale=1.0 / self.world_size, + groups=self.process_group[1], + ) diff --git a/data/fairseq/fairseq/distributed/utils.py b/data/fairseq/fairseq/distributed/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..968830d58582e436386111d90896bf95889c736e --- /dev/null +++ b/data/fairseq/fairseq/distributed/utils.py @@ -0,0 +1,843 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import io +import logging +import os +import pickle +import random +import socket +import struct +import subprocess +import warnings +from argparse import Namespace +from collections import OrderedDict +from dataclasses import dataclass +from typing import Any, Dict, List, Mapping, Optional + +import torch +import torch.distributed as dist +from fairseq.dataclass.configs import DistributedTrainingConfig, FairseqConfig +from omegaconf import open_dict + +try: + import torch_xla.core.xla_model as xm +except ImportError: + xm = None + + +# Flag to indicate if we're using Megatron +# NOTE: this is a temporary hack until we move away from Megatron's model parallel init +_USE_MEGATRON = False + +# Whether to use XLA ops (e.g., on TPUs) instead of CUDA ops. +_USE_XLA = False + + +logger = logging.getLogger(__name__) + + +def is_master(cfg: DistributedTrainingConfig): + return cfg.distributed_rank == 0 + + +def infer_init_method(cfg: DistributedTrainingConfig, force_distributed=False): + if cfg.distributed_init_method is not None or cfg.tpu: + return + + num_pipelines_per_node = None + if cfg.pipeline_model_parallel: + num_pipeline_devices, num_pipelines_per_node = _pipeline_parallel_pre_init(cfg) + + if cfg.distributed_world_size == 1: + return + if all( + key in os.environ + for key in ["MASTER_ADDR", "MASTER_PORT", "WORLD_SIZE", "RANK"] + ): + # support torch.distributed.launch + _infer_torch_distributed_launch_init(cfg) + else: + # we can determine the init method automatically for Slurm + if not _infer_slurm_init(cfg, num_pipelines_per_node): + if cfg.distributed_port <= 0 or force_distributed: + _infer_single_node_init(cfg) + elif cfg.distributed_port <= 0: + _infer_single_node_init(cfg) + + if cfg.pipeline_model_parallel: + _pipeline_parallel_post_init(cfg, num_pipeline_devices, num_pipelines_per_node) + elif not cfg.distributed_no_spawn: + with open_dict(cfg): + cfg.distributed_num_procs = min( + torch.cuda.device_count(), cfg.distributed_world_size + ) + else: + if cfg.device_id > 0: + logger.info( + "setting CUDA device={} on rank {}".format( + cfg.device_id, cfg.distributed_rank + ) + ) + torch.cuda.set_device(cfg.device_id) + + +def _infer_torch_distributed_launch_init(cfg: DistributedTrainingConfig): + cfg.distributed_init_method = "env://" + cfg.distributed_world_size = int(os.environ["WORLD_SIZE"]) + cfg.distributed_rank = int(os.environ["RANK"]) + cfg.device_id = cfg.distributed_rank % torch.cuda.device_count() + # processes are created by torch.distributed.launch + cfg.distributed_no_spawn = True + + +def _infer_slurm_init(cfg: DistributedTrainingConfig, num_pipelines_per_node): + node_list = os.environ.get("SLURM_STEP_NODELIST") + if node_list is None: + node_list = os.environ.get("SLURM_JOB_NODELIST") + if node_list is not None: + try: + hostnames = subprocess.check_output( + ["scontrol", "show", "hostnames", node_list] + ) + cfg.distributed_init_method = "tcp://{host}:{port}".format( + host=hostnames.split()[0].decode("utf-8"), + port=cfg.distributed_port, + ) + nnodes = int(os.environ.get("SLURM_NNODES")) + ntasks_per_node = os.environ.get("SLURM_NTASKS_PER_NODE") + if ntasks_per_node is not None: + ntasks_per_node = int(ntasks_per_node) + else: + ntasks = int(os.environ.get("SLURM_NTASKS")) + nnodes = int(os.environ.get("SLURM_NNODES")) + assert ntasks % nnodes == 0 + ntasks_per_node = int(ntasks / nnodes) + if ntasks_per_node == 1: + gpus_per_node = torch.cuda.device_count() + node_id = int(os.environ.get("SLURM_NODEID")) + cfg.distributed_rank = node_id * gpus_per_node + cfg.distributed_world_size = nnodes * gpus_per_node + elif cfg.pipeline_model_parallel: + assert ntasks_per_node == num_pipelines_per_node, ( + "SLURM --ntasks-per-node must match number of pipelines per " + "node (={})".format(num_pipelines_per_node) + ) + cfg.distributed_no_spawn = True + # For 4-way MP on nodes with 8 GPUs, ranks will be [0, 1] on + # the first node, [1, 2] on the second node, etc. This + # matches torch.distributed.launch. + node_id = int(os.environ.get("SLURM_NODEID")) + local_id = int(os.environ.get("SLURM_LOCALID")) + cfg.distributed_rank = node_id * num_pipelines_per_node + local_id + # In the above example, device_id will always be in [0, 1], + # which also matches torch.distributed.launch. + cfg.device_id = local_id + # We also want to set distributed_world_size to be the total + # number of pipelines across all nodes. + cfg.distributed_world_size = nnodes * num_pipelines_per_node + else: + assert ( + ntasks_per_node == cfg.distributed_world_size // nnodes + ), f"{ntasks_per_node}, {cfg.distributed_world_size}, {nnodes}" + cfg.distributed_no_spawn = True + cfg.distributed_rank = int(os.environ.get("SLURM_PROCID")) + cfg.device_id = int(os.environ.get("SLURM_LOCALID")) + logger.info(f"Rank {cfg.distributed_rank}, device_id: {cfg.device_id}") + return True + except subprocess.CalledProcessError as e: # scontrol failed + raise e + except FileNotFoundError: # Slurm is not installed + pass + + return False + + +def _infer_single_node_init(cfg: DistributedTrainingConfig): + assert ( + cfg.distributed_world_size <= torch.cuda.device_count() + ), f"world size is {cfg.distributed_world_size} but have {torch.cuda.device_count()} available devices" + + if cfg.distributed_port <= 0: + jobid = os.environ.get("SLURM_JOB_ID") + task_id = os.environ.get("SLURM_ARRAY_TASK_ID") + + if jobid is not None: + if task_id is not None: + jobid += str(task_id) + jobid = int(jobid) + rng = random.Random(jobid) + port = rng.randint(10000, 60000) + else: + port = random.randint(10000, 60000) + + cfg.distributed_port = port + cfg.distributed_init_method = "tcp://localhost:{port}".format( + port=cfg.distributed_port + ) + + +def _pipeline_parallel_pre_init(cfg: DistributedTrainingConfig): + from fairseq import utils + + balance_exists = ( + cfg.pipeline_balance is not None + or cfg.pipeline_encoder_balance is not None + or cfg.pipeline_decoder_balance is not None + ) + devices_exist = ( + cfg.pipeline_devices is not None + or cfg.pipeline_encoder_devices is not None + or cfg.pipeline_decoder_devices is not None + ) + if not balance_exists: + raise ValueError( + "--pipeline-balance is currently required for pipeline model parallelism" + ) + if not devices_exist: + raise ValueError( + "--pipeline-devices is currently required for pipeline model parallelism" + ) + + cfg.pipeline_balance = utils.eval_str_list(cfg.pipeline_balance, type=int) + if cfg.pipeline_devices is not None: + cfg.pipeline_devices = utils.eval_str_list(cfg.pipeline_devices, type=int) + num_pipeline_devices = len(set(cfg.pipeline_devices)) + else: + cfg.pipeline_encoder_devices = utils.eval_str_list( + cfg.pipeline_encoder_devices, type=int + ) + cfg.pipeline_decoder_devices = utils.eval_str_list( + cfg.pipeline_decoder_devices, type=int + ) + num_pipeline_devices = len( + set(cfg.pipeline_encoder_devices + cfg.pipeline_decoder_devices) + ) + gpus_per_node = torch.cuda.device_count() + assert ( + gpus_per_node >= num_pipeline_devices + and gpus_per_node % num_pipeline_devices == 0 + ), ( + "the number of unique device IDs in --pipeline-devices must evenly divide " + "the number of GPUs per node (multi-node pipelining is not yet supported)" + ) + num_pipelines_per_node = gpus_per_node // num_pipeline_devices + return num_pipeline_devices, num_pipelines_per_node + + +def _pipeline_parallel_post_init( + cfg: DistributedTrainingConfig, num_pipeline_devices, num_pipelines_per_node +): + if not cfg.distributed_no_spawn: + # When distributed_no_spawn is False, we expect distributed_rank and + # distributed_world_size to be based on the total number of GPUs, so + # we need to correct them to be based on the number of pipelines. + assert cfg.distributed_world_size % num_pipeline_devices == 0 + cfg.distributed_world_size = cfg.distributed_world_size // num_pipeline_devices + # In the case of 4-way MP on nodes with 8 GPUs, we want + # distributed_rank to be the starting GPU index for each pipeline + # i.e., 0, 2, ... + gpus_per_node = torch.cuda.device_count() + assert cfg.distributed_rank % gpus_per_node == 0 + assert cfg.distributed_rank % num_pipeline_devices == 0 + + with open_dict(cfg): + cfg.distributed_rank = cfg.distributed_rank // num_pipeline_devices + # launch one process per pipeline + cfg.distributed_num_procs = num_pipelines_per_node + + # if we have 4-way MP on a node with 8 GPUs, we want device_ids to be 0 + # and 4, indicating the starting device IDs for each pipeline + cfg.device_id *= num_pipeline_devices + + if cfg.device_id > 0: + # if there's multiple pipelines on a node (e.g., 4-way MP on an 8 + # GPU node), we need to adjust pipeline_devices accordingly + logger.debug( + "setting CUDA device={} on rank {}".format( + cfg.device_id, cfg.distributed_rank + ) + ) + torch.cuda.set_device(cfg.device_id) + with open_dict(cfg): + cfg.pipeline_devices = [cfg.device_id + d for d in cfg.pipeline_devices] + logger.info( + "setting pipeline_devices={} on rank {}".format( + cfg.pipeline_devices, cfg.distributed_rank + ) + ) + + +def distributed_init(cfg: FairseqConfig): + if isinstance(cfg, Namespace): + from fairseq.dataclass.utils import convert_namespace_to_omegaconf + + cfg = convert_namespace_to_omegaconf(cfg) + + if not cfg.common.tpu: + if torch.distributed.is_available() and torch.distributed.is_initialized(): + warnings.warn( + "Distributed is already initialized, cannot initialize twice!" + ) + else: + logger.info( + "distributed init (rank {}): {}".format( + cfg.distributed_training.distributed_rank, + cfg.distributed_training.distributed_init_method, + ) + ) + dist.init_process_group( + backend=cfg.distributed_training.distributed_backend, + init_method=cfg.distributed_training.distributed_init_method, + world_size=cfg.distributed_training.distributed_world_size, + rank=cfg.distributed_training.distributed_rank, + ) + logger.info( + "initialized host {} as rank {}".format( + socket.gethostname(), + cfg.distributed_training.distributed_rank, + ) + ) + + # perform a dummy all-reduce to initialize the NCCL communicator + if torch.cuda.is_available(): + dist.all_reduce(torch.zeros(1).cuda()) + + cfg.distributed_training.distributed_rank = torch.distributed.get_rank() + else: + assert xm.xrt_world_size() == cfg.distributed_training.distributed_world_size + global _USE_XLA + _USE_XLA = True + cfg.distributed_training.device_id = xm.get_local_ordinal() + cfg.distributed_training.distributed_rank = xm.get_ordinal() + xm.rendezvous("distributed_init") # wait for all workers + + if is_master(cfg.distributed_training): + logging.getLogger().setLevel(logging.INFO) + else: + logging.getLogger().setLevel(logging.WARNING) + + if cfg.common.model_parallel_size > 1: + try: + from fairseq.model_parallel.megatron.mpu import ( + initialize_model_parallel, + model_parallel_cuda_manual_seed, + ) + except ImportError: + raise ImportError( + "\n\nPlease install the megatron submodule:" + "\n\n git submodule update --init " + "fairseq/model_parallel/megatron" + ) + global _USE_MEGATRON + _USE_MEGATRON = True + initialize_model_parallel(cfg.common.model_parallel_size) + model_parallel_cuda_manual_seed(cfg.common.seed) + model_part_number = get_model_parallel_rank() + cfg.checkpoint.checkpoint_suffix += "-model_part-{0}".format(model_part_number) + + if hasattr(cfg, "model") and getattr(cfg.model, "base_layers", 0) > 0: + cfg.checkpoint.checkpoint_suffix = ( + f"-rank-{cfg.distributed_training.distributed_rank}" + ) + + return cfg.distributed_training.distributed_rank + + +def distributed_main(i, main, cfg: FairseqConfig, kwargs): + cfg.distributed_training.device_id = i + if torch.cuda.is_available() and not cfg.common.cpu and not cfg.common.tpu: + torch.cuda.set_device(cfg.distributed_training.device_id) + if cfg.distributed_training.distributed_rank is None: # torch.multiprocessing.spawn + cfg.distributed_training.distributed_rank = kwargs.pop("start_rank", 0) + i + + cfg.distributed_training.distributed_rank = distributed_init(cfg) + + after_distributed_init_fn = kwargs.pop("after_distributed_init_fn", None) + if after_distributed_init_fn: + cfg = after_distributed_init_fn(cfg) + + main(cfg, **kwargs) + + if torch.distributed.is_initialized(): + torch.distributed.barrier(get_global_group()) + + +def call_main(cfg: FairseqConfig, main, **kwargs): + if cfg.distributed_training.distributed_init_method is None: + infer_init_method(cfg.distributed_training) + + if cfg.distributed_training.distributed_init_method is not None: + # distributed training + if not cfg.distributed_training.distributed_no_spawn: + start_rank = cfg.distributed_training.distributed_rank + cfg.distributed_training.distributed_rank = None # assign automatically + kwargs["start_rank"] = start_rank + + torch.multiprocessing.spawn( + fn=distributed_main, + args=(main, cfg, kwargs), + nprocs=min( + torch.cuda.device_count(), + cfg.distributed_training.distributed_world_size, + ), + join=True, + ) + else: + distributed_main(cfg.distributed_training.device_id, main, cfg, kwargs) + elif cfg.common.tpu and cfg.distributed_training.distributed_world_size > 1: + import torch_xla.distributed.xla_multiprocessing as xmp + + torch.multiprocessing.set_sharing_strategy("file_system") + xmp.spawn( + fn=distributed_main, + args=(main, cfg, kwargs), + # tpu-comment: + # 8 devices in one TPU VM, is the max processes to be spawned. + # The rest is driven by xm.distributed.xla_dist + nprocs=min(cfg.distributed_training.distributed_world_size, 8), + ) + else: + # single GPU main + main(cfg, **kwargs) + + +def use_xla(): + global _USE_XLA + return _USE_XLA + + +def new_groups(grouped_ranks: List[List[int]]): + if use_xla(): + return ("tpu", grouped_ranks) + else: + groups = [dist.new_group(g) for g in grouped_ranks] + my_group_idx = _find_my_group_index(grouped_ranks) + return groups[my_group_idx] + + +def _find_my_group_index(grouped_ranks): + my_rank = get_global_rank() + for i, group in enumerate(grouped_ranks): + if my_rank in group: + return i + raise RuntimeError + + +def _find_my_group(grouped_ranks): + index = _find_my_group_index(grouped_ranks) + return grouped_ranks[index] + + +def get_rank(group): + if use_xla(): + assert group[0] == "tpu" + my_group = _find_my_group(group[1]) + return my_group.index(get_global_rank()) + else: + return dist.get_rank(group=group) + + +def get_world_size(group): + if use_xla(): + assert group[0] == "tpu" + my_group = _find_my_group(group[1]) + return len(my_group) + elif torch.distributed.is_initialized(): + return dist.get_world_size(group=group) + else: + return 1 + + +def get_global_group(): + if use_xla(): + return new_groups([list(range(get_global_world_size()))]) + elif torch.distributed.is_initialized(): + if not hasattr(get_global_group, "_global_group"): + # ideally we could use torch.distributed.group.WORLD, but it seems + # to cause random NCCL hangs in some cases + get_global_group._global_group = dist.new_group() + return get_global_group._global_group + else: + return None + + +def get_global_rank(): + if use_xla(): + return xm.get_ordinal() + elif torch.distributed.is_initialized(): + return torch.distributed.get_rank() + else: + return 0 + + +def get_global_world_size(): + if use_xla(): + return xm.xrt_world_size() + elif torch.distributed.is_initialized(): + return torch.distributed.get_world_size() + else: + return 1 + + +def get_data_parallel_group(): + """Get the data parallel group the caller rank belongs to.""" + global _USE_MEGATRON + if _USE_MEGATRON: + from fairseq.model_parallel.megatron import mpu + + return mpu.get_data_parallel_group() + else: + return get_global_group() + + +def get_data_parallel_rank(): + """Return my rank for the data parallel group.""" + return get_rank(get_data_parallel_group()) + + +def get_data_parallel_world_size(): + """Return world size for the data parallel group.""" + return get_world_size(get_data_parallel_group()) + + +def get_model_parallel_group(): + global _USE_MEGATRON + if _USE_MEGATRON: + from fairseq.model_parallel.megatron import mpu + + return mpu.get_model_parallel_group() + else: + return None + + +def get_model_parallel_rank(): + """Return my rank for the model parallel group.""" + return get_rank(get_model_parallel_group()) + + +def get_model_parallel_world_size(): + """Return world size for the model parallel group.""" + return get_world_size(get_model_parallel_group()) + + +def all_reduce(tensor, group, op="sum"): + if use_xla(): + assert isinstance(group, tuple) and group[0] == "tpu" + tensor = [tensor] # wrap in a list to make xm.all_reduce in-place + return xm.all_reduce(op, tensor, groups=group[1])[0] + else: + if op == "sum": + op = dist.ReduceOp.SUM + elif op == "max": + op = dist.ReduceOp.MAX + else: + raise NotImplementedError + dist.all_reduce(tensor, op=op, group=group) + return tensor + + +def broadcast(tensor, src, group): + if use_xla(): + # XLA doesn't support broadcast, hack it with all_reduce + if get_rank(group) != src: + tensor.zero_() + all_reduce(tensor, group) + else: + dist.broadcast(tensor, src=src, group=group) + + +def all_to_all(tensor, group): + """Perform an all-to-all operation on a 1D Tensor.""" + assert tensor.dim() == 1 + split_count = get_world_size(group=group) + assert tensor.numel() % split_count == 0 + if use_xla(): + assert isinstance(group, tuple) and group[0] == "tpu" + return xm.all_to_all( + tensor, + split_dimension=0, + concat_dimension=0, + split_count=split_count, + groups=group[1], + ) + else: + output = torch.zeros_like(tensor) + dist.all_to_all_single(output, tensor, group=group) + return output + + +def all_gather(tensor, group, return_tensor=False): + """Perform an all-gather operation.""" + if use_xla(): + result = xm.all_gather(tensor, groups=group[1]) + world_size = get_world_size(group=group) + result = result.view(world_size, *tensor.size()) + if return_tensor: + return result + else: + return [result[i] for i in range(world_size)] + else: + world_size = get_world_size(group=group) + rank = get_rank(group=group) + tensor_list = [ + tensor if i == rank else torch.empty_like(tensor) for i in range(world_size) + ] + dist.all_gather(tensor_list, tensor, group=group) + if return_tensor: + return torch.stack(tensor_list, dim=0) + else: + return tensor_list + + +def all_gather_list(data, group=None, max_size=16384): + """Gathers arbitrary data from all nodes into a list. + + Similar to :func:`~torch.distributed.all_gather` but for arbitrary Python + data. Note that *data* must be picklable and any CUDA tensors will be moved + to CPU and returned on CPU as well. + + Args: + data (Any): data from the local worker to be gathered on other workers + group: group of the collective + max_size (int, optional): maximum size of the data to be gathered + across workers + """ + from fairseq import utils + + if group is None: + group = get_global_group() + rank = get_rank(group=group) + world_size = get_world_size(group=group) + + buffer_size = max_size * world_size + if ( + not hasattr(all_gather_list, "_buffer") + or all_gather_list._buffer.numel() < buffer_size + ): + all_gather_list._buffer = torch.cuda.ByteTensor(buffer_size) + all_gather_list._cpu_buffer = torch.ByteTensor(max_size).pin_memory() + buffer = all_gather_list._buffer + buffer.zero_() + cpu_buffer = all_gather_list._cpu_buffer + + data = utils.move_to_cpu(data) + enc = pickle.dumps(data) + enc_size = len(enc) + header_size = 4 # size of header that contains the length of the encoded data + size = header_size + enc_size + if size > max_size: + raise ValueError( + "encoded data size ({}) exceeds max_size ({})".format(size, max_size) + ) + + header = struct.pack(">I", enc_size) + cpu_buffer[:size] = torch.ByteTensor(list(header + enc)) + start = rank * max_size + buffer[start : start + size].copy_(cpu_buffer[:size]) + + all_reduce(buffer, group=group) + + buffer = buffer.cpu() + try: + result = [] + for i in range(world_size): + out_buffer = buffer[i * max_size : (i + 1) * max_size] + (enc_size,) = struct.unpack(">I", bytes(out_buffer[:header_size].tolist())) + if enc_size > 0: + result.append( + pickle.loads( + bytes(out_buffer[header_size : header_size + enc_size].tolist()) + ) + ) + return result + except pickle.UnpicklingError: + raise Exception( + "Unable to unpickle data from other workers. all_gather_list requires all " + "workers to enter the function together, so this error usually indicates " + "that the workers have fallen out of sync somehow. Workers can fall out of " + "sync if one of them runs out of memory, or if there are other conditions " + "in your training script that can cause one worker to finish an epoch " + "while other workers are still iterating over their portions of the data. " + "Try rerunning with --ddp-backend=legacy_ddp and see if that helps." + ) + + +def all_reduce_dict(data: Mapping[str, Any], device, group) -> Dict[str, Any]: + """ + AllReduce a dictionary of values across workers. We separately + reduce items that are already on the device and items on CPU for + better performance. + + Args: + data (Mapping[str, Any]): dictionary of data to all-reduce, but + cannot be a nested dictionary + device (torch.device): device for the reduction + group: group of the collective + """ + data_keys = list(data.keys()) + + # We want to separately reduce items that are already on the + # device and items on CPU for performance reasons. + cpu_data = OrderedDict() + device_data = OrderedDict() + for k in data_keys: + t = data[k] + if not torch.is_tensor(t): + cpu_data[k] = torch.tensor(t, dtype=torch.double) + elif t.device.type != device.type: + cpu_data[k] = t.to(dtype=torch.double) + else: + device_data[k] = t.to(dtype=torch.double) + + def _all_reduce_dict(data: OrderedDict): + if len(data) == 0: + return data + buf = torch.cat([t.view(-1) for t in data.values()]).to(device=device) + all_reduce(buf, group=group) + split_buf = torch.split(buf.clone(), [t.numel() for t in data.values()]) + reduced_data = [t.view_as(orig) for t, orig in zip(split_buf, data.values())] + return OrderedDict(zip(data.keys(), reduced_data)) + + cpu_data = _all_reduce_dict(cpu_data) + device_data = _all_reduce_dict(device_data) + + def get_from_stack(key): + if key in cpu_data: + return cpu_data[key] + elif key in device_data: + return device_data[key] + raise KeyError + + return OrderedDict([(key, get_from_stack(key)) for key in data_keys]) + + +def broadcast_tensors( + tensors: Optional[List[torch.Tensor]], + src_rank: int, + group: object, + dist_device: Optional[torch.device] = None, +) -> List[torch.Tensor]: + """ + Broadcasts a list of tensors without other (non-src) ranks needing to know + the dtypes/shapes of the tensors. + """ + if dist_device is None: + if torch.distributed.get_backend(group) == "nccl": + dist_device = torch.device("cuda") + else: + dist_device = torch.device("cpu") + + # share metadata first to simplify transfer + is_src_rank = get_rank(group) == src_rank + if is_src_rank: + metadata = [ + {"size": t.size(), "dtype": t.dtype, "device": t.device} for t in tensors + ] + metadata = _broadcast_object_slow(metadata, src_rank, group, dist_device) + else: + metadata = _broadcast_object_slow(None, src_rank, group, dist_device) + + out_tensors = [] + for i, meta in enumerate(metadata): + if is_src_rank: + tensor = tensors[i] + broadcast(tensors[i].to(dist_device), src=src_rank, group=group) + else: + tensor = torch.zeros( + [meta["size"].numel()], dtype=meta["dtype"], device=dist_device + ) + broadcast(tensor, src=src_rank, group=group) + tensor = tensor.view(meta["size"]).to(meta["device"]) + out_tensors.append(tensor) + return out_tensors + + +def broadcast_object( + obj: Any, + src_rank: int, + group: object, + dist_device: Optional[torch.device] = None, +) -> Any: + """Broadcast an arbitrary Python object to other workers.""" + if dist_device is None: + if torch.distributed.get_backend(group) == "nccl": + dist_device = torch.device("cuda") + else: + dist_device = torch.device("cpu") + + if get_rank(group) == src_rank: + # split the tensors from the non-tensors so we can broadcast them + # directly, avoiding unnecessary serialization/deserialization + tensors = [] + obj = _split_tensors_from_obj(obj, tensors) + obj = _broadcast_object_slow(obj, src_rank, group, dist_device) + tensors = broadcast_tensors(tensors, src_rank, group, dist_device) + else: + obj = _broadcast_object_slow(None, src_rank, group, dist_device) + tensors = broadcast_tensors(None, src_rank, group, dist_device) + return _put_tensors_in_obj(obj, tensors) + + +def _broadcast_object_slow( + obj: Any, + src_rank: int, + group: object, + dist_device: torch.device, +) -> Any: + if get_rank(group) == src_rank: + # Emit data + buffer = io.BytesIO() + torch.save(obj, buffer) + buffer = torch.ByteTensor(buffer.getbuffer()).to(dist_device) + length = torch.LongTensor([len(buffer)]).to(dist_device) + broadcast(length, src=src_rank, group=group) + broadcast(buffer, src=src_rank, group=group) + else: + # Fetch from the source + length = torch.LongTensor([0]).to(dist_device) + broadcast(length, src=src_rank, group=group) + buffer = torch.ByteTensor(int(length.item())).to(dist_device) + broadcast(buffer, src=src_rank, group=group) + buffer = io.BytesIO(buffer.cpu().numpy()) + obj = torch.load(buffer, map_location="cpu") + return obj + + +@dataclass(frozen=True) +class _TensorPlaceholder: + index: int + + +def _split_tensors_from_obj(obj: Any, tensors: List[torch.Tensor]) -> Any: + if torch.is_tensor(obj): + placeholder = _TensorPlaceholder(index=len(tensors)) + tensors.append(obj) + return placeholder + elif isinstance(obj, dict): + return {k: _split_tensors_from_obj(v, tensors) for k, v in obj.items()} + elif isinstance(obj, list): + return [_split_tensors_from_obj(v, tensors) for v in obj] + elif isinstance(obj, tuple): + return tuple(_split_tensors_from_obj(v, tensors) for v in obj) + elif isinstance(obj, set): + return {_split_tensors_from_obj(v, tensors) for v in obj} + else: + return obj + + +def _put_tensors_in_obj(obj: Any, tensors: List[torch.Tensor]) -> Any: + if isinstance(obj, _TensorPlaceholder): + return tensors[obj.index] + elif isinstance(obj, dict): + return {k: _put_tensors_in_obj(v, tensors) for k, v in obj.items()} + elif isinstance(obj, list): + return [_put_tensors_in_obj(v, tensors) for v in obj] + elif isinstance(obj, tuple): + return tuple(_put_tensors_in_obj(v, tensors) for v in obj) + elif isinstance(obj, set): + return {_put_tensors_in_obj(v, tensors) for v in obj} + else: + return obj diff --git a/data/fairseq/fairseq/libbase.cpython-38-x86_64-linux-gnu.so b/data/fairseq/fairseq/libbase.cpython-38-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..62136140a03b26fdc0b9ee98a3620bfb6cefd669 --- /dev/null +++ b/data/fairseq/fairseq/libbase.cpython-38-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:31643862b43b0048d0e7941fb4961c9a459573eada9167aadb01f3bfaae4c5c4 +size 9223248 diff --git a/data/fairseq/fairseq/libbleu.cpython-38-x86_64-linux-gnu.so b/data/fairseq/fairseq/libbleu.cpython-38-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..52f3bc61ce10ef27e0dd71d2d6b05974852da552 --- /dev/null +++ b/data/fairseq/fairseq/libbleu.cpython-38-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b2c589da6010faf057d6a80997a9e7b03fe105ae4144e0cbd5ca2791c24201c2 +size 125112 diff --git a/data/fairseq/fairseq/libnat.cpython-38-x86_64-linux-gnu.so b/data/fairseq/fairseq/libnat.cpython-38-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..1373474d451b48a28a8c2d103dee89304b5911f6 --- /dev/null +++ b/data/fairseq/fairseq/libnat.cpython-38-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f9dd8196115f2eeee03623339d6b88dc800d9377a6cb5a11e43ea40ba38edb42 +size 9300656 diff --git a/nllb-mni-lsftl/checkpoint-26112/adapter_model.safetensors b/nllb-mni-lsftl/checkpoint-26112/adapter_model.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..6fbbe1a6df2e1028b7126038bf9058035df121d4 --- /dev/null +++ b/nllb-mni-lsftl/checkpoint-26112/adapter_model.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:26424799753a3c5b4bc0665039a089967626c4317b2e58e22550e9063a0df25b +size 18915448 diff --git a/nllb-mni-lsftl/checkpoint-26112/optimizer.pt b/nllb-mni-lsftl/checkpoint-26112/optimizer.pt new file mode 100644 index 0000000000000000000000000000000000000000..5ce948a7a45a316fba525d4c6d9c8f782623c991 --- /dev/null +++ b/nllb-mni-lsftl/checkpoint-26112/optimizer.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:07a2f3a5acf54a9fc7ff12601f6be6905fb1c58690219e22fafd48465b50df92 +size 37990394 diff --git a/nllb-mni-lsftl/checkpoint-26112/rng_state.pth b/nllb-mni-lsftl/checkpoint-26112/rng_state.pth new file mode 100644 index 0000000000000000000000000000000000000000..578612a555f69808641837e46196ff23fe42e675 --- /dev/null +++ b/nllb-mni-lsftl/checkpoint-26112/rng_state.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9994bfd5687272267ea0ce4b42f21b11fc813acf3fce6b76250dda6d29e5e4b9 +size 14244 diff --git a/nllb-mni-lsftl/checkpoint-26112/scheduler.pt b/nllb-mni-lsftl/checkpoint-26112/scheduler.pt new file mode 100644 index 0000000000000000000000000000000000000000..597a9b30e5bc96d1ef61f158f1f0b8bdded71297 --- /dev/null +++ b/nllb-mni-lsftl/checkpoint-26112/scheduler.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:edc5655750c6f05a036866292ae83cc3bb0795a91f41abfb205218a5e4541dbd +size 1064 diff --git a/nllb-mni-lsftl/checkpoint-26112/sentencepiece.bpe.model b/nllb-mni-lsftl/checkpoint-26112/sentencepiece.bpe.model new file mode 100644 index 0000000000000000000000000000000000000000..dc2262d3e1d375b235eb71c24119c8e73f85d4ad --- /dev/null +++ b/nllb-mni-lsftl/checkpoint-26112/sentencepiece.bpe.model @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:14bb8dfb35c0ffdea7bc01e56cea38b9e3d5efcdcb9c251d6b40538e1aab555a +size 4852054 diff --git a/nllb-mni-lsftl/checkpoint-26112/tokenizer.json b/nllb-mni-lsftl/checkpoint-26112/tokenizer.json new file mode 100644 index 0000000000000000000000000000000000000000..461a2202b7d3c032e0de66101269ee1c9815f374 --- /dev/null +++ b/nllb-mni-lsftl/checkpoint-26112/tokenizer.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:570293b084645660e4881a8acf17c2c28dac07a64b17cc0dca332ef61fb1b0b9 +size 32240234 diff --git a/nllb-mni-lsftl/checkpoint-26112/training_args.bin b/nllb-mni-lsftl/checkpoint-26112/training_args.bin new file mode 100644 index 0000000000000000000000000000000000000000..fb9a96893eec79a98bd702037b3f40a7ae357af8 --- /dev/null +++ b/nllb-mni-lsftl/checkpoint-26112/training_args.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f639c23602880e8ebe4b89a8d32455751bc25a0aefb5003b274d30f8d86e75fb +size 5432 diff --git a/nllb-mni-lsftl/runs/Apr25_12-53-58_cs-01kq2a9tgy56g3y86a8pwq4qae/events.out.tfevents.1777121639.cs-01kq2a9tgy56g3y86a8pwq4qae b/nllb-mni-lsftl/runs/Apr25_12-53-58_cs-01kq2a9tgy56g3y86a8pwq4qae/events.out.tfevents.1777121639.cs-01kq2a9tgy56g3y86a8pwq4qae new file mode 100644 index 0000000000000000000000000000000000000000..429627e89b0ad3cbb50c6cbeceacf0b9d25b46d3 --- /dev/null +++ b/nllb-mni-lsftl/runs/Apr25_12-53-58_cs-01kq2a9tgy56g3y86a8pwq4qae/events.out.tfevents.1777121639.cs-01kq2a9tgy56g3y86a8pwq4qae @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a6633af648ea0f3ff2f14b39b9db2152277b91b84d34d9f23e833ca0f645603f +size 561512 diff --git a/nllb-mni-lsftl/runs/Apr25_12-53-58_cs-01kq2a9tgy56g3y86a8pwq4qae/events.out.tfevents.1777143517.cs-01kq2a9tgy56g3y86a8pwq4qae b/nllb-mni-lsftl/runs/Apr25_12-53-58_cs-01kq2a9tgy56g3y86a8pwq4qae/events.out.tfevents.1777143517.cs-01kq2a9tgy56g3y86a8pwq4qae new file mode 100644 index 0000000000000000000000000000000000000000..85eecdd7894abb9d0179d39f03ee2595f0bb0342 --- /dev/null +++ b/nllb-mni-lsftl/runs/Apr25_12-53-58_cs-01kq2a9tgy56g3y86a8pwq4qae/events.out.tfevents.1777143517.cs-01kq2a9tgy56g3y86a8pwq4qae @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9fc8aced0a2621ad3979a11f8f83d8daa92deccf9143c5f3193de92577eff13 +size 365