Upload 35 files

.gitattributes

@@ -33,3 +33,6 @@ 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
+dist/assets/FAT5_dark.gif filter=lfs diff=lfs merge=lfs -text
+dist/assets/FAT5.gif filter=lfs diff=lfs merge=lfs -text
+dist/assets/LinFAT5_dark.gif filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,10 +1,10 @@
 ---
-title: FAT5 Rapport
-emoji: 📊
-colorFrom: purple
-colorTo: green
+title: 'Le FAT5 : Flash Attention T5'
+emoji: ⚡
+colorFrom: blue
+colorTo: red
 sdk: static
 pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+header: default
+app_file: dist/index.html
+---

dist/bibliography.bib

@@ -0,0 +1,590 @@
+@article{JMLR:v21:20-074,
+  author  = {Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu},
+  title   = {Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer},
+  journal = {Journal of Machine Learning Research},
+  year    = {2020},
+  volume  = {21},
+  number  = {140},
+  pages   = {1--67},
+  url     = {http://jmlr.org/papers/v21/20-074.html}
+}
+@misc{chia2023instructeval,
+      title={INSTRUCTEVAL: Towards Holistic Evaluation of Instruction-Tuned Large Language Models}, 
+      author={Yew Ken Chia and Pengfei Hong and Lidong Bing and Soujanya Poria},
+      year={2023},
+      url={https://arxiv.org/abs/2306.04757},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{fu2024tiny,
+      title={Tiny Titans: Can Smaller Large Language Models Punch Above Their Weight in the Real World for Meeting Summarization?}, 
+      author={Xue-Yong Fu and Md Tahmid Rahman Laskar and Elena Khasanova and Cheng Chen and Shashi Bhushan TN},
+      year={2024},
+      url={https://arxiv.org/abs/2402.00841},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{hsieh2023distilling,
+      title={Distilling Step-by-Step! Outperforming Larger Language Models with Less Training Data and Smaller Model Sizes}, 
+      author={Cheng-Yu Hsieh and Chun-Liang Li and Chih-Kuan Yeh and Hootan Nakhost and Yasuhisa Fujii and Alexander Ratner and Ranjay Krishna and Chen-Yu Lee and Tomas Pfister},
+      year={2023},
+      url={https://arxiv.org/abs/2305.02301},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{nawrot2023nanot5,
+      title={nanoT5: A PyTorch Framework for Pre-training and Fine-tuning T5-style Models with Limited Resources}, 
+      author={Piotr Nawrot},
+      year={2023},
+      url={https://arxiv.org/abs/2309.02373},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{tay2023ul2,
+      title={UL2: Unifying Language Learning Paradigms}, 
+      author={Yi Tay and Mostafa Dehghani and Vinh Q. Tran and Xavier Garcia and Jason Wei and Xuezhi Wang and Hyung Won Chung and Siamak Shakeri and Dara Bahri and Tal Schuster and Huaixiu Steven Zheng and Denny Zhou and Neil Houlsby and Donald Metzler},
+      year={2023},
+      url={https://arxiv.org/abs/2205.05131},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{dao2022flashattention,
+      title={FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness}, 
+      author={Tri Dao and Daniel Y. Fu and Stefano Ermon and Atri Rudra and Christopher Ré},
+      year={2022},
+      url={https://arxiv.org/abs/2205.14135},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+@misc{turbot5,
+      title={TurboT5}, 
+      author={Knowledgator},
+      year={2024},
+      publisher={GitHub},
+      url={https://github.com/Knowledgator/TurboT5},
+}
+@misc{nguyen2023culturax,
+      title={CulturaX: A Cleaned, Enormous, and Multilingual Dataset for Large Language Models in 167 Languages}, 
+      author={Thuat Nguyen and Chien Van Nguyen and Viet Dac Lai and Hieu Man and Nghia Trung Ngo and Franck Dernoncourt and Ryan A. Rossi and Thien Huu Nguyen},
+      year={2023},
+      url={https://arxiv.org/abs/2309.09400},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{leclerc2023ffcv,
+      title={FFCV: Accelerating Training by Removing Data Bottlenecks}, 
+      author={Guillaume Leclerc and Andrew Ilyas and Logan Engstrom and Sung Min Park and Hadi Salman and Aleksander Madry},
+      year={2023},
+      url={https://arxiv.org/abs/2306.12517},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+@misc{lhoest2021datasets,
+      title={Datasets: A Community Library for Natural Language Processing}, 
+      author={Quentin Lhoest and Albert Villanova del Moral and Yacine Jernite and Abhishek Thakur and Patrick von Platen and Suraj Patil and Julien Chaumond and Mariama Drame and Julien Plu and Lewis Tunstall and Joe Davison and Mario Šaško and Gunjan Chhablani and Bhavitvya Malik and Simon Brandeis and Teven Le Scao and Victor Sanh and Canwen Xu and Nicolas Patry and Angelina McMillan-Major and Philipp Schmid and Sylvain Gugger and Clément Delangue and Théo Matussière and Lysandre Debut and Stas Bekman and Pierric Cistac and Thibault Goehringer and Victor Mustar and François Lagunas and Alexander M. Rush and Thomas Wolf},
+      year={2021},
+      url={https://arxiv.org/abs/2109.02846},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{paszke2019pytorch,
+      title={PyTorch: An Imperative Style, High-Performance Deep Learning Library}, 
+      author={Adam Paszke and Sam Gross and Francisco Massa and Adam Lerer and James Bradbury and Gregory Chanan and Trevor Killeen and Zeming Lin and Natalia Gimelshein and Luca Antiga and Alban Desmaison and Andreas Köpf and Edward Yang and Zach DeVito and Martin Raison and Alykhan Tejani and Sasank Chilamkurthy and Benoit Steiner and Lu Fang and Junjie Bai and Soumith Chintala},
+      year={2019},
+      url={https://arxiv.org/abs/1912.01703},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+@inproceedings{10.1145/2833157.2833162,
+author = {Lam, Siu Kwan and Pitrou, Antoine and Seibert, Stanley},
+title = {Numba: a LLVM-based Python JIT compiler},
+year = {2015},
+isbn = {9781450340052},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+url = {https://doi.org/10.1145/2833157.2833162},
+doi = {10.1145/2833157.2833162},
+abstract = {Dynamic, interpreted languages, like Python, are attractive for domain-experts and scientists experimenting with new ideas. However, the performance of the interpreter is often a barrier when scaling to larger data sets. This paper presents a just-in-time compiler for Python that focuses in scientific and array-oriented computing. Starting with the simple syntax of Python, Numba compiles a subset of the language into efficient machine code that is comparable in performance to a traditional compiled language. In addition, we share our experience in building a JIT compiler using LLVM[1].},
+booktitle = {Proceedings of the Second Workshop on the LLVM Compiler Infrastructure in HPC},
+articleno = {7},
+numpages = {6},
+keywords = {compiler, Python, LLVM},
+location = {Austin, Texas},
+series = {LLVM '15}
+}
+@inproceedings{10.1145/3315508.3329973,
+author = {Tillet, Philippe and Kung, H. T. and Cox, David},
+title = {Triton: an intermediate language and compiler for tiled neural network computations},
+year = {2019},
+isbn = {9781450367196},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+url = {https://doi.org/10.1145/3315508.3329973},
+doi = {10.1145/3315508.3329973},
+abstract = {The validation and deployment of novel research ideas in the field of Deep Learning is often limited by the availability of efficient compute kernels for certain basic primitives. In particular, operations that cannot leverage existing vendor libraries (e.g., cuBLAS, cuDNN) are at risk of facing poor device utilization unless custom implementations are written by experts – usually at the expense of portability. For this reason, the development of new programming abstractions for specifying custom Deep Learning workloads at a minimal performance cost has become crucial. We present Triton, a language and compiler centered around the concept of tile, i.e., statically shaped multi-dimensional sub-arrays. Our approach revolves around (1) a C-based language and an LLVM-based intermediate representation (IR) for expressing tensor programs in terms of operations on parametric tile variables and (2) a set of novel tile-level optimization passes for compiling these programs into efficient GPU code. We demonstrate how Triton can be used to build portable implementations of matrix multiplication and convolution kernels on par with hand-tuned vendor libraries (cuBLAS / cuDNN), or for efficiently implementing recent research ideas such as shift convolutions.},
+booktitle = {Proceedings of the 3rd ACM SIGPLAN International Workshop on Machine Learning and Programming Languages},
+pages = {10–19},
+numpages = {10},
+keywords = {GPU, compiler, neural networks},
+location = {Phoenix, AZ, USA},
+series = {MAPL 2019}
+}
+@misc{flagattention,
+      title={FlagAttention}, 
+      author={FlagOpen},
+      year={2023},
+      publisher={GitHub},
+      title={https://github.com/FlagOpen/FlagAttention}
+}
+@misc{nvidiapex,
+      title={Apex}, 
+      author={NVIDIA},
+      year={2018},
+      publisher={GitHub},
+      url={https://github.com/NVIDIA/apex},
+}
+@misc{jansen2022perplexed,
+      title={Perplexed by Quality: A Perplexity-based Method for Adult and Harmful Content Detection in Multilingual Heterogeneous Web Data}, 
+      author={Tim Jansen and Yangling Tong and Victoria Zevallos and Pedro Ortiz Suarez},
+      year={2022},
+      url={https://arxiv.org/abs/2212.10440},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{micikevicius2018mixed,
+      title={Mixed Precision Training}, 
+      author={Paulius Micikevicius and Sharan Narang and Jonah Alben and Gregory Diamos and Erich Elsen and David Garcia and Boris Ginsburg and Michael Houston and Oleksii Kuchaiev and Ganesh Venkatesh and Hao Wu},
+      year={2018},
+      url={https://arxiv.org/abs/1710.03740},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI}
+}
+@misc{you2020large,
+      title={Large Batch Optimization for Deep Learning: Training BERT in 76 minutes}, 
+      author={Yang You and Jing Li and Sashank Reddi and Jonathan Hseu and Sanjiv Kumar and Srinadh Bhojanapalli and Xiaodan Song and James Demmel and Kurt Keutzer and Cho-Jui Hsieh},
+      year={2020},
+      url={https://arxiv.org/abs/1904.00962},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+@misc{liu2024sophia,
+      title={Sophia: A Scalable Stochastic Second-order Optimizer for Language Model Pre-training}, 
+      author={Hong Liu and Zhiyuan Li and David Hall and Percy Liang and Tengyu Ma},
+      year={2024},
+      url={https://arxiv.org/abs/2305.14342},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+@misc{rajbhandari2020zero,
+      title={ZeRO: Memory Optimizations Toward Training Trillion Parameter Models}, 
+      author={Samyam Rajbhandari and Jeff Rasley and Olatunji Ruwase and Yuxiong He},
+      year={2020},
+      url={https://arxiv.org/abs/1910.02054},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+@misc{debrébisson2016zloss,
+      title={The Z-loss: a shift and scale invariant classification loss belonging to the Spherical Family}, 
+      author={Alexandre de Brébisson and Pascal Vincent},
+      year={2016},
+      url={https://arxiv.org/abs/1604.08859},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+@misc{zhang2019root,
+      title={Root Mean Square Layer Normalization}, 
+      author={Biao Zhang and Rico Sennrich},
+      year={2019},
+      url={https://arxiv.org/abs/1910.07467},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+@misc{liu2021pay,
+      title={Pay Attention to MLPs}, 
+      author={Hanxiao Liu and Zihang Dai and David R. So and Quoc V. Le},
+      year={2021},
+      url={https://arxiv.org/abs/2105.08050},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+@misc{wolf2020huggingfaces,
+      title={HuggingFace's Transformers: State-of-the-art Natural Language Processing}, 
+      author={Thomas Wolf and Lysandre Debut and Victor Sanh and Julien Chaumond and Clement Delangue and Anthony Moi and Pierric Cistac and Tim Rault and Rémi Louf and Morgan Funtowicz and Joe Davison and Sam Shleifer and Patrick von Platen and Clara Ma and Yacine Jernite and Julien Plu and Canwen Xu and Teven Le Scao and Sylvain Gugger and Mariama Drame and Quentin Lhoest and Alexander M. Rush},
+      year={2020},
+      url={https://arxiv.org/abs/1910.03771},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{liu2022enct5,
+      title={EncT5: A Framework for Fine-tuning T5 as Non-autoregressive Models}, 
+      author={Frederick Liu and Terry Huang and Shihang Lyu and Siamak Shakeri and Hongkun Yu and Jing Li},
+      year={2022},
+      url={https://arxiv.org/abs/2110.08426},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{shaw2018selfattention,
+      title={Self-Attention with Relative Position Representations}, 
+      author={Peter Shaw and Jakob Uszkoreit and Ashish Vaswani},
+      year={2018},
+      url={https://arxiv.org/abs/1803.02155},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{press2022train,
+      title={Train Short, Test Long: Attention with Linear Biases Enables Input Length Extrapolation}, 
+      author={Ofir Press and Noah A. Smith and Mike Lewis},
+      year={2022},
+      url={https://arxiv.org/abs/2108.12409},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{su2023roformer,
+      title={RoFormer: Enhanced Transformer with Rotary Position Embedding}, 
+      author={Jianlin Su and Yu Lu and Shengfeng Pan and Ahmed Murtadha and Bo Wen and Yunfeng Liu},
+      year={2023},
+      url={https://arxiv.org/abs/2104.09864},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{li2024functional,
+      title={Functional Interpolation for Relative Positions Improves Long Context Transformers}, 
+      author={Shanda Li and Chong You and Guru Guruganesh and Joshua Ainslie and Santiago Ontanon and Manzil Zaheer and Sumit Sanghai and Yiming Yang and Sanjiv Kumar and Srinadh Bhojanapalli},
+      year={2024},
+      url={https://arxiv.org/abs/2310.04418},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+@misc{lacoste2019quantifying,
+      title={Quantifying the Carbon Emissions of Machine Learning}, 
+      author={Alexandre Lacoste and Alexandra Luccioni and Victor Schmidt and Thomas Dandres},
+      year={2019},
+      url={https://arxiv.org/abs/1910.09700},
+      archivePrefix={arXiv},
+      primaryClass={cs.CY}
+}
+@misc{devlin2019bert,
+      title={BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding}, 
+      author={Jacob Devlin and Ming-Wei Chang and Kenton Lee and Kristina Toutanova},
+      year={2019},
+      url={https://arxiv.org/abs/1810.04805},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{eddine2021barthez,
+      title={BARThez: a Skilled Pretrained French Sequence-to-Sequence Model}, 
+      author={Moussa Kamal Eddine and Antoine J. -P. Tixier and Michalis Vazirgiannis},
+      year={2021},
+      url={https://arxiv.org/abs/2010.12321},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+}
+@misc{allocine,
+      title={French sentiment analysis with BERT}, 
+      author={Théophile Blard},
+      year={2020},
+      url={https://arxiv.org/abs/https://github.com/TheophileBlard/french-sentiment-analysis-with-bert},
+}
+@misc{delestre2022distilcamembert,
+      title={DistilCamemBERT: a distillation of the French model CamemBERT}, 
+      author={Cyrile Delestre and Abibatou Amar},
+      year={2022},
+      url={https://arxiv.org/abs/2205.11111},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc {frenchQA2023,  
+    author       = { ALBAR, Boris and BEDU, Pierre and BOURDOIS, Loïck },  
+    organization  = { Centre Aquitain des Technologies de l'Information et Electroniques },  
+    title        = { frenchQA (Revision 6249cd5) },  
+    year         = 2023,  
+    url          = { https://huggingface.co/CATIE-AQ/frenchQA },  
+    doi          = { 10.57967/hf/0862 },  
+    publisher    = { Hugging Face }  
+}
+@misc {frenchNER2024,
+    author       = { BOURDOIS, Loïck },  
+    organization = { Centre Aquitain des Technologies de l'Information et Electroniques },  
+    title        = { frenchNER_4entities (Revision f1e8fef) },
+    year         = 2024,
+    url          = { https://huggingface.co/datasets/CATIE-AQ/frenchNER_4entities },
+    doi          = { 10.57967/hf/1751 },
+    publisher    = { Hugging Face }
+}
+@misc{lacoste2019quantifying,
+      title={Quantifying the Carbon Emissions of Machine Learning}, 
+      author={Alexandre Lacoste and Alexandra Luccioni and Victor Schmidt and Thomas Dandres},
+      year={2019},
+      url={https://arxiv.org/abs/1910.09700},
+      archivePrefix={arXiv},
+      primaryClass={cs.CY}
+}
+@inproceedings{Martin_2020,
+   title={CamemBERT: a Tasty French Language Model},
+   url={http://dx.doi.org/10.18653/v1/2020.acl-main.645},
+   DOI={10.18653/v1/2020.acl-main.645},
+   booktitle={Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics},
+   publisher={Association for Computational Linguistics},
+   author={Martin, Louis and Muller, Benjamin and Ortiz Suárez, Pedro Javier and Dupont, Yoann and Romary, Laurent and de la Clergerie, Éric and Seddah, Djamé and Sagot, Benoît},
+   year={2020} }
+@misc{le2020flaubert,
+      title={FlauBERT: Unsupervised Language Model Pre-training for French}, 
+      author={Hang Le and Loïc Vial and Jibril Frej and Vincent Segonne and Maximin Coavoux and Benjamin Lecouteux and Alexandre Allauzen and Benoît Crabbé and Laurent Besacier and Didier Schwab},
+      year={2020},
+      url={https://arxiv.org/abs/1912.05372},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{chung2022scaling,
+      title={Scaling Instruction-Finetuned Language Models}, 
+      author={Hyung Won Chung and Le Hou and Shayne Longpre and Barret Zoph and Yi Tay and William Fedus and Yunxuan Li and Xuezhi Wang and Mostafa Dehghani and Siddhartha Brahma and Albert Webson and Shixiang Shane Gu and Zhuyun Dai and Mirac Suzgun and Xinyun Chen and Aakanksha Chowdhery and Alex Castro-Ros and Marie Pellat and Kevin Robinson and Dasha Valter and Sharan Narang and Gaurav Mishra and Adams Yu and Vincent Zhao and Yanping Huang and Andrew Dai and Hongkun Yu and Slav Petrov and Ed H. Chi and Jeff Dean and Jacob Devlin and Adam Roberts and Denny Zhou and Quoc V. Le and Jason Wei},
+      year={2022},
+      url={https://arxiv.org/abs/2210.11416},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+@misc{guo2022longt5,
+      title={LongT5: Efficient Text-To-Text Transformer for Long Sequences}, 
+      author={Mandy Guo and Joshua Ainslie and David Uthus and Santiago Ontanon and Jianmo Ni and Yun-Hsuan Sung and Yinfei Yang},
+      year={2022},
+      url={https://arxiv.org/abs/2112.07916},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{arora2024simple,
+      title={Simple linear attention language models balance the recall-throughput tradeoff}, 
+      author={Simran Arora and Sabri Eyuboglu and Michael Zhang and Aman Timalsina and Silas Alberti and Dylan Zinsley and James Zou and Atri Rudra and Christopher Ré},
+      year={2024},
+      url={https://arxiv.org/abs/2402.18668},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+@misc{zhang2024hedgehog,
+      title={The Hedgehog & the Porcupine: Expressive Linear Attentions with Softmax Mimicry}, 
+      author={Michael Zhang and Kush Bhatia and Hermann Kumbong and Christopher Ré},
+      year={2024},
+      url={https://arxiv.org/abs/2402.04347},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+@misc{thunderkittens ,
+      title={ThunderKittens}, 
+      author={HazyResearch},
+      year={2024},
+      publisher={GitHub},
+      url={https://github.com/HazyResearch/ThunderKittens},
+}
+@misc{flashdecoding ,
+      title={Flash-Decoding for long-context inference}, 
+      author={Tri Dao and Daniel Haziza and Francisco Massa and Grigory Sizov},
+      year={2023},
+      url={https://crfm.stanford.edu/2023/10/12/flashdecoding.html}, 
+}
+@InProceedings{huggingface:dataset:stsb_multi_mt,
+title = {Machine translated multilingual STS benchmark dataset.},
+author={Philip May},
+year={2021},
+url={https://github.com/PhilipMay/stsb-multi-mt}
+}
+@misc{ciancone2024mtebfrenchresourcesfrenchsentence,
+      title={MTEB-French: Resources for French Sentence Embedding Evaluation and Analysis}, 
+      author={Mathieu Ciancone and Imene Kerboua and Marion Schaeffer and Wissam Siblini},
+      year={2024},
+      eprint={2405.20468},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2405.20468}, 
+}
+@misc{dubey2024llama3herdmodels,
+      title={The Llama 3 Herd of Models}, 
+      author={Abhimanyu Dubey and Abhinav Jauhri and Abhinav Pandey and Abhishek Kadian and Ahmad Al-Dahle and Aiesha Letman and Akhil Mathur and Alan Schelten and Amy Yang and Angela Fan and Anirudh Goyal and Anthony Hartshorn and Aobo Yang and Archi Mitra and Archie Sravankumar and Artem Korenev and Arthur Hinsvark and Arun Rao and Aston Zhang and Aurelien Rodriguez and Austen Gregerson and Ava Spataru and Baptiste Roziere and Bethany Biron and Binh Tang and Bobbie Chern and Charlotte Caucheteux and Chaya Nayak and Chloe Bi and Chris Marra and Chris McConnell and Christian Keller and Christophe Touret and Chunyang Wu and Corinne Wong and Cristian Canton Ferrer and Cyrus Nikolaidis and Damien Allonsius and Daniel Song and Danielle Pintz and Danny Livshits and David Esiobu and Dhruv Choudhary and Dhruv Mahajan and Diego Garcia-Olano and Diego Perino and Dieuwke Hupkes and Egor Lakomkin and Ehab AlBadawy and Elina Lobanova and Emily Dinan and Eric Michael Smith and Filip Radenovic and Frank Zhang and Gabriel Synnaeve and Gabrielle Lee and Georgia Lewis Anderson and Graeme Nail and Gregoire Mialon and Guan Pang and Guillem Cucurell and Hailey Nguyen and Hannah Korevaar and Hu Xu and Hugo Touvron and Iliyan Zarov and Imanol Arrieta Ibarra and Isabel Kloumann and Ishan Misra and Ivan Evtimov and Jade Copet and Jaewon Lee and Jan Geffert and Jana Vranes and Jason Park and Jay Mahadeokar and Jeet Shah and Jelmer van der Linde and Jennifer Billock and Jenny Hong and Jenya Lee and Jeremy Fu and Jianfeng Chi and Jianyu Huang and Jiawen Liu and Jie Wang and Jiecao Yu and Joanna Bitton and Joe Spisak and Jongsoo Park and Joseph Rocca and Joshua Johnstun and Joshua Saxe and Junteng Jia and Kalyan Vasuden Alwala and Kartikeya Upasani and Kate Plawiak and Ke Li and Kenneth Heafield and Kevin Stone and Khalid El-Arini and Krithika Iyer and Kshitiz Malik and Kuenley Chiu and Kunal Bhalla and Lauren Rantala-Yeary and Laurens van der Maaten and Lawrence Chen and Liang Tan and Liz Jenkins and Louis Martin and Lovish Madaan and Lubo Malo and Lukas Blecher and Lukas Landzaat and Luke de Oliveira and Madeline Muzzi and Mahesh Pasupuleti and Mannat Singh and Manohar Paluri and Marcin Kardas and Mathew Oldham and Mathieu Rita and Maya Pavlova and Melanie Kambadur and Mike Lewis and Min Si and Mitesh Kumar Singh and Mona Hassan and Naman Goyal and Narjes Torabi and Nikolay Bashlykov and Nikolay Bogoychev and Niladri Chatterji and Olivier Duchenne and Onur Çelebi and Patrick Alrassy and Pengchuan Zhang and Pengwei Li and Petar Vasic and Peter Weng and Prajjwal Bhargava and Pratik Dubal and Praveen Krishnan and Punit Singh Koura and Puxin Xu and Qing He and Qingxiao Dong and Ragavan Srinivasan and Raj Ganapathy and Ramon Calderer and Ricardo Silveira Cabral and Robert Stojnic and Roberta Raileanu and Rohit Girdhar and Rohit Patel and Romain Sauvestre and Ronnie Polidoro and Roshan Sumbaly and Ross Taylor and Ruan Silva and Rui Hou and Rui Wang and Saghar Hosseini and Sahana Chennabasappa and Sanjay Singh and Sean Bell and Seohyun Sonia Kim and Sergey Edunov and Shaoliang Nie and Sharan Narang and Sharath Raparthy and Sheng Shen and Shengye Wan and Shruti Bhosale and Shun Zhang and Simon Vandenhende and Soumya Batra and Spencer Whitman and Sten Sootla and Stephane Collot and Suchin Gururangan and Sydney Borodinsky and Tamar Herman and Tara Fowler and Tarek Sheasha and Thomas Georgiou and Thomas Scialom and Tobias Speckbacher and Todor Mihaylov and Tong Xiao and Ujjwal Karn and Vedanuj Goswami and Vibhor Gupta and Vignesh Ramanathan and Viktor Kerkez and Vincent Gonguet and Virginie Do and Vish Vogeti and Vladan Petrovic and Weiwei Chu and Wenhan Xiong and Wenyin Fu and Whitney Meers and Xavier Martinet and Xiaodong Wang and Xiaoqing Ellen Tan and Xinfeng Xie and Xuchao Jia and Xuewei Wang and Yaelle Goldschlag and Yashesh Gaur and Yasmine Babaei and Yi Wen and Yiwen Song and Yuchen Zhang and Yue Li and Yuning Mao and Zacharie Delpierre Coudert and Zheng Yan and Zhengxing Chen and Zoe Papakipos and Aaditya Singh and Aaron Grattafiori and Abha Jain and Adam Kelsey and Adam Shajnfeld and Adithya Gangidi and Adolfo Victoria and Ahuva Goldstand and Ajay Menon and Ajay Sharma and Alex Boesenberg and Alex Vaughan and Alexei Baevski and Allie Feinstein and Amanda Kallet and Amit Sangani and Anam Yunus and Andrei Lupu and Andres Alvarado and Andrew Caples and Andrew Gu and Andrew Ho and Andrew Poulton and Andrew Ryan and Ankit Ramchandani and Annie Franco and Aparajita Saraf and Arkabandhu Chowdhury and Ashley Gabriel and Ashwin Bharambe and Assaf Eisenman and Azadeh Yazdan and Beau James and Ben Maurer and Benjamin Leonhardi and Bernie Huang and Beth Loyd and Beto De Paola and Bhargavi Paranjape and Bing Liu and Bo Wu and Boyu Ni and Braden Hancock and Bram Wasti and Brandon Spence and Brani Stojkovic and Brian Gamido and Britt Montalvo and Carl Parker and Carly Burton and Catalina Mejia and Changhan Wang and Changkyu Kim and Chao Zhou and Chester Hu and Ching-Hsiang Chu and Chris Cai and Chris Tindal and Christoph Feichtenhofer and Damon Civin and Dana Beaty and Daniel Kreymer and Daniel Li and Danny Wyatt and David Adkins and David Xu and Davide Testuggine and Delia David and Devi Parikh and Diana Liskovich and Didem Foss and Dingkang Wang and Duc Le and Dustin Holland and Edward Dowling and Eissa Jamil and Elaine Montgomery and Eleonora Presani and Emily Hahn and Emily Wood and Erik Brinkman and Esteban Arcaute and Evan Dunbar and Evan Smothers and Fei Sun and Felix Kreuk and Feng Tian and Firat Ozgenel and Francesco Caggioni and Francisco Guzmán and Frank Kanayet and Frank Seide and Gabriela Medina Florez and Gabriella Schwarz and Gada Badeer and Georgia Swee and Gil Halpern and Govind Thattai and Grant Herman and Grigory Sizov and Guangyi and Zhang and Guna Lakshminarayanan and Hamid Shojanazeri and Han Zou and Hannah Wang and Hanwen Zha and Haroun Habeeb and Harrison Rudolph and Helen Suk and Henry Aspegren and Hunter Goldman and Ibrahim Damlaj and Igor Molybog and Igor Tufanov and Irina-Elena Veliche and Itai Gat and Jake Weissman and James Geboski and James Kohli and Japhet Asher and Jean-Baptiste Gaya and Jeff Marcus and Jeff Tang and Jennifer Chan and Jenny Zhen and Jeremy Reizenstein and Jeremy Teboul and Jessica Zhong and Jian Jin and Jingyi Yang and Joe Cummings and Jon Carvill and Jon Shepard and Jonathan McPhie and Jonathan Torres and Josh Ginsburg and Junjie Wang and Kai Wu and Kam Hou U and Karan Saxena and Karthik Prasad and Kartikay Khandelwal and Katayoun Zand and Kathy Matosich and Kaushik Veeraraghavan and Kelly Michelena and Keqian Li and Kun Huang and Kunal Chawla and Kushal Lakhotia and Kyle Huang and Lailin Chen and Lakshya Garg and Lavender A and Leandro Silva and Lee Bell and Lei Zhang and Liangpeng Guo and Licheng Yu and Liron Moshkovich and Luca Wehrstedt and Madian Khabsa and Manav Avalani and Manish Bhatt and Maria Tsimpoukelli and Martynas Mankus and Matan Hasson and Matthew Lennie and Matthias Reso and Maxim Groshev and Maxim Naumov and Maya Lathi and Meghan Keneally and Michael L. Seltzer and Michal Valko and Michelle Restrepo and Mihir Patel and Mik Vyatskov and Mikayel Samvelyan and Mike Clark and Mike Macey and Mike Wang and Miquel Jubert Hermoso and Mo Metanat and Mohammad Rastegari and Munish Bansal and Nandhini Santhanam and Natascha Parks and Natasha White and Navyata Bawa and Nayan Singhal and Nick Egebo and Nicolas Usunier and Nikolay Pavlovich Laptev and Ning Dong and Ning Zhang and Norman Cheng and Oleg Chernoguz and Olivia Hart and Omkar Salpekar and Ozlem Kalinli and Parkin Kent and Parth Parekh and Paul Saab and Pavan Balaji and Pedro Rittner and Philip Bontrager and Pierre Roux and Piotr Dollar and Polina Zvyagina and Prashant Ratanchandani and Pritish Yuvraj and Qian Liang and Rachad Alao and Rachel Rodriguez and Rafi Ayub and Raghotham Murthy and Raghu Nayani and Rahul Mitra and Raymond Li and Rebekkah Hogan and Robin Battey and Rocky Wang and Rohan Maheswari and Russ Howes and Ruty Rinott and Sai Jayesh Bondu and Samyak Datta and Sara Chugh and Sara Hunt and Sargun Dhillon and Sasha Sidorov and Satadru Pan and Saurabh Verma and Seiji Yamamoto and Sharadh Ramaswamy and Shaun Lindsay and Shaun Lindsay and Sheng Feng and Shenghao Lin and Shengxin Cindy Zha and Shiva Shankar and Shuqiang Zhang and Shuqiang Zhang and Sinong Wang and Sneha Agarwal and Soji Sajuyigbe and Soumith Chintala and Stephanie Max and Stephen Chen and Steve Kehoe and Steve Satterfield and Sudarshan Govindaprasad and Sumit Gupta and Sungmin Cho and Sunny Virk and Suraj Subramanian and Sy Choudhury and Sydney Goldman and Tal Remez and Tamar Glaser and Tamara Best and Thilo Kohler and Thomas Robinson and Tianhe Li and Tianjun Zhang and Tim Matthews and Timothy Chou and Tzook Shaked and Varun Vontimitta and Victoria Ajayi and Victoria Montanez and Vijai Mohan and Vinay Satish Kumar and Vishal Mangla and Vítor Albiero and Vlad Ionescu and Vlad Poenaru and Vlad Tiberiu Mihailescu and Vladimir Ivanov and Wei Li and Wenchen Wang and Wenwen Jiang and Wes Bouaziz and Will Constable and Xiaocheng Tang and Xiaofang Wang and Xiaojian Wu and Xiaolan Wang and Xide Xia and Xilun Wu and Xinbo Gao and Yanjun Chen and Ye Hu and Ye Jia and Ye Qi and Yenda Li and Yilin Zhang and Ying Zhang and Yossi Adi and Youngjin Nam and Yu and Wang and Yuchen Hao and Yundi Qian and Yuzi He and Zach Rait and Zachary DeVito and Zef Rosnbrick and Zhaoduo Wen and Zhenyu Yang and Zhiwei Zhao},
+      year={2024},
+      eprint={2407.21783},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+      url={https://arxiv.org/abs/2407.21783}, 
+}
+@Misc{accelerate,
+  title =        {Accelerate: Training and inference at scale made simple, efficient and adaptable.},
+  author =       {Sylvain Gugger and Lysandre Debut and Thomas Wolf and Philipp Schmid and Zachary Mueller and Sourab Mangrulkar and Marc Sun and Benjamin Bossan},
+  howpublished = {\url{https://github.com/huggingface/accelerate}},
+  year =         {2022}
+}
+@misc{wang2022languagemodelarchitecturepretraining,
+      title={What Language Model Architecture and Pretraining Objective Work Best for Zero-Shot Generalization?}, 
+      author={Thomas Wang and Adam Roberts and Daniel Hesslow and Teven Le Scao and Hyung Won Chung and Iz Beltagy and Julien Launay and Colin Raffel},
+      year={2022},
+      eprint={2204.05832},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2204.05832}, 
+}
+@misc{kaddour2023minipilechallengedataefficientlanguage,
+      title={The MiniPile Challenge for Data-Efficient Language Models}, 
+      author={Jean Kaddour},
+      year={2023},
+      eprint={2304.08442},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2304.08442}, 
+}
+@article{Kocetkov2022TheStack,
+  title={The Stack: 3 TB of permissively licensed source code},
+  author={Kocetkov, Denis and Li, Raymond and Ben Allal, Loubna and Li, Jia and Mou,Chenghao and Muñoz Ferrandis, Carlos and Jernite, Yacine and Mitchell, Margaret and Hughes, Sean and Wolf, Thomas and Bahdanau, Dzmitry and von Werra, Leandro and de Vries, Harm},
+  journal={Preprint},
+  year={2022}
+}
+@misc{sennrich2016neuralmachinetranslationrare,
+      title={Neural Machine Translation of Rare Words with Subword Units}, 
+      author={Rico Sennrich and Barry Haddow and Alexandra Birch},
+      year={2016},
+      eprint={1508.07909},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/1508.07909}, 
+}
+@ONLINE{wikidump,
+    author = "Wikimedia Foundation",
+    title  = "Wikimedia Downloads",
+    url    = "https://dumps.wikimedia.org"
+}
+@misc {justice_fr,  
+    author       = { ECKENDOERFFER, Guillaume },    
+    title        = { justice_fr },  
+    year         = 2023,  
+    url          = { https://huggingface.co/datasets/eckendoerffer/justice_fr },  
+    publisher    = { Hugging Face }  
+}
+@software{unsloth,
+  author = {Daniel Han, Michael Han and Unsloth team},
+  title = {Unsloth},
+  url = {http://github.com/unslothai/unsloth},
+  year = {2023}
+}
+@misc{antoun2024camembert20smarterfrench,
+      title={CamemBERT 2.0: A Smarter French Language Model Aged to Perfection}, 
+      author={Wissam Antoun and Francis Kulumba and Rian Touchent and Éric de la Clergerie and Benoît Sagot and Djamé Seddah},
+      year={2024},
+      eprint={2411.08868},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2411.08868}, 
+}
+@article{wijmans2024cut,
+  author       = {Erik Wijmans and
+                  Brody Huval and
+                  Alexander Hertzberg and
+                  Vladlen Koltun and
+                  Philipp Kr\"ahenb\"uhl},
+  title        = {Cut Your Losses in Large-Vocabulary Language Models},
+  journal      = {arXiv},
+  year         = {2024},
+  url          = {https://arxiv.org/abs/2411.09009},
+}
+@misc{rafailov2024directpreferenceoptimizationlanguage,
+      title={Direct Preference Optimization: Your Language Model is Secretly a Reward Model}, 
+      author={Rafael Rafailov and Archit Sharma and Eric Mitchell and Stefano Ermon and Christopher D. Manning and Chelsea Finn},
+      year={2024},
+      eprint={2305.18290},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2305.18290}, 
+}
+@misc{muennighoff2023crosslingualgeneralizationmultitaskfinetuning,
+      title={Crosslingual Generalization through Multitask Finetuning}, 
+      author={Niklas Muennighoff and Thomas Wang and Lintang Sutawika and Adam Roberts and Stella Biderman and Teven Le Scao and M Saiful Bari and Sheng Shen and Zheng-Xin Yong and Hailey Schoelkopf and Xiangru Tang and Dragomir Radev and Alham Fikri Aji and Khalid Almubarak and Samuel Albanie and Zaid Alyafeai and Albert Webson and Edward Raff and Colin Raffel},
+      year={2023},
+      eprint={2211.01786},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2211.01786}, 
+}
+@misc {centre_aquitain_des_technologies_de_l'information_et_electroniques_2023,   
+    author       = { {BOURDOIS, Loïck} },  
+    organization  = { {Centre Aquitain des Technologies de l'Information et Electroniques} },  
+    title        = { Dataset of French Prompts (DFP) (Revision 1d24c09) },  
+    year         = 2023,  
+    url          = { https://huggingface.co/datasets/CATIE-AQ/DFP },  
+    doi          = { 10.57967/hf/1200 },  
+    publisher    = { Hugging Face } }
+@misc{wang2022languagemodelarchitecturepretraining,
+      title={What Language Model Architecture and Pretraining Objective Work Best for Zero-Shot Generalization?}, 
+      author={Thomas Wang and Adam Roberts and Daniel Hesslow and Teven Le Scao and Hyung Won Chung and Iz Beltagy and Julien Launay and Colin Raffel},
+      year={2022},
+      eprint={2204.05832},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2204.05832}, 
+}
+@misc{zhang2024lolcatslowranklinearizinglarge,
+      title={LoLCATs: On Low-Rank Linearizing of Large Language Models}, 
+      author={Michael Zhang and Simran Arora and Rahul Chalamala and Alan Wu and Benjamin Spector and Aaryan Singhal and Krithik Ramesh and Christopher Ré},
+      year={2024},
+      eprint={2410.10254},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2410.10254}, 
+}
+@misc{hu2021loralowrankadaptationlarge,
+      title={LoRA: Low-Rank Adaptation of Large Language Models}, 
+      author={Edward J. Hu and Yelong Shen and Phillip Wallis and Zeyuan Allen-Zhu and Yuanzhi Li and Shean Wang and Lu Wang and Weizhu Chen},
+      year={2021},
+      eprint={2106.09685},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2106.09685}, 
+}
+@misc{zhang2024sageattention2efficientattentionthorough,
+      title={SageAttention2: Efficient Attention with Thorough Outlier Smoothing and Per-thread INT4 Quantization}, 
+      author={Jintao Zhang and Haofeng Huang and Pengle Zhang and Jia Wei and Jun Zhu and Jianfei Chen},
+      year={2024},
+      eprint={2411.10958},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2411.10958}, 
+}
+@software{penedo2024fineweb-2,
+  author = {Penedo, Guilherme and Kydlíček, Hynek and Sabolčec, Vinko and Messmer, Bettina and Foroutan, Negar and Jaggi, Martin and von Werra, Leandro and Wolf, Thomas},
+  title = {FineWeb2: A sparkling update with 1000s of languages},
+  month = dec,
+  year = 2024,
+  doi = { },
+  url = {https://huggingface.co/datasets/HuggingFaceFW/fineweb-2}
+}
+@misc{lewis2019bartdenoisingsequencetosequencepretraining,
+      title={BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension}, 
+      author={Mike Lewis and Yinhan Liu and Naman Goyal and Marjan Ghazvininejad and Abdelrahman Mohamed and Omer Levy and Ves Stoyanov and Luke Zettlemoyer},
+      year={2019},
+      eprint={1910.13461},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/1910.13461}, 
+}
+@misc{gloeckle2024betterfasterlarge,
+      title={Better & Faster Large Language Models via Multi-token Prediction}, 
+      author={Fabian Gloeckle and Badr Youbi Idrissi and Baptiste Rozière and David Lopez-Paz and Gabriel Synnaeve},
+      year={2024},
+      eprint={2404.19737},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2404.19737}, 
+}
+@misc{he2023debertav3improvingdebertausing,
+      title={DeBERTaV3: Improving DeBERTa using ELECTRA-Style Pre-Training with Gradient-Disentangled Embedding Sharing}, 
+      author={Pengcheng He and Jianfeng Gao and Weizhu Chen},
+      year={2023},
+      eprint={2111.09543},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2111.09543}, 
+}
+@misc{liu2019robertarobustlyoptimizedbert,
+      title={RoBERTa: A Robustly Optimized BERT Pretraining Approach}, 
+      author={Yinhan Liu and Myle Ott and Naman Goyal and Jingfei Du and Mandar Joshi and Danqi Chen and Omer Levy and Mike Lewis and Luke Zettlemoyer and Veselin Stoyanov},
+      year={2019},
+      eprint={1907.11692},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/1907.11692}, 
+}

dist/index.html

@@ -0,0 +1,1395 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <script src="distill.bundle.js" type="module" fetchpriority="high" blocking></script>
+    <script src="main.bundle.js" type="module" fetchpriority="low" defer></script>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta charset="utf8">
+    <base target="_blank">
+    <title>Le FAT5 : Flash Attention T5</title>
+    <link rel="stylesheet" href="style.css">
+</head>
+
+<body>
+<d-front-matter>
+    <script id='distill-front-matter' type="text/json">{
+    "title": "Le FAT5 : Flash Attention T5",
+    "description": "",
+    "published": "May 28, 2024", 
+    "authors": [
+      {
+        "author":"Boris ALBAR",
+        "authorURL":"https://github.com/b-albar",
+        "affiliation": [{"name": "CATIE", "url": "https://catie.fr"}]
+      },
+      {
+        "author":"Loïck BOURDOIS",
+        "authorURL":"https://github.com/lbourdois",
+        "affiliation": [{"name": "CATIE", "url": "https://catie.fr"}]
+      }
+    ],
+    "color": "#9CA3AF",
+    "katex": {
+      "delimiters": [
+        {"left": "$$", "right": "$$", "display": false}
+      ]
+    }
+  }
+    </script>
+</d-front-matter>
+<d-title>
+    <h1 class="l-page" style="text-align: center;">Le FAT5 : Flash Attention T5</h1>
+    <p><img src="./assets/FAT5_dark.gif" alt="FAT5" width="100%"></p>
+</d-title>
+
+<d-article>
+    <d-contents>
+    </d-contents>
+
+    <div class="note">Pour une meilleure expérience, nous déconseillons la lecture sur téléphone portable</div>
+
+    <br>
+  
+    <h2 id="motivation">Motivation</h2>
+    <p class="width_125">
+    Alors que beaucoup d’efforts ont été consacrés à l’optimisation de <i>transformer</i> de type décodeur, abandonnant ainsi l’encodeur, 
+    nous pensons qu’il est essentiel de maintenir une architecture encodeur-décodeur.<br>
+
+    En effet, cette architecture qui présente des performances intéressantes pour l’instruction tuning <d-cite bibtex-key="chia2023instructeval"></d-cite>,
+    est propice à la distillation <d-cite bibtex-key="hsieh2023distilling"></d-cite> et semble supérieure aux modèles décodeur lorsqu’elle est finetunée <d-cite bibtex-key="fu2024tiny"></d-cite>.
+    Il a aussi été montré que les modèles encodeur-décodeur entraînés avec une modélisation du langage masqué obtiennent une meilleure performance zéro-shot
+    après un finetuning multitâche par rapport à un modèle décodeur <d-cite bibtex-key="wang2022languagemodelarchitecturepretraining"></d-cite>.<br>
+    Au-delà du NLP sur lequel nous nous concentrons dans cet article de blog, l’architecture encodeur-décodeur est très utilisée dans d’autres domaines 
+    comme l’audio ou  les séries temporelles par exemple. L'encodeur d'une telle architecture est également utilisé dans des modèles de diffusion.<br>    
+      
+    Dans cette logique, nous avons décidé de nous concentrer sur le T5 <d-cite bibtex-key="JMLR:v21:20-074"></d-cite>.<br><br>
+
+    Dans cet article, sont détaillons les optimisations que nous avons mises en place afin de pré-entraîner de manière efficiente un T5 de 147M de paramètres en français en un temps raisonnable (1 461 H pour 419Mds de <i>tokens</i>) et avec des moyens limités (1 unique A100 ; soit un budget de calcul d'environ 2 200 euros).
+    Pour ce faire, nous avons conçu des noyaux CUDA/Triton afin de rendre la Flash Attention compatible avec T5 et de fournir une inférence linéaire, étendant ainsi la taille du contexte qui peut être prise en compte par le modèle.<br><br>
+    <strong>Le code de pré-entrainement est disponible sur notre répertoire <a class="link" href="https://github.com/catie-aq/flashT5">GitHub</a> sous licence Apache-2.0. et les poids sur notre compte <a class="link" href="https://hf.co/CATIE-AQ">Hugging Face</a>.</strong>
+    <p class="width_125"><br><br><br></p>
+
+  
+    <h2 id="vue-d-ensemble-de-notre-travail">Vue d’ensemble de notre travail</h2>
+    <p class="width_125">Nous avons donc choisi de travailler avec un T5 et en pratique avec le nanoT5 <d-cite bibtex-key="nawrot2023nanot5"></d-cite>.<br>
+    Pour les tâches de prétexte lors du pré-entraînement, nous avons suivi celles d'UL2 <d-cite bibtex-key="tay2023ul2"></d-cite> avec les 7 tâches suivantes :</p>
+    <pre><code class="lang-py">
+            denoiser_list=[
+                {<span class="hljs-string">"mu"</span>: <span class="hljs-number">3.0</span>, <span class="hljs-string">"r"</span>: <span class="hljs-number">0</span>.<span class="hljs-number">15</span>, <span class="hljs-string">"max_spans"</span>: max_token_length, <span class="hljs-string">"prefix"</span>: <span class="hljs-string">"[R]"</span>},
+                {<span class="hljs-string">"mu"</span>: <span class="hljs-number">8.0</span>, <span class="hljs-string">"r"</span>: <span class="hljs-number">0</span>.<span class="hljs-number">15</span>, <span class="hljs-string">"max_spans"</span>: max_token_length, <span class="hljs-string">"prefix"</span>: <span class="hljs-string">"[R]"</span>},
+                {<span class="hljs-string">"mu"</span>: <span class="hljs-number">4.0</span>, <span class="hljs-string">"r"</span>: <span class="hljs-number">0</span>.<span class="hljs-number">0</span>, <span class="hljs-string">"max_spans"</span>: <span class="hljs-number">1</span>, <span class="hljs-string">"prefix"</span>: <span class="hljs-string">"[S]"</span>},
+                {<span class="hljs-string">"mu"</span>: <span class="hljs-number">3.0</span>, <span class="hljs-string">"r"</span>: <span class="hljs-number">0</span>.<span class="hljs-number">5</span>, <span class="hljs-string">"max_spans"</span>: max_token_length, <span class="hljs-string">"prefix"</span>: <span class="hljs-string">"[X]"</span>},
+                {<span class="hljs-string">"mu"</span>: <span class="hljs-number">8.0</span>, <span class="hljs-string">"r"</span>: <span class="hljs-number">0</span>.<span class="hljs-number">15</span>, <span class="hljs-string">"max_spans"</span>: max_token_length, <span class="hljs-string">"prefix"</span>: <span class="hljs-string">"[X]"</span>},
+                {<span class="hljs-string">"mu"</span>: <span class="hljs-number">64.0</span>, <span class="hljs-string">"r"</span>: <span class="hljs-number">0</span>.<span class="hljs-number">15</span>, <span class="hljs-string">"max_spans"</span>: max_token_length, <span class="hljs-string">"prefix"</span>: <span class="hljs-string">"[X]"</span>},
+                {<span class="hljs-string">"mu"</span>: <span class="hljs-number">64.0</span>, <span class="hljs-string">"r"</span>: <span class="hljs-number">0</span>.<span class="hljs-number">5</span>, <span class="hljs-string">"max_spans"</span>: max_token_length, <span class="hljs-string">"prefix"</span>: <span class="hljs-string">"[X]"</span>}]
+            denoiser_proportions=[<span class="hljs-number">0</span>.<span class="hljs-number">165</span>, <span class="hljs-number">0</span>.<span class="hljs-number">165</span>, <span class="hljs-number">0</span>.<span class="hljs-number">34</span>, <span class="hljs-number">0</span>.0825, <span class="hljs-number">0</span>.0825, <span class="hljs-number">0</span>.0825, <span class="hljs-number">0</span>.0825]
+    </code></pre>
+    <p class="width_125">avec <code>mu</code> la taille du n-gram, <code>r</code> le pourcentage de masquage dans le n-gram et <code>prefix</code> le type de tâche de prétexte. 
+      La signification des lettres <code>[R]</code>, <code>[S]</code> et <code>[X]</code> est décrite <a class="link" href="https://huggingface.co/google/ul2#mixture-of-denoisers">ici</a> 
+      et nous vous invitons à consulter notamment l'image explicative <a class="link" href="https://raw.githubusercontent.com/google-research/google-research/master/ul2/figs/mod.png">ici</a>.</p>
+    <p class="width_125">Pour avoir un entraînement rapide, nous nous sommes orientés sur la Flash Attention <d-cite bibtex-key="dao2022flashattention"></d-cite>. 
+    Cependant, comme celle-ci ne gère pas les biais attentionnels (additifs) du T5, nous avons dû l’étendre en développant un noyau personnalisé. 
+    Plus précisément nous avons développé successivement deux versions de ce noyau. 
+    Dans la première version, au début de notre travail nous transmettions la matrice de biais au noyau. 
+    Dans la version actuelle, nous inspirant du TurboT5 <d-cite bibtex-key="turbot5"></d-cite>, 
+    nous communiquons seulement un tenseur contenant les biais fusionnés afin de matérialiser la matrice de biais à la volée. 
+    Cela permet de passer d’un T5 à mémoire quadratique à un T5 à mémoire linéaire, et par conséquent augmente fortement la taille de contexte que le modèle peut gérer.</p>
+    <p class="width_125">Notre travail a abouti au pré-entraînement d'un T5 en français de 147M de paramètres : le FAT5 <i>small</i>.<br> 
+      Le jeu de données que nous avons utilisé est composé de la partie en français du corpus CulturaX <d-cite bibtex-key="nguyen2023culturax"></d-cite>
+      (principale source avec plus de 1258 Go de texte), 
+      de la partie en français de Wikipedia <d-cite bibtex-key="wikidump"></d-cite> (dump 20231101),
+      de justice_fr (textes de loi française) <d-cite bibtex-key="justice_fr"></d-cite>,
+      et de 25 000 000 lignes de TheStack <d-cite bibtex-key="Kocetkov2022TheStack"></d-cite>
+      (l'idée ici est de montrer un peu de code à notre modèle bien que ce ne soit pas notre objectif principal).<br>
+      Ce modèle a été évalué sur cinq tâches : le résumé de textes, la classification binaire, le question answering, la reconnaissance d’entités nommées et la <i>sentence similarity</i>.</p>
+    <p class="width_125"><br><br><br></p>
+  
+    <h2 id="les-d-tails-de-la-recette">Les détails de la recette</h2>
+    <p class="width_125">Ne disposant que de deux A100 (une de 80Go et une de 40Go), nous avons dû consacrer un peu de temps afin d’implémenter des optimisations permettant d'exploiter au mieux notre matériel.
+      En effet, avant même d’entraîner un modèle voire de modifier son architecture, il faut s’assurer qu’on optimise l'usage des capacités de calcul de nos GPU. 
+      Plusieurs facteurs peuvent expliquer un entraînement sous-optimal d’un modèle de deep learning :<br>
+    &nbsp; • Le manque de nourriture (<em>disk-bounded</em> - limitation en disque)<br>
+    &nbsp; • La bande passante mémoire (<em>memory-bounded</em> - limitation en bande passante mémoire)<br>
+    &nbsp; • La vitesse de calcul (<em>compute-bounded</em> - limitation en calcul)</p>
+
+    <p class="width_125">Idéalement, on aimerait que le modèle soit limité par la vitesse de calcul, c’est-à-dire que le GPU soit utilisé à pleine capacité. 
+      Partant de ce constat, nous avons travaillé sur trois points principaux : <br>
+    &nbsp; • L’optimisation du disque du GPU <br>
+    &nbsp; • L’optimisation de la bande passante de la mémoire du GPU <br>
+    &nbsp; • L’optimisation de l’utilisation des Tensor Cores<br>
+    </p>
+  
+    <p class="width_125">Il s’agit donc de points à la fois hardware mais aussi software.</p>
+    <p></p>
+    <p class="width_125">Dans la suite de cette section, tout ce que nous avons réalisé/implémenté pour apporter une réponse aux limites rencontrées est disponible dans un encadré en vert. Des notes/commentaires sont trouvables dans un encadré en bleu. 
+    <br><br></p>
+    <h3 id="optimisation-du-disque-du-gpu">Optimisation du disque du GPU</h3>
+    <p class="width_125">La limitation en disque intervient soit lors du chargement des données, soit lors des opérations de prétraitement. 
+      Dans les deux cas, cela se matérialise par un problème de lenteur.
+    <br></p>
+    <h4 id="acc-s-disques">Accès disques</h4>
+    <p class="width_125">Si la limitation vient des accès disques, plusieurs solutions sont possibles :</p>
+    <ul>
+    <li><p class="width_125"><u>Mettre les données en RAM</u><br>
+      Cela résout le problème de manière radicale mais suppose que la base de données rentre en RAM, ce qui est loin d’être évident du fait de sa petite taille.</p>
+    <div class="tip"><p>Ce n’est donc pas la solution que nous avons retenue.</p></div>
+    </li>
+    <li><p class="width_125"><u>Mettre les données sur un disque plus rapide et/ou moins utilisé</u><br>
+      Si vous avez un accès physique à votre serveur de GPU, il est très utile d’intégrer des <a class="link" href="https://fr.wikipedia.org/wiki/NVM_Express">NVMe</a> dans la configuration de celui-ci.</p>
+    <p class="width_125">Il faut aussi faire attention à ne pas avoir trop de processus de différents entraînements qui tirent sur un même disque. 
+      Il est alors préférable d’avoir plusieurs petits disques plutôt qu’un gros.  </p>
+    <div class="note"><p>Un effet indirect bénéfique est qu’une telle configuration coûte moins cher 😉</p></div>
+    </li>
+    </ul>    
+    <ul>    
+    <li class="width_125"><u>Utiliser des formats de fichiers plus efficients notamment au niveau des accès aléatoires</u><br>
+      Par exemple les fichiers <code>.parquet</code> sont plus efficients que les <code>.csv</code>. 
+      On peut aussi utiliser des formats spécifiquement développés dans ce but comme le <code>.beton</code> de ffcv <d-cite bibtex-key="leclerc2023ffcv"></d-cite>.</li>
+    <div class="tip"><p>Nous utilisons la bibliothèque Datasets <d-cite bibtex-key="lhoest2021datasets"></d-cite> pour charger et traiter les données que nous utilisons. 
+      Avec cette bibliothèque, les données sont décompressées en local au format <code>Arrow</code>. 
+      De plus, si les données chargées depuis le Hub d’Hugging Face ont été ajoutées avec la fonction <code>push_to_hub()</code>, 
+      alors le jeu de données est par défaut converti au format <code>parquet</code>.</p></div>
+    </ul>
+    <ul>    
+    <li class="width_125"><u>Prétokeniser les données</u><br>
+    L'option la plus efficace est probablement de prétokeniser les données afin d'optimiser les accès.
+    C'est-à-dire que la tokenisation a lieu dans une étape préalable et non pas à la volée.
+    </li>
+    <div class="tip"><p>Nous invitions le lecteur à consulter le code 
+      <a class="link" href="https://github.com/catie-aq/flashT5/blob/main/examples/minipile/pretokenize_minipile.py">suivant</a> qui
+      illustre la façon dont nous procédons dans notre tutoriel sur le FAT5 appliqué au jeu de données Minipile <d-cite bibtex-key="kaddour2023minipilechallengedataefficientlanguage"></d-cite>.</p></div>
+    </ul>
+    <p><br></p>
+    <h4 id="traitement-des-donn-es">Traitement des données</h4>
+    <p class="width_125">Si la limitation vient du traitement des données après leur chargement :</p>
+    <ul>
+    <li><p class="width_125"><u>Il est possible d’utiliser plusieurs processus pour traiter les données en parallèle</u><br> 
+    Par exemple, le paramètre <code>num_workers</code> du <code>Dataloader</code> de PyTorch <d-cite bibtex-key="paszke2019pytorch"></d-cite>.</p></li>
+    <div class="tip"><p>Vous pouvez retrouver dans notre code les valeurs que nous utilisons pour ce paramètre pour notre FAT5 <a class="link" href="https://github.com/catie-aq/flashT5/blob/dfe10d498ae0b39082182f807acb509e91992360/configs/fr/fat5-fr-small.yaml#L42">small</a>.</div>
+    </ul>
+    <ul>
+    <li><p class="width_125"><u>Le goulot d’étranglement peut aussi venir du <code>DataCollator</code></u><br>
+    C'est notamment le cas lorsqu’il y a des tâches complexes à effectuer (masquage d’image ou débruiteurs multiples sur des tâches de NLP).<br>
+    On pourra alors construire un <code>DataCollator</code> personnalisé pour la tâche. 
+    On appliquera les méthodes traditionnelles pour optimiser la vitesse de celui-ci. 
+    De même, l’emploi de la vectorisation de Numpy permettra de traiter plus rapidement des listes qu'avec des boucles <code>for</code>. 
+    D’une manière générale, Numpy est plus rapide que PyTorch pour ce type de tâches. 
+    On pourra aussi utiliser des méthodes de compilation comme numba <d-cite bibtex-key="10.1145/2833157.2833162"></d-cite> pour Python par exemple.</p></li>
+    <div class="tip"><p>Nous avons suivi ce principe et développé un <code>DataCollator</code> personnalisé pour notre FAT5 dont vous pouvez consulter le code <a class="link" href="https://github.com/catie-aq/flashT5/blob/main/src/data/data_collator_ul2.py">ici</a>. 
+      Il gère les tâches de prétexte UL2 tout en ayant un mécanisme de batch dynamique pour réduire le <em>padding</em> (plus d'informations dans la section suivante).</p></div>
+    <div class="note"><p>Comme il n’y avait pas d’implémentation du <code>DataCollator</code> d’UL2 disponible en PyTorch jusqu’ici, nous espérons que cela pourra être utile à d’autres travaux.</p></div>
+    </ul>
+    <ul>
+    <li><p class="width_125"><u>Réaliser un <em>padding</em> efficace</u><br>
+    <p class="width_125">Lorsque l’on travaille avec des séquences, on a naturellement tendance à padder un ensemble de séquences pour pouvoir construire des batchs. 
+      Les <em>tokens</em> de <em>padding</em> engendrent alors des calculs inutiles.<br>
+      La première chose à faire est de limiter le <em>padding</em> à la séquence de taille maximum et non à une valeur maximale. 
+      C’est la technique du <a class="link" href="https://huggingface.co/learn/nlp-course/chapter3/2?fw=pt#dynamic-padding">padding dynamique</a>.<br>
+      Avec cette technique, il peut néanmoins rester des <em>tokens</em> de <em>padding</em>. Pour les gérer, il existe deux possibilités :<br>
+    &nbsp; • soit utiliser une méthode de groupage des données avec des tailles similaires 
+      (par exemple, <a class="link" href="https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments.group_by_length">ce paramètre</a> 
+      dans la bibliothèque Transformers <d-cite bibtex-key="wolf2020huggingfaces"></d-cite> ou encore 
+      <a class="link" href="https://discuss.huggingface.co/t/how-to-implement-trainers-group-by-length-in-pytorch/9232">en récupérant ce sampler</a> pour PyTorch)<br>
+    &nbsp; • soit concaténer différents exemples dans un DataCollator personnalisé.</p>
+    <div class="tip"><p>Nous avons opté pour la seconde option et nous renvoyons donc le lecteur à nouveau au <a class="link" href="https://github.com/catie-aq/flashT5/blob/main/src/data/data_collator_ul2.py">code</a> de notre DataCollator de mélange de débruiteurs (UL2).</p></div>
+    <div class="note"><p>Des heuristiques plus optimisées doivent probablement être mises en place. 
+      Nous avons fait un test en proposant une
+      <a class="link" href="https://github.com/catie-aq/flashT5/blob/dfe10d498ae0b39082182f807acb509e91992360/src/data/data_collator_ul2.py#L45">fonction</a> 
+      dans le <code>DataCollator</code> afin de trier les <code>input_ids</code> et les <code>labels</code> par longueur décroissante.
+      Néanmoins ceci est plutôt long pour un gain d'empaquetage minime.
+      Un travail plus conséquent serait à effectuer sur ce point.
+      </p></div>
+    </ul>
+    <p class="width_125"><br><br></p>
+
+  
+    <h3 id="optimisation-de-la-bande-passante-de-la-m-moire-du-gpu">Optimisation de la bande passante de la mémoire du GPU</h3>
+    <p class="width_125">La limitation en bande passante mémoire est plus difficile à traiter. 
+      Une opération limitée par la mémoire est une opération dont le temps global d’exécution est restreint par les accès mémoires. 
+      C’est notamment le cas pour les LLMs particulièrement au niveau de l’inférence. 
+      Le diagnostic peut être posé à partir du <a class="link" href="https://pytorch.org/tutorials/intermediate/tensorboard_profiler_tutorial.html"><em>profiler</em> de PyTorch</a> :</p>
+    <figure class="width_125">
+    <img src="https://pytorch.org/tutorials/_static/img/profiler_overview1.png" alt="profiler_overview1.png" width="100%">
+    <figcaption><center><i>Source : <a class="link" href="https://pytorch.org/tutorials/_static/img/profiler_overview1.png">https://pytorch.org/tutorials/_static/img/profiler_overview1.png</a></i></center></figcaption>
+    </figure>
+    <br><br><br>
+    <p class="width_125">Une autre possibilité pour établir un diagnostic est d’utiliser un simple <code>nvidia-smi</code> :</p>
+    <figure class="width_125">
+    <img src="./assets/nvidiasmi.png" alt="nvidiasmi.png" width="100%">
+    </figure>
+    <br>
+    <p class="width_125">Utile pour savoir si un problème est présent mais donne peu d’information sur la nature de ce problème. 
+      C’est pourquoi nous avons une préférence pour le profiler.</p>
+    <p><br></p>
+    <h4 id="noyau-cuda">Noyau CUDA</h4>
+    <p class="width_125">La technique reine pour optimiser la bande passante de la mémoire du GPU est de développer un kernel CUDA fusionnant
+      dans la SRAM plusieurs opérations limitantes. 
+      Cela peut limiter la copie de larges matrices dans l’HBM pour les recharger immédiatement ensuite dans la SRAM. 
+      C’est désormais une caractéristique courante des <i>transformers</i> décodeurs grâce à la <a class="link" href="https://github.com/Dao-AILab/flash-attention">Flash Attention</a>.</p>
+    <div class="tip"><p>
+    Comme la Flash Attention ne gère pas les biais attentionnels (additifs) du T5, nous l’avons étendue en développant un noyau CUDA personnalisé. 
+    Comme évoqué dans l’introduction, c’est en réalité successivement deux versions successives de ce noyau que nous avons implémentées. 
+    Sans pour autant entrer dans les détails des 650 lignes de code de l’implémentation de la première version (consultable 
+      <a class="link" href="https://github.com/Dao-AILab/flash-attention/pull/617">ici</a>),
+      l’idée générale et simplifiée (pour une passe avant) est la suivante :</p>
+    <ul>
+    <li>On charge de l’HBM vers la SRAM la sortie attendue O (output) initialisée avec des 0, 
+      de même que la requête Q (query), la clé K (key), la valeur V (value) et les biais B.</li>
+    <li>Notre noyau CUDA calcule les étapes suivantes :<br>
+    &nbsp; • Calcul de la matrice S via le produit matriciel entre Q et la transposée de K<br>
+    &nbsp; • Calcul de S’ qui est la somme de la matrice S et de la matrice des biais B<br>
+    &nbsp; • Calcul de P qui est la softmax (cumulative sous le capot) de S’<br>
+    &nbsp; • Calcul de la sortie O qui est le produit matriciel de P par V<br>
+    </li>
+    <li>La sortie O est chargée sur l’HBM et la SRAM est vidée.
+    <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="./assets/FAT5_dark.gif">
+    <img alt="FAT5 animation" src="./assets/FAT5.gif" width="100%">
+    </picture>
+    </ul>
+    <br>
+    <p>Alors que la première version du noyau est générique, la seconde (disponible <a class="link" href="https://github.com/Dao-AILab/flash-attention/pull/956">ici</a>) 
+      est spécifique au fonctionnement de modèles avec encodage positionnel relatif (ce qui est le cas du T5).
+     L’idée générale et simplifiée (pour une passe avant) est la suivante :</p>
+    <ul>
+    <li>Dans l'HBM, nous avons la sortie attendue O (output) initialisée avec des 0, 
+      de même que la requête Q (query), la clé K (key), la valeur V (value). 
+      Cependant nous n'avons pas la matrice de biais B comme précédemment mais le bucket de tenseur T.</li>
+    <li>On charge de l’HBM vers la SRAM la sortie attendue O (output) initialisée avec des 0, 
+      de même que la requête Q (query), la clé K (key), la valeur V (value) et le bucket de tenseur T.</li>
+    <li>Notre noyau CUDA calcule les étapes suivantes :<br>
+    &nbsp; • Calcul de la matrice S via le produit matriciel entre Q et la transposée de K<br>
+    &nbsp; • Calcul de S’ qui est la somme de la matrice S et d'une matrice remplie avec les éléments de T<br>
+    &nbsp; • Calcul de P qui est la softmax (cumulative sous le capot) de S’<br>
+    &nbsp; • Calcul de la sortie O qui est le produit matriciel de P par V<br>
+    </li>
+    <li>La sortie O est chargée sur l’HBM et la SRAM est vidée.</li>
+    </ul>
+    <p>
+    De cette façon, alors que la première version la matrice de biais B nécessitait une mémoire quadratique, ici nous nous ramenons 
+    à une mémoire linéaire permettant d'effectuer des inférences sur des dizaines de milliers de <em>tokens</em>.<br>
+    Pour la conception de cette seconde version, nous nous sommes inspirés du noyau Triton du TurboT5 que nous avons porté en CUDA et étendu au full bf16.  
+    </p>
+    </div>
+    <br>
+
+    <div class="tip"><p>Notons que les deux versions développées peuvent être utilisées avec plusieurs encodages positionnels.<br>
+    Nous invitions le lecteur à consulter ce <a class="link" href="https://github.com/catie-aq/flashT5/blob/main/src/utils/positional_encoding.py">fichier</a> 
+      contenant des classes compatibles avec la Flash Attention pour le 
+      <a class="link" href="https://github.com/catie-aq/flashT5/blob/dfe10d498ae0b39082182f807acb509e91992360/src/utils/positional_encoding.py#L10">RelativePositionalEncoding</a> 
+      <d-cite bibtex-key="shaw2018selfattention"></d-cite>, 
+      l’<a class="link" href="https://github.com/catie-aq/flashT5/blob/dfe10d498ae0b39082182f807acb509e91992360/src/utils/positional_encoding.py#L113">ALiBiPositionalEncoding</a>
+      <d-cite bibtex-key="press2022train"></d-cite>, 
+      le <a class="link" href="https://github.com/catie-aq/flashT5/blob/dfe10d498ae0b39082182f807acb509e91992360/src/utils/positional_encoding.py#L205">RotaryPositionalEncoding</a> 
+      <d-cite bibtex-key="su2023roformer"></d-cite> et 
+      <a class="link" href="https://github.com/catie-aq/flashT5/blob/dfe10d498ae0b39082182f807acb509e91992360/src/utils/positional_encoding.py#L341">FIRE</a> <d-cite bibtex-key="li2024functional"></d-cite>.</p></div>
+
+    <div class="note"><p>Au moment de la rédaction de ces lignes, 
+      les deux <em>pull request</em> (une pour chaque version du noyau, disponibles <a class="link" href="https://github.com/Dao-AILab/flash-attention/pull/617">ici</a> 
+      et <a class="link" href="https://github.com/Dao-AILab/flash-attention/pull/956">ici</a>) ouvertes sur le répertoire officiel de la Flash Attention n’ont pas été mergées. 
+      Le lecteur devra donc provisoirement recompiler nos patchs personnalisés de la Flash Attention pour pouvoir utiliser nos modèles.<br>
+      Nous invitons le lecteur à consulter la partie Benchmark plus bas dans l'article pour visualiser l'amélioration apportée par ces deux noyaux.</p></div>
+  
+    <br>
+    <div class="note"><p>Bien que nous n’y ayons pas eu recours, il est à noter que certaines libraires contiennent des implémentations d’opérateurs courant fusionnés, par exemple Apex <d-cite bibtex-key="nvidiapex"></d-cite>.</p></div>
+    
+    <p><br></p>
+    <h4 id="noyau-triton">Noyau Triton</h4>
+    <p class="width_125">Triton <d-cite bibtex-key="10.1145/3315508.3329973"></d-cite> est un langage de programmation maintenu qui permet de compiler du code Python efficacement à l’instar de CUDA mais ayant l’avantage d’être (de notre point de vue) plus simple à prendre en main. En effet, contrairement à CUDA, qui nécessite une compréhension approfondie de l’architecture matérielle des GPU, Triton fait abstraction de nombreux détails de bas niveau tels que la coalescence de la mémoire, la gestion de la mémoire partagée et l’ordonnancement au sein des blocs de threads CUDA.</p>
+
+    <div class="tip"><p>Une implémentation en Triton de la 
+      <a class="link" href="https://github.com/catie-aq/flashT5/blob/main/src/model/ops/flash_attention_v2_bias.py">Flash Attention 2 gérant les biais d’attention</a> 
+      est fournie pour ceux qui ne souhaitent pas recompiler un patch personnalisé pour la Flash Attention. 
+      Pour cela, nous nous sommes appuyés sur le répertoire de FlagAttention <d-cite bibtex-key="flagattention"></d-cite>. 
+      <br>
+      <br>
+      En complément de cette implémentation (dont l'usage est facultatif), d’autres parties de l’architecture ont été optimisées à l’aide de noyaux Triton ad hoc, à savoir :
+    <br>
+    &nbsp; • la perte d’<a class="link" href="https://github.com/catie-aq/flashT5/blob/main/src/model/ops/cross_entropy_loss.py">entropie croisée</a> (et la perte z <d-cite bibtex-key="debrébisson2016zloss"></d-cite>) <br>
+    &nbsp; • la <a class="link" href="https://github.com/catie-aq/flashT5/blob/main/src/model/ops/rms_norm.py">couche de RMSNorm</a> <d-cite bibtex-key="zhang2019root"></d-cite> <br>
+    <br>
+    Nous nous sommes notamment inspirés de <a class="link" href="https://github.com/unslothai/unsloth">Unsloth</a> <d-cite bibtex-key="unsloth"></d-cite>.<br>
+    <br>
+    Nous invitons le lecteur se référer à la partie Benchmark plus bas dans l'article pour visualiser l'impact de cette optimisation.</div>
+    
+    <p><br></p>
+    <h4 id="utiliser-torch-compile-">Utiliser <code>torch.compile</code></h4>
+    <p class="width_125">Une approche plus simple est de compiler les modèles avec <code>torch.compile</code>. 
+      PyTorch se charge alors de faire les fusions possibles, éventuellement en réordonnant des opérations. 
+      Il s’agit alors de faire la chasse aux cassures dans le graphe de compilation qui sont des retours à un mode d’exécution « eager » impactant 
+      négativement la performance de l’opération.</p>
+    <div class="note"><p>Voir la <a class="link" href="https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html">documentation</a> officielle pour plus de détails.</p></div>
+    <p class="width_125">Une autre possibilité consiste à un usage conjoint d’un noyau kernel personnalisé et de <code>torch.compile</code>. 
+      L'implémentation de cette option est grandement simplifiée depuis la 
+      <a class="link" href="https://github.com/pytorch/pytorch/releases/tag/v2.4.0">version 2.4 de PyTorch</a>.</p>
+    <p class="width_125">Nous invitons le lecteur à se référer à la partie benchmark disponible plus bas dans l’article afin de mesurer les performances mémoire 
+      des différentes techniques décrites.</p>
+    <p class="width_125"><br><br></p>
+    <h3 id="optimisation-de-l-utilisation-des-tensor-cores">Optimisation de l’utilisation des Tensor Cores</h3>
+    <p class="width_125">Les GPU récents possèdent des unités dédiées aux opérations tensorielles : les TensorCore. Les utiliser correctement est essentiel.</p>
+    <p class="width_125">A nouveau, pour établir un diagnostic, il est conseillé de se référer au profiler de PyTorch qui indique la proportion de TensorCore 
+      utilisé pour chaque noyau CUDA :</p>
+    <p><figure class="width_125">
+    <img src="https://pytorch.org/tutorials/_static/img/profiler_kernel_view.png" alt="profiler_kernel_view.png" width="100%">
+    <figcaption><center><i>Source : <a class="link" href="https://pytorch.org/tutorials/_static/img/profiler_kernel_view.png">https://pytorch.org/tutorials/_static/img/profiler_kernel_view.png</a></i></center></figcaption>
+    </figure>
+    <br><br>
+    <p class="width_125">Concernant les optimisations réalisables :<br></p>
+    <h4 id="puissances-de-2">Multiple de 8 ou de 64</h4>
+    <p class="width_125">La première consiste à employer des tailles de tenseurs de certains multiples de 8 ou de 64. 
+      Nous invitons le lecteur à se référer à la documentation de Nvidia, 
+      en particulier cet <a class="link" href="https://docs.nvidia.com/deeplearning/performance/dl-performance-matrix-multiplication/index.html#requirements-tc">article</a>
+      et cet <a class="link" href="https://developer.nvidia.com/blog/optimizing-gpu-performance-tensor-cores/">article</a> pour déterminer le multiple à sélectionner en fonction de la précision désirée.  </p>
+    <div class="tip"><p>Dans cette logique, nous avons entraîné un <em>tokenizer</em> de taille 32 768 (8**5), suivant <a class="link" href="https://twitter.com/karpathy/status/1621578354024677377">cette observation de KARPATHY</a>. 
+      Il s'agit d'un BPE <d-cite bibtex-key="sennrich2016neuralmachinetranslationrare"></d-cite> entraîné sur CulturaX et The Stack, utilisant 256 extra_tokens et 
+      les chiffres sont séparés.<br>
+      Le lecteur pourra trouver le code utilisé <a class="link" href=https://github.com/catie-aq/flashT5/blob/main/examples/fat5-fr/train_tokenizer.py">ici</a>.
+      </p></div>
+    <p><br></p>
+      
+    <h4 id="utiliser-le-bon-optimiseur">Utiliser le bon optimiseur</h4>
+    <p class="width_125">Changer d’optimiseur par rapport à l’implémentation initiale du modèle peut être judicieux pour accélérer la convergence du modèle
+      (cela peut néanmoins empêcher la reproduction des résultats du papier original).<br>
+      Les optimiseurs accélèrent la convergence en permettant des tailles de batchs conséquentes comme dans le cas de LAMB <d-cite bibtex-key="you2020large"></d-cite> 
+      ou l’utilisation de <em>learning rates</em> plus élevés comme Sophia <d-cite bibtex-key="liu2024sophia"></d-cite>.<br>
+      Des versions plus efficaces des optimiseurs peuvent être aussi utilisées comme l’option <code>fused</code> 
+      dans l’<a class="link" href="https://pytorch.org/docs/stable/generated/torch.optim.Adam.html">optimiseur Adam</a> de PyTorch 
+      ou encore les optimiseurs disponibles dans <a class="link" href="https://github.com/NVIDIA/apex">Apex</a>.</p>
+    <div class="tip"><p>
+      Nous avons utilisé l’optimiseur l’optimiseur original du T5, <a class="link" href="https://github.com/catie-aq/flashT5/blob/main/src/utils/adamw_scaled.py">AdamWScale</a>.
+      Pour les valeurs des hyperparamètres, nous utilisons <code>lr = 5e-3</code>, <code>betas = (0.9, 0.999)</code>, <code>eps = 1e-6</code> et <code>weight_decay = 0.0</code>
+      en nous basant sur les observations de <a class="link" href="https://github.com/PiotrNawrot/nanoT5/issues/25#issuecomment-1922731400">Wilson Wongso</a>.
+      En effet, il s'avère que tous les optimiseurs alternatifs testés ne convergeaient pas.</p></div>
+    <div class="note"><p>Nous avons fait en sorte que notre version d'AdamWScale dispose du paramètre <code>foreach</code>.</p>       
+    </div>
+    <p><br></p>
+
+    <h4 id="entra-ner-ses-mod-les-en-bf16-ou-fp16-">Entraîner ses modèles en <code>bf16</code></h4>
+    <p class="width_125">Les GPU récents permettent d’exploiter pleinement l’utilisation de précision réduite 
+      (permettant de gagner un facteur 2 de débit par rapport au <code>fp32</code>). 
+      Le <code>bf16</code> n’est disponible que sur les architectures Ampere ou plus récentes mais autorise de s’affranchir de méthode
+      de <em>loss scaling</em> <d-cite bibtex-key="micikevicius2018mixed"></d-cite> qui est généralement nécessaire en <code>fp16</code> 
+      grâce à une plage dynamique plus grande (l’exposant est codé sur 8 bits comme le <code>fp32</code>).</p>
+    <div class="tip"><p>Dans cette logique, nous entraînons nos modèles en <code>bf16</code>.
+      Plus précisément, alors qu'au début de nos expérimentations nous utilisions du <code>bf16-mixed</code>, nous avons recouru à 
+      <a class="link" href="https://en.wikipedia.org/wiki/Kahan_summation_algorithm">la sommation compensée de Kahan</a>
+      afin de pouvoir utiliser du <code>full bf16</code> dans notre optimiseur.<br>  
+      A nouveau, le code de notre optimiseur est consultable <a class="link" href="https://github.com/catie-aq/flashT5/blob/main/src/utils/adamw_scaled.py">ici</a>.</p>
+    </div>
+      
+    <h4 id="utiliser-moins-de-m-moire-du-gpu">Utiliser moins de mémoire GPU</h4>
+    <p class="width_125">Certaines techniques existent pour limiter l’utilisation de mémoire GPU par le modèle tel que le 
+      <a class="link" href="https://pytorch.org/docs/stable/checkpoint.html"><em>gradient checkpointing</em></a> 
+      ou les méthodes type ZeRO <d-cite bibtex-key="rajbhandari2020zero"></d-cite> implémentées dans 
+      <a class="link" href="https://github.com/microsoft/DeepSpeed">DeepSpeed</a>. 
+      En limitant la mémoire utilisée, des tailles de batchs plus grandes peuvent être utilisées accélérar l’entraînement du modèle.</p>
+    <p class="width_125"><br><br></p>
+
+      
+    <h3 id="autres">Autres</h3>
+    <h4 id="le-parall-lisme">Le parallélisme</h4>
+    <p class="width_125">L’utilisation de plusieurs GPUs est délicate. 
+      Réalisée naïvement, elle peut résulter en des performances inférieures à l’implémentation sur un seul GPU gâchant alors des ressources de calculs. 
+      C’est le cas notamment lorsque des goulets d’étranglement se forment au niveau des communications entre les GPU. 
+      Il s’agit d’être sûr que le modèle n’est pas limité par la bande passante entre les cartes ou de s'assurer que les cartes sont connectées avec des 
+      bandes passantes suffisantes via des techniques type <a class="link" href="https://en.wikipedia.org/wiki/NVLink">NVLink</a> par exemple. </p>
+    <p class="width_125">A noter aussi que les techniques d’optimisation requièrent en général de synchroniser tous les GPU à la fin d’un batch. 
+      De ce fait, si un GPU est plus lent que les autres (ou est utilisé par un autre processus), le modèle est bridé à la vitesse du GPU le plus lent de l’ensemble. </p>
+    <div class="note"><p>
+    Ayant pré-entraîné notre modèle sur une seule A100 80Go, nous n'avons pas pu expérimenter le parallélisme.</p>
+    </div>
+    <p><br></p>
+  
+    <h4 id="les-t-tes-pour-le-finetuning">Les têtes pour le finetuning</h4>
+    <p class="width_125">Nous nous sommes penchés sur les éléments listés ci-dessus dans une optique d’optimiser le pré-entraînement de notre modèle. 
+      En pratique, nous devons ensuite le finetuner pour le spécialiser sur les tâches finales qui nous intéresse.  
+      Pour cela, nous recourrons à des têtes. Pour le <a class="link" href="https://huggingface.co/docs/transformers/model_doc/t5">T5 « standard »</a>, 
+      cinq sont disponibles dans Transformers permettant d’effectuer toutes les tâches faisables : 
+      <a class="link" href="https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5ForConditionalGeneration"><code>T5ForConditionalGeneration</code></a>, 
+      <a class="link" href="https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5ForSequenceClassification"><code>T5ForSequenceClassification</code></a>, 
+      <a class="link" href="https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5ForTokenClassification"><code>T5ForTokenClassification</code></a>,  
+      <a class="link" href="https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5ForQuestionAnswering"><code>T5ForQuestionAnswering</code></a>
+      et <a class="link" href="https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel"><code>T5EncoderModel</code></a>.<br><br>
+      Là encore, un travail d’optimisation peut être effectué.<br>
+      Pour la génération conditionnelle, le principal point est de s’assurer d’avoir un processus de génération efficace.<br>
+      Pour les têtes portant sur des tâches de classification (séquence, NER et QA), il faut s’assurer que l’on utilise la partie encodeur
+      du T5 puisque le décodeur n’est pas essentiel pour celles-ci comme le montre l’EncT5 <d-cite bibtex-key="liu2022enct5"></d-cite>. 
+      En effet, les poids du décodeur prennent inutilement de la place en mémoire, et le temps d’exécution du code du finetuning est doublé inutilement.<br>
+      La dernière tête sert simplement à ne garder que la partie encodeur d'un modèle encodeur-décodeur. Elle n'a donc pas besoin d'être optimisée.</p>
+    <div class="tip"><p>
+    Concernant la tête <code>ForConditionalGeneration</code>, notre 
+      <a class="link" href="https://github.com/catie-aq/flashT5/blob/main/src/model/modeling_flash_t5.py">implémentation</a> 
+      repose sur le processus de génération disponible dans le 
+      <a class="link" href="https://github.com/PiotrNawrot/nanoT5/blob/1c82d67bf8dea635be68a3b2a68a43b68b665193/nanoT5/utils/t5_model.py#L407">nanoT5</a> 
+      car est 14% plus rapide que l’implémentation d’Hugging Face.<br>
+      Concernant les têtes de classification, l’implémentation est disponible dans ce 
+      <a class="link" href="https://github.com/catie-aq/flashT5/blob/main/src/model/custom_heads_flash_t5.py">fichier</a>. 
+      Il s'agit d'un fichier disjoint du fichier modeling car nos implémentations diffèrent de celles disponibles dans Transformers.
+      En effet, les implémentations des têtes <code>T5ForSequenceClassification</code> et de <code>T5ForQuestionAnswering</code> disponibles dans Transformers reposent 
+      sur l’encodeur et le décodeur du T5 ce qui est donc inefficient. 
+      Nous avons donc recodé ces deux têtes pour n'utiliser que l'encodeur. 
+      Nous avons alors suivi la même structure que la tête <code>T5ForTokenClassification</code> disponible dans Transformers qui, 
+      utilise aussi que l'encodeur et donc reprenons telle quelle. </p>
+    </div>
+  
+    <p class="width_125"><br><br><br></p>
+    <h2 id="benchmark">Benchmark</h2>
+
+    <h3 id="TFLOPS">TFLOPS</h3>
+    <p class="width_125">
+    Le nombre de TFLOPS (trillions de calculs en virgule flottante qu'un processeur peut effectuer en une seconde) est probablement la mesure la plus parlante
+    pour étayer l'impact des optimisations effectuées.<br>
+    Nous comparons alors quatre approches :<br>
+    • l'implémentation SPDA (Scaled Dot Product Attention) avec full bias,<br>
+    • la même implémentation mais en Triton,<br>
+    • l'implémentation en Flash Attention RPE, c'est-à-dire le second noyau que nous avons développé (peut être vu comme le turboT5 mais en C++/Cuda avec bf16 full),<br>
+    • l'implémentation en Flash Attention i.e. sans biais. Nous l'indiquons pour avoir une référence car elle est inutilisable en pratique pour un T5.<br>
+    <br>
+    Pour la passe avant, nous avons :
+    </p> 
+    <p class="width_125">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="./assets/FWD-causal-True_dark.png" width="100%">
+      <img alt="Benchmark memory backward pass" src="./assets/FWD-causal-True.png" width="100%">
+    </picture>
+
+    <div class="width_125"><p>Pour la passe avant, nous pouvons observer que l'approche en Triton permet 1,34 fois plus de FLOPS que celle en SPDA et que l'approche en Flash Attention RPE permet 1,99 fois plus de FLOPS que celle en SPDA.<br>
+    Nous pouvons aussi constater que notre implémentation en bf16 est équivalente à du fp16 (faisant même mieux en taille 512).<br>
+    C'est suite à ce benchmark que nous avons décidé d'entraîner notre modèle en français en bf16, head_dim = 128 et avec une séquence 1024.</p></div>
+
+    <br>
+    <p class="width_125">
+    Pour la passe arrière, nous avons :
+    </p>
+  
+    <p class="width_125">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="./assets/BWD-causal-True_dark.png" width="100%">
+      <img alt="Benchmark memory backward pass" src="./assets/BWD-causal-True.png" width="100%">
+    </picture>
+  
+    <div class="width_125"><p>Pour la passe arrière, l'implémentation en Triton se révèle moins efficace que SPDA avec 0,71 fois les FLOPS de SPDA. Celle en Flash Attention RPE est plus ou moins équivalente à SPDA (1,018 fois plus de FLOPS).<br>
+      Nous pouvons également observer que Triton en head_dim 64 est plus efficace que Triton en head_dim 128.</p></div>
+
+
+    <p><br></p>  
+    <h3 id="torchvstriton">Torch vs Triton</h3>
+    <p class="width_125">
+    Nous indiquions plus haut avoir optimisé des parties de l’architecture à l’aide de noyaux Triton ad hoc, à savoir l'entropie croisée et la couche de RMSNorm.
+    Les benchmarks suivants doivent en illustrer la raison.<br>
+      
+    Pour l'entropie croisée, nous obtenons une passe avant 7 à 11,4 fois plus rapide, une passe arrière 3,26 à 3,75 plus rapide ainsi qu'une mémoire réduite d'un facteur 4 :</p>
+
+    <p class="width_125">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="./assets/CE_dark.png" width="100%">
+      <img alt="Benchmark memory backward pass" src="./assets/CE.png" width="100%">
+    </picture>
+
+    <p class="width_125">
+    Pour la couche de RMSNorm, nous obtenons une passe avant 3 à 5 fois plus rapide, une passe arrière 2,33 à 4,33 plus rapide ainsi qu'une mémoire réduite d'un facteur 3,2 :</p>
+
+    <p class="width_125">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="./assets/LN_dark.png" width="100%">
+      <img alt="Benchmark memory backward pass" src="./assets/LN.png" width="100%">
+    </picture>
+
+    <p class="note">
+    Notez que l'ensemble des graphiques des benchmarks peuvent être générés automatiquement via le code <a href="https://github.com/catie-aq/flashT5/tree/main/benchmarks">suivant</a>.
+    </p>
+
+    <p><br><br></p>
+    <h3 id="mod-le-en-fran-ais">Modèle en français</h3>
+    <p class="width_125">Nous avons appliqué notre travail au français en pré-entraînant un modèle de 147M de paramètres. <br>
+    Le jeu de données que nous avons utilisé est un mélange de CulturaX, Wikipedia, justice_fr et The Stack. <br>
+    Notre <em>tokenizer</em> de taille 32 768 (8**5) est entraîné sur CulturaX et The Stack.<br>
+    Notre modèle est pré-entraîné sur une séquence de 1 024 tokens.</p>
+
+    <p class="width_125">
+    Nous souhaitions comparer les performances de notre modèle face à d'autres modèles en français précédemment publiés comme le CamemBERT <d-cite bibtex-key="Martin_2020"></d-cite> pour les tâches de classification et le BARThez <d-cite bibtex-key="eddine2021barthez"></d-cite> pour les tâches de génération.<br>
+    Pour cela, il nous est paru important de faire des comparaisons à nombre de <i>tokens</i> vus équivalent.
+    Nous avons ainsi essayé d'estimer le nombre de <i>tokens</i> vus par ces deux modèles via la formule nombre de steps × la taille de la séquence × la taille du batch. Nous n'avons pas trouvé les informations dans la publication du BARThez pour le faire. Pour le CamemBERT nous l'estimons à environ 419,4 Mds de <i>tokens</i> au maximum. Ce chiffre pourrait être en réalité moins élevé car nous ne connaissons pas le nombre de <i>tokens</i> de <i>padding</i> vus par ce modèle (là où dans notre cas, nous n'en utilisons pas). Ainsi, nous avons pré-entraîné notre modèle sur le nombre maximal de <i>tokens</i> vus par le CamemBERT.<br></p>
+
+    <p><br></p>
+
+    <p class="width_125">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="./assets/loss_train.png" width="49%">
+      <img alt="Convergence masked accuracy FAT5" src="./assets/loss_train.png" width="49%">
+     </picture>
+     <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="./assets/loss_eval.png" width="49%">
+      <img alt="Convergence masked accuracy FAT5" src="./assets/loss_eval.png" width="49%">
+    </picture>
+    </p>
+
+    <p><br></p>
+
+    <p class="width_125">
+    Nous nous sommes également intéressés à comparer notre modèle face à lui-même, c'est-à-dire que nous avons évalué ses performances sur les tâches en aval toutes les 100 000 steps (~26 Mds de tokens) au cours du pré-entraînement.<br>
+    Dans le tableau ci-dessous, nous avons listés le nombre de <i>tokens</i> équivalents à chaque intervalle de 100 000 steps.<br>
+    </p>
+  
+    <table class="width_125">
+    <thead>
+    <tr>
+    <th>Modèle</th>
+    <th>Nombre de <em>tokens</em> ✝</th>
+    </tr>
+    </thead>
+    <tbody>
+    <tr>
+    <td>FAT5-small-100K</td>
+    <td>26 214 400 000 (100 000 × 1024 × 256)</td>
+    </tr>    
+    <tr>
+    <td>FAT5-small-200K</td>
+    <td>52 428 800 000 (200 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-300K</td>
+    <td>78 643 200 000 (300 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-400K</td>
+    <td>104 857 600 000 (400 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-500K</td>
+    <td>131 072 000 000 (500 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-600K</td>
+    <td>157 286 400 000 (600 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-700K</td>
+    <td>183 500 800 000 (700 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-800K</td>
+    <td>209 715 200 000 (800 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-900K</td>
+    <td>235 929 600 000 (900 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1000K</td>
+    <td>262 144 000 000 (1 000 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1100K</td>
+    <td>288 358 400 000 (1 100 000× 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1200K</td>
+    <td>314 572 800 000 (1 200 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1300K</td>
+    <td>340 787 200 000 (1 300 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1400K</td>
+    <td>367 001 600 000 (1 400 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1500K</td>
+    <td>393 216 000 000 (1 500 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1600K</td>
+    <td>419 430 400 000 (1 600 000 × 1024 × 256)</td>
+    </tr>
+    <tr>
+    <td><a class="link" href="https://hf.co/almanach/camembert-base">camembert (base ou large)</a></td>
+    <td>419 430 400 000 (100 000 × 512 × 8192)</td>
+    </tr>
+    </tbody>
+    </table>
+    <p class="width_125">✝ équivaut au nombre de steps × la taille de la séquence × la taille du batch</p>
+
+
+     <p><br></p>
+    <h4 id="finetuning">Finetuning</h4>
+    <p class="width_125">Nous nous sommes focalisés sur cinq tâches :<br>
+    &nbsp; • Du résumé de textes pour illustrer un usage de la tête <code>T5ForConditionalGeneration</code>,<br>
+    &nbsp; • De la classification binaire pour illustrer un usage de la tête <code>T5ForSequenceClassification</code>,<br>
+    &nbsp; • De la reconnaissance d’entités nommées pour illustrer un usage de la tête <code>T5ForTokenClassification</code>,<br>
+    &nbsp; • Du question answering pour illustrer un usage de la tête <code>T5ForQuestionAnswering</code>.<br>
+    &nbsp; • De la <i>sentence similarity</i> pour illustrer un usage de la tête <code>T5EncoderModel</code>.</p>
+
+  <p class="width_125"> Les tâches de classification nous semblent être importantes à évaluer car elles sont généralement ignorées par les benchmarks des grands modèles de langue génératifs alors qu’il de tâches fréquemment utilisées en pratique par les entreprises (recherche documentaire, classification pour d'avis clients, anonymisation de données, etc.).
+      En témoigne sûrement le fait que 6 ans et demi après sa sortie, BERT <d-cite bibtex-key="devlin2019bert"></d-cite> est téléchargé plus de fois par mois à lui seul que les <a class="link" href="https://huggingface.co/models?pipeline_tag=text-generation&amp;sort=downloads">30 modèles de génération de textes</a> les plus téléchargés sur Hugging Face au moment où nous écrivons ces lignes : 38,5M contre 31,3M.</p>
+
+  <p class="width_125">Dans les tableaux suivants, nous soulignons pour le FAT5 la ligne obtenant le meilleur résultat pour chacune des tâches. Nous interprétons les résultats de la partie génération après le tableau sur le résumé de texte. Les résultats sur la partie classification sont interprétés après l'ensemble des tableaux de classification binaire, QA, NER et de <i>sentence-similarity</i>.</p>
+
+    <p><br></p>
+    <h5>Résumé de textes</h5>
+    <p class="width_125">Pour cette tâche, nous avons utilisé le jeu de données <a class="link" href="https://huggingface.co/datasets/orange_sum">orange_sum</a><d-cite bibtex-key="eddine2021barthez"></d-cite>.</p>
+    <table class="width_125">
+    <thead>
+    <tr>
+    <th>Modèle</th>
+    <th>ROUGE-1</th>
+    <th>ROUGE-2</th>
+    <th>ROUGE-L</th>
+    </tr>
+    </thead>
+    <tbody>
+    <tr>
+    <td>FAT5-small-100K (147M)</td>
+    <td>28,17</td>
+    <td>10,60</td>
+    <td>20,62</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-200K (147M)</td>
+    <td>28,72</td>
+    <td>10,86</td>
+    <td>20,68</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-300K (147M)</td>
+    <td>28,76</td>
+    <td>10,85</td>
+    <td>20,63</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-400K (147M)</td>
+    <td>28,59</td>
+    <td>10,76</td>
+    <td>20,60</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-500K (147M)</td>
+    <td>28,98</td>
+    <td>10,97</td>
+    <td>20,72</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-600K (147M)</td>
+    <td>29,04</td>
+    <td>11,20</td>
+    <td>20,89</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-700K (147M)</td>
+    <td>28,72</td>
+    <td>10,87</td>
+    <td>20,77</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-800K (147M)</td>
+    <td>29,00</td>
+    <td>10,91</td>
+    <td>20,78</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-900K (147M)</td>
+    <td>29,30</td>
+    <td>11,34</td>
+    <td>21,22</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1000K (147M)</td>
+    <td>29,10</td>
+    <td>11,21</td>
+    <td>21,08</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1100K (147M)</td>
+    <td>29,43</td>
+    <td>11,40</td>
+    <td>21,15</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1200K (147M)</td>
+    <td>29,30</td>
+    <td>11,38</td>
+    <td>21,18</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1300K (147M)</td>
+    <td>29,38</td>
+    <td>11,38</td>
+    <td>21,18</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1400K (147M)</td>
+    <td>29,29</td>
+    <td>11,18</td>
+    <td>21,14</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1500K (147M)</td>
+    <td><u>29,48</u></td>
+    <td><u>11,48</u></td>
+    <td><u>21,22</u></td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1600K (147M)</td>
+    <td>29,30</td>
+    <td>11,27</td>
+    <td>21,10</td>
+    </tr>
+    <tr>
+    <td><a class="link" href="https://huggingface.co/moussaKam/barthez">Barthez<d-cite bibtex-key="eddine2021barthez"></d-cite></a> (165M)</td>
+    <td>31.44</td>
+    <td>12.77</td>
+    <td>22.23</td>
+    </tr>
+    <tr>
+    <td><a class="link" href="https://huggingface.co/moussaKam/mbarthez">mBarthez</a> (458M)</td>
+    <td>32.67</td>
+    <td>13.73</td>
+    <td>23.18</td>
+    </tr>
+    </tbody>
+    </table>
+
+    <p><br></p>
+  <p class="width_125">Nous pouvons constater que notre modèle performe moins bien que le Barthez. Nous pouvons émettre quelques hypothèses à ce sujet. <br>
+  Premièrement, il est vraisemblable que notre processus de génération de texte ne soit pas optimal. Ne connaissant pas celui utilisé par le Barthez, nous avons simplement recouru aux paramètres par défaut de la fonction <a class="link" href="https://github.com/huggingface/transformers/blob/241c04d36867259cdf11dbb4e9d9a60f9cb65ebc/src/transformers/generation/utils.py#L1905">generate</a> de Hugging Face pour ne pas avantager notre modèle avec un processus de génération qui serait plus sophistiqué.<br>
+  Deuxièmement, nous n'avons pas utilisé de <i>prompt</i> pour conditionner la génération, ce qui aurait pu bénéficier à notre modèle puisque le T5 est le modèle ayant introduit ce système.<br>
+  Troisièmement, le Barthez a sûrement vu plus de <i>tokens</i> que notre modèle. Bien que nous n'arrivons pas à déterminer ce nombre d'après la publication des auteurs, il est indiqué que c'est un modèle BART <d-cite bibtex-key="lewis2019bartdenoisingsequencetosequencepretraining"></d-cite> qui a reçu un pré-entraînement supplémentaire sur du français. Or dans le papier de BART, il est indiqué que le modèle a été entraîné sur 500000 steps × une séquence de 1 024 <i>tokens</i> × un batch de taille 8000, soit 4 096 000 000 000 <i>tokens</i>, ce qui 9,76 fois plus que notre modèle.
+  </p>
+  
+    <p><br></p>
+    <h5 id="classification">Classification</h5>
+    <p class="width_125">Nous utilisons une version nettoyée du jeu de données allocine <d-cite bibtex-key="allocine"></d-cite> : <a class="link" href="https://huggingface.co/datasets/CATIE-AQ/allocine_clean">allocine_clean</a>. Plus précisément 0,6 % de l'échantillon de test n’était pas fiable car contenait des fuites ou des données dupliquées. Il est probable que le jeu de données obtenu soit encore imparfait avec notamment des problèmes d'annotations nécessitant un travail de relecture/correction plus important.
+    </p>
+    <table class="width_125">
+    <thead>
+    <tr>
+    <th>Modèle</th>
+    <th>Accuracy</th>
+    </tr>
+    </thead>
+    <tbody>
+    <tr>
+    <td>FAT5-small-100K (67,4M)</td>
+    <td>96,05</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-200K (67,4M)</td>
+    <td>96,20</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-300K (67,4M)</td>
+    <td>96,48</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-400K (67,4M)</td>
+    <td>96,60</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-500K (67,4M)</td>
+    <td>96,60</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-600K (67,4M)</td>
+    <td>96,60</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-700K (67,4M)</td>
+    <td>96,68</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-800K (67,4M)</td>
+    <td>96,59</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-900K (67,4M)</td>
+    <td><u>96,75</u></td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1000K (67,4M)</td>
+    <td>96,62</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1100K (67,4M)</td>
+    <td>96,69</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1200K (67,4M)</td>
+    <td>96,71</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1300K (67,4M)</td>
+    <td>96,69</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1400K (67,4M)</td>
+    <td>96,65</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1500K (67,4M)</td>
+    <td>96,57</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1600K (67,4M)</td>
+    <td>96,69</td>
+    </tr>
+    <tr>
+    <td><a class="link" href="">distilcamembert</a> (68,1M)</td>
+    <td>96,74</td>
+    </tr>
+    <tr>
+    <td><a class="link" href="https://huggingface.co/bourdoiscatie/camembert_base_cls">camembert-base</a> (111M)</td>
+    <td>97,27</td>
+    </tr>
+    <tr>
+    <td><a class="link" href="https://huggingface.co/bourdoiscatie/camembert_large_cls">camembert-large</a> (337M)</td>
+    <td>97,15</td>
+    </tr>
+    <tr>
+    </tbody>
+    </table>
+    <p class="width_125">Note : dans le tableau et dans les suivants, distilcamembert se réfère au <a class="link" href="https://huggingface.co/cmarkea/distilcamembert-base">distilcamembert-base</a> <d-cite bibtex-key="delestre2022distilcamembert"></d-cite> que nous avons finetuné.</p>
+  
+    <p><br></p>
+    <h5>Reconnaissance d’entités nommées</h5>
+    <p class="width_125">Pour cette tâche, nous avons utilisé frenchNER dans sa configuration <a class="link" href="https://huggingface.co/datasets/CATIE-AQ/frenchNER_4entities">4 entités</a> (PER, LOC, ORG, MISC) <d-cite bibtex-key="frenchNER2024"></d-cite>.</p>
+    <table class="width_125">
+    <thead>
+    <tr>
+    <th>Modèle</th>
+    <th>F1 PER</th>
+    <th>F1 LOC</th>
+    <th>F1 ORG</th>
+    <th>F1 MISC</th>
+    </tr>
+    </thead>
+    <tbody>
+    <tr>
+    <td>FAT5-small-100K  (67,1M)</td>
+    <td>96,51</td>
+    <td>94,48</td>
+    <td>87,24</td>
+    <td>75,81</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-200K  (67,1M)</td>
+    <td>96,90</td>
+    <td>94,83</td>
+    <td>88,78</td>
+    <td>76,82</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-300K  (67,1M)</td>
+    <td>97,25</td>
+    <td>95,11</td>
+    <td>88,86</td>
+    <td><u>77,48</u></td>
+    </tr>
+    <tr>
+    <td>FAT5-small-400K  (67,1M)</td>
+    <td>97,18</td>
+    <td>95,08</td>
+    <td>89,11</td>
+    <td>77,42</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-500K  (67,1M)</td>
+    <td>97,25</td>
+    <td>95,16</td>
+    <td>89,16</td>
+    <td>76,91</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-600K  (67,1M)</td>
+    <td>97,19</td>
+    <td>95,19</td>
+    <td>88,85</td>
+    <td>76,88</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-700K  (67,1M)</td>
+    <td>97,17</td>
+    <td>95,14</td>
+    <td>89,39</td>
+    <td>76,82</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-800K  (67,1M)</td>
+    <td><u>97,34</u></td>
+    <td>95,20</td>
+    <td>89,18</td>
+    <td>77,27</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-900K  (67,1M)</td>
+    <td>97,19</td>
+    <td>95,21</td>
+    <td>89,04</td>
+    <td>76,83</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1000K  (67,1M)</td>
+    <td>97,31</td>
+    <td>95,26</td>
+    <td>89,24</td>
+    <td>76,84</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1100K  (67,1M)</td>
+    <td>97,11</td>
+    <td>94,99</td>
+    <td>88,52</td>
+    <td>76,30</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1200K  (67,1M)</td>
+    <td>97,19</td>
+    <td>95,11</td>
+    <td>88,79</td>
+    <td>76,86</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1300K  (67,1M)</td>
+    <td>97,15</td>
+    <td>95,00</td>
+    <td>88,62</td>
+    <td>76,58</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1400K  (67,1M)</td>
+    <td>97,22</td>
+    <td>95,09</td>
+    <td>89,01</td>
+    <td>77,00</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1500K  (67,1M)</td>
+    <td>97,32</td>
+    <td><u>95,34</u></td>
+    <td><u>89,39</u></td>
+    <td>77,30</td>
+    </tr>
+    <tr>
+    <td>FAT5-small-1600K  (67,1M)</td>
+    <td>97,14</td>
+    <td>95,22</td>
+    <td>89,24</td>
+    <td>76,88</td>
+    </tr>
+    <tr>
+    <td><a class="link" href="">distilcamembert</a>  (67,5M)</td>
+    <td>97,26</td>
+    <td>95,24</td>
+    <td>89,10</td>
+    <td>79,88</td>
+    </tr>
+    <tr>
+    <td><a class="link" href="https://huggingface.co/CATIE-AQ/NERmembert-base-4entities">camembert-base</a> (110M)</td>
+    <td>97,80</td>
+    <td>95,78</td>
+    <td>90,27</td>
+    <td>81,38</td>
+    </tr>
+    <tr>
+    <td><a class="link" href="https://huggingface.co/CATIE-AQ/NERmembert-large-4entities">camembert-large</a> (336M)</td>
+    <td>98,17</td>
+    <td>96,37</td>
+    <td>91,87</td>
+    <td>83,35</td>
+    </tr>
+    </tbody>
+    </table>
+
+    <p><br></p>
+      <h5 id="question-answering">Question Answering</h5>
+    <p class="width_125">
+    Nous avons voulu finetuner notre modèle sur cette tâche mais nous nous sommes rendu compte que notre tokenizer a deux problèmes.<br>
+    Premièrement, nous avons oublié d'ajouter le token de début de phrase.  
+    Deuxièmement, nous avons décidé d'utiliser un fast BPE tokenizer. Nous avons appris après coup que l'argument `add_special_tokens=True` ne fonctionne pas avec ce type de tokenizer.
+    Corriger ces deux points nécessite de post-traiter les encodages du tokenizer avant d'effectuer notre tâche de finetuning ce qui n'est pas élégant et nécessite du temps que nous n'avons pas dans l'immédiat.  
+    <p><br></p>
+
+    <h5><i>Sentence Similarity</i></h5>
+    <p class="width_125">
+    Nous invitons le lecteur à prendre les résultats de cette section avec des pincettes.<br>
+    Nous avons effectué un finetuning sur cette tâche afin de vérifier que la tête <code>T5EncoderModel</code> fonctionnait
+    mais nous ne nous focalisons pas sur les résultats obtenus car nous nous interrogeons sur la qualité du benchmark sur lequel nous évaluons les modèles,
+    à savoir MTEB FR <d-cite bibtex-key="ciancone2024mtebfrenchresourcesfrenchsentence"></d-cite>, une version française de MTEB.<br>
+      
+    En effet, Nils Reimers, créateur du MTEB, a récemment remis en cause dans un <a class="link" href="https://x.com/Nils_Reimers/status/1870812625505849849">tweet</a>
+    la pertinence de ce benchmark, le déclarant « mort ».
+      
+    Plus tôt dans l'année, nous avions d'ailleurs observé des fuites de données et des duplications dans ce benchmark 
+      (voir <a class="link" href="https://huggingface.co/datasets/lbourdois/MTEB_leaks_and_duplications">ici</a> et
+      <a class="link" href="https://github.com/embeddings-benchmark/mteb/issues/1036">ici</a>).
+    Alexey Vatolin a ensuite étendu ces observations en prenant également en compte les lignes vides (voir <a class="link" href="https://github.com/embeddings-benchmark/mteb/issues/1049#issuecomment-2463095122">ici</a>).
+    <br>
+    
+    Dans le tableau ci-dessous, nous finetunons sur une version nettoyée du jeu de données <code>stsb_multi_mt</code> <d-cite bibtex-key="huggingface:dataset:stsb_multi_mt"></d-cite> (0,653 % du test split n'était pas fiable parce qu'il contenait des fuites ou des données dupliquées) avant d'évaluer sur MTEB FR.
+    <br>
+    </p>
+  
+      
+    <table class="width_125">
+    <thead>
+    <tr>
+    <th>Modèle</th>
+    <th>Moyenne</th>
+    <th>Classification</th>
+    <th>Clustering</th>
+    <th>PairClassification</th>
+    <th>Reranking</th>
+    <th>Retrieval</th>
+    <th>STS</th>
+    <th>Summary</th>
+    </tr>
+    </thead>
+    <tbody>
+    <tr>
+    <td>FAT5-small-400K (67,1M)</td>
+    <td>52,2</td>
+    <td>59,8</td>
+    <td>39,1</td>
+    <td>77,5</td>
+    <td>56,1</td>
+    <td>29,1</td>
+    <td>74</td>
+    <td>29,8</td>
+    </tr>
+    <tr>
+    <td>distilcamembert(68,1M)</td>
+    <td>51,3</td>
+    <td>60,7</td>
+    <td>37,4</td>
+    <td>77</td>
+    <td>51,1</td>
+    <td>25,2</td>
+    <td>76,4</td>
+    <td>31,3</td>
+    </tr>
+    </tbody>
+    </table>
+
+    <p><br><br><br></p>
+  
+    <p class="width_125">     
+    Nous observons dans le graphique de la convergence de la <i>masked accuracy</i>, que les performances de la partie encodeur du modèle progressent dans un premier temps avant de s'aplatir.       
+    </p>
+    <p><br></p>
+
+    <p class="width_125">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="./assets/convergence_masked_accuracy_FAT5.png" width="100%">
+      <img alt="Convergence masked accuracy FAT5" src="./assets/convergence_masked_accuracy_FAT5.png" width="100%">
+    </picture>
+    </p>
+
+    <p><br></p>
+
+  <p class="width_125">   
+    Ce phénomène s'observe aussi dans les résultats des finetunings, le FAT5 match les performances du distilcamembert aux alentours de 800 ou 900K steps (à l'exception de l'entité MISC pour la NER) mais ne fait pas mieux au-delà. Cela est néanmoins encourageant en vue d'un passage à l'échelle puisque les modèles distillés issus de modèles plus importants donnent habituellement de meilleurs résultats que les modèles entraînés de zéro.<br>
+    Notons que cette forme de plateau dans les performances serait à confirmer en effectuant plusieurs exécutions avec des configurations différentes (au niveau de la <i>seed</i> notamment) pour proposer des résultats sous la forme d'un intervalle au lieu d'un résultat unique (pour chaque step évaluée, nous utilisons une <i>seed</i> de 42).<br>
+  Signalons également que ce plafonnement pour la partie encodeur a déjà été observé par d'autres auteurs. On peut par exemple citer le CamemBERT(a) 2.0 <d-cite bibtex-key="antoun2024camembert20smarterfrench"></d-cite> qui a également été entraîné sur la partie en français de CulturaX. Le CamemBERT 2.0 n'apparaît pas plus performant que le CamemBERT 1.0 alors qu'il a vu davantage de <i>tokens</i>. Les auteurs obtiennent par contre des gains de performances avec le CamemBERTa 2.0, suggérant ainsi que pour les encodeurs, l'importance est de se focaliser en priorité sur l'architecture (le CamemBERTa 2.0 est un DeBERTaV3 <d-cite bibtex-key="he2023debertav3improvingdebertausing"></d-cite>  alors que le CamemBERT 2.0 est un RoBERTa <d-cite bibtex-key="liu2019robertarobustlyoptimizedbert"></d-cite>) plutôt que sur les données. Ce résultat nous invite à réfléchir à une actualisation de l'encodeur du T5.<br>
+  Une dernière observation pouvant être faite, est que si les performances plafonnent, il est possible de se permettre de stopper le pré-entraînement plus tôt et donc réduire les coûts.<br>
+
+    Dans le tableau ci-dessous, nous listons des estimations de coûts (en euros) pour le pré-entraînement de notre modèle selon divers <i>cloud providers</i>. 
+    Pour chacun d'eux, nous nous basons sur le prix horaire d'une A 100 80GB proposé le 20 décembre 2024.<br>
+    Nous indiquons deux cas, un pré-entraînement sur 262 Mds de <i>tokens</i> (seuil où on observe que les performances sur les tâches de classifications commencent à plafonner et que les gains marginaux deviennent alors faibles) sur 419 Mds de <i>tokens</i> (le nombre de <i>tokens</i> vus au maximum par le CamemBERT).
+    <br>
+    </p>
+    
+    <table class="width_125">
+    <thead>
+    <tr>
+    <th>Cloud provider</th>
+    <th>Prix horaire d'une A 100</th>
+    <th>Prix pour 262 Mds de tokens</th>
+    <th>Prix pour 419 Mds de tokens</th>
+    <th>Note</th>
+    </tr>
+    </thead>
+    <tbody>
+    <tr>
+    <td>AWS</td>
+    <td>1,77</td>
+    <td>1 616</td>
+    <td>2 586</td>
+    <td></td>
+    </tr>
+    <tr>
+    <td>OVH</td>
+    <td>2,75</td>
+    <td>2 475</td>
+    <td>3 960</td>
+    <td>En optant pour un payement mensuel plutôt qu'horaire, le prix dans les deux cas n'est plus que de 2 200€.</td>
+    </tr>
+    <tr>
+    <td>Azure</td>
+    <td>3,31</td>
+    <td>3 021</td>
+    <td>4 833</td>
+    <td>Le prix horaire a été calculé à partir du prix mensuel de 8 A100.</td>
+    </tr>
+    <tr>
+    <td>Google Cloud</td>
+    <td>3,52</td>
+    <td>3 214</td>
+    <td>5 143</td>
+    <td></td>
+    </tr>
+    </tbody>
+    </table>
+    
+
+  
+    <br><br>
+    
+  
+    <p><br><br></p>
+    <h4>Temps et émissions par pré-entraînement</h4>
+    <p class="width_125">Les émissions carbones ont été estimées à l’aide du <a class="link" href="https://mlco2.github.io/impact#compute">Machine Learning Impact calculator</a> <d-cite bibtex-key="lacoste2019quantifying"></d-cite>.<br>
+      Notre modèle a été pré-entraîné sur une A100 PCIe 80GB, sur une infrastructure privée. 
+      Pour l'efficacité carbone, nous nous sommes basés sur les chiffres journaliers indiqués 
+      par <a class="link" href="https://app.electricitymaps.com/zone/FR">electricitymaps</a> pour la France lors de la période de notre pré-entraînement.<br>
+      Les finetunings ont été effectués pour leur part sur une A100 PCIe 40GB. 
+      Le temps d’exécution se comptant généralement en heures voire en minutes, pour l’efficacité carbone nous nous référons alors au chiffre d’electricitymaps indiqué pour l’heure en question plutôt que pour le chiffre journalier.<br>
+      Nous estimons ainsi les émissions de notre modèle à 14,084 kg eq. CO2, 
+      dont 13,5 kg eq. CO2 pour le pré-entraînement et 0,584 kg eq. CO2 pour les 49 finetunings.<br>
+      À ce chiffre, nous devons ajouter des émissions supplémentaires estimées à 6,24 kg eq. CO2.
+      Elles correspondent au finetuning de modèles pour établir les baselines auxquelles se comparer (0,475 kg eq. CO2), à nos travaux préliminaires en bf16 mixed (4,735 kg eq. CO2 pour le pré-entraînement de trois modèles différents sur 300K steps) et à des tests en bf16 full avant l'entraînement de notre modèle final (1,03 kg eq. en pré-entraînement d'un modèle deux fois plus petit sur 400K steps).<br>
+      Ainsi, au total, nous estimons l’empreinte carbone de nos travaux à 20,324 kg eq. CO2.  </p>
+  
+    <p class="width_125">Sur la phase de pré-entraînement (nous n’avons pas assez d’informations pour faire des estimations pour les autres phases),
+      il est alors possible de nous situer vis-à-vis des autres modèles en français pré-entraînés listés précédemment : </p>
+    <table class="width_125">
+    <thead>
+    <tr>
+    <th>Modèle</th>
+    <th>Temps (H)</th>
+    <th>Emissions (kg Co2 eq)</th>
+    <th>Note</th>
+    </tr>
+    </thead>
+    <tbody>
+    <tr>
+    <td>Camembert</td>
+    <td>6 144</td>
+    <td>106,91 ✝</td>
+    <td>24H × 256 Tesla V100-SXM2-32GB à 58g (moyenne sur 2019) <br>Les auteurs ne précisent pas les chiffres pour la version large</td>
+    </tr>
+    <tr>
+    <td>Flaubert base <d-cite bibtex-key="le2020flaubert"></d-cite></td>
+    <td>13 120</td>
+    <td>190,24 à 228,29 ✝</td>
+    <td>410H × 32 V100  à 58g (moyenne sur 2019) <br>Le type de la V100 n’est pas spécifié<br>(V100-SXM2-32GB ? V100-SXM2-16GB ? V100-PCIE-16GB ?)</td>
+    </tr>
+    <tr>
+    <td>Flaubert large <d-cite bibtex-key="le2020flaubert"></d-cite></td>
+    <td>49 920</td>
+    <td>723,84 à 868,61 ✝</td>
+    <td>390H × 128 V100  à 58g (moyenne sur 2019) <br>Le type de la V100 n’est pas spécifié<br>(V100-SXM2-32GB ? V100-SXM2-16GB ? V100-PCIE-16GB ?)</td>
+    </tr>
+    <tr>
+    <td>Barthez</td>
+    <td>7 680 ★</td>
+    <td>107,52 à 129,02 ✝</td>
+    <td>60H × 128 V100  à 56g (moyenne sur 2020) <br>Le type de la V100 n’est pas spécifié<br>(V100-SXM2-32GB ? V100-SXM2-16GB ? V100-PCIE-16GB ?)</td>
+    </tr>
+    <tr>
+    <td>FAT5-small</td>
+    <td>1 461</td>
+    <td>13,5</td>
+    <td>1 461H × 1 A100 à 36,96 g (moyenne entre le 18/10/2024 et le 19/12/2024)</td>
+    </tr>
+    </tbody>
+    </table>
+    <p class="width_125">✝ les chiffres indiqués sont des estimations à partir des informations fournies par les auteurs dans leur publication<br>
+    ★ nous indiquons uniquement les heures pour le pré-entraînement en français appliqué par dessus le pré-entraînement en anglais initial sur lequel se base le modèle</p>
+
+    <p><br></p>
+
+    <h3 id="mod-les-en-anglais">Modèles dans d'autres langues</h3>
+    <p class="width_125">
+      Notre contribution se focalise sur le français avec l'introduction d'un nouveau modèle. Pour d'autres langues, nous ne pouvons pas nous permettre d’effectuer un travail de la même envergure.<br>
+      Néanmoins, nous mettons à disposition un <a class="link" href="https://github.com/catie-aq/flashT5/blob/main/convert_huggingface_t5.py">code</a> permettant d'adapter vers notre méthode des poids de (m)T5/FLAN-T5 <d-cite bibtex-key="chung2022scaling"></d-cite> déjà pré-entraînés. Nous espérons ainsi que les utilisateurs pourront poursuivre efficacement le pré-entraînement d'un de ces modèles pour l'adapter à des données plus récentes par exemple.<br>
+      Notez cependant que cette adaptation est limitée puisque le pré-entraînement supplémentaire devra être effectué dans la précision du modèle original. Par exemple, si les poids du modèle sont en fp32 (ce qui est le cas du FLAN-T5), l'entraînement ne sera pas aussi rapide que le FAT5 qui est en bf16.<br><br>  
+    
+    Pour les anglophones, nous avons déjà adapté les poids des différentes versions du FLAN-T5 à notre méthode. Tous les poids peuvent être trouvés dans cette 
+    <a class="link" href="https://huggingface.co/collections/CATIE-AQ/catie-english-fat5-flan-662b679a8e855c7c0137d69e">collection Hugging Face</a>.<br><br>  
+
+    Si vous souhaitez pré-entraîner votre propre modèle (pour être spécialisé dans un domaine spécifique par exemple, et ainsi bénéficier d'un <i>tokenizer</i> personnalisé), nous vous renvoyons à nouveau vers le <a class="link"  href="https://github.com/catie-aq/flashT5/tree/main/examples/minipile">tutoriel</a> indiquant comment procéder pour pré-entraîner un modèle sur minipile. Notez que nous avons testé et entraîné le modèle du tutoriel sur une A100, cela peut ou non fonctionner avec d'autres GPU.</p>
+    <p class="width_125"><br><br><br></p>
+
+    
+    <h2 id="la-suite">La suite</h2>
+    <p class="width_125">Terminons cet article en évoquant ce que nous comptons, ou du moins aimerions, donner comme suite à ce travail.<br></p>
+
+    <h3>À court terme</h3>
+    <p class="width_125">Il s'agit ici de choses qui auraient déjà dû être présentes dans cet article mais qui ont pris plus de temps que prévu.
+    Typiquement, nous avons terminé la conception des jeux de données mais n'avons pas eu le temps d'effectuer les finetunings.<br>
+    L'objectif est d'effectuer ces tâches prochainement pour pouvoir ajouter les résultats obtenus dans une actualisation de cet article de blog.
+    </p>
+
+    <h4>Corriger le tokenizer</h4>
+    <p class="width_125">
+    Le FAT5 actuel est utilisable. Néanmoins, du fait des problèmes avec le <i>tokenizer</i> entraînant des post-traîtement inélégant pour certaines tâches, nous n'excluons pas de ré-entraîner un modèle (sur 1M de steps seulement) avec un nouveau <i>tokenizer</i> permettant un usage plus simple du modèle.      
+    <br><br></p>
+      
+    <h4>Modèle instruct</h4>
+    <p class="width_125">Nous souhaiterions tester les capacités de génération de textes du FAT5 de façon plus optimale via notamment l'usage de <i>prompts</i> en développant un modèle instruct.<br>
+    Pour cela, nous disposons du <a class="link" href="https://huggingface.co/datasets/CATIE-AQ/DFP">DFP</a> (<i>Dataset of French Prompts</i>) <d-cite bibtex-key="centre_aquitain_des_technologies_de_l'information_et_electroniques_2023"></d-cite>, un jeu de données de plus de 100M de lignes portant sur trente tâches de NLP. Il reprend la méthodologie du jeu de données <a class="link" href="https://huggingface.co/datasets/bigscience/xP3">xP3</a> ayant servi au mT0 <d-cite bibtex-key="muennighoff2023crosslingualgeneralizationmultitaskfinetuning"></d-cite>. Nous pourrions à cette occasion également vérifier le "Finding 2"  de BigScience <d-cite bibtex-key="wang2022languagemodelarchitecturepretraining"></d-cite> (page 9 de la publication) indiquant que les modèles encodeur-décodeur auraient de meilleures capacités en 0-shot que les modèles décodeur. <br>
+    Au-delà du NLP, nous possédons aussi plus de 2M de lignes de prompt de type "open QA" qui doivent nous permettre de tester le FAT5 sur des tâches/connaissances plus généralistes.<br><br>
+      
+    La conception de ce modèle instruct doit en outre nous permettre de travailler sur son alignement, notamment via un jeu de données de 12M de lignes pour effectuer de la DPO en français.<br><br><br></p>
+    
+    <h4>Longues séquences</h4>
+    <p class="width_125">
+    Le pré-entraînement effectué porte sur des séquences de 1 024 <i>tokens</i>. Or, le noyau CUDA que nous avons développé prend en compte des encodages positionnels permettant d'étendre fortement cette taille de contexte ainsi qu'une inférence linéaire.<br>
+    Dans cette logique, nous avons créé deux jeux de données de longues séquences en français (un de QA, un de résumé de textes) sur lesquels nous souhaitons finetuner notre modèle.<br><br></p>
+  
+    <h3>À long terme</h3>
+    <p class="width_125">Les éléments listés ci-dessous portent sur des pistes à plus long terme. C'est-à-dire que leur implémentation prendra du temps et feront l'objet d'un nouvel article de blog le cas échéant.</p>
+
+  <h4 id="calcul-lin-aire">Réduction de la mémoire</h4>
+  <p class="width_125">Bien que déjà satisfaits par les optimisations effectuées sur la mémoire via notre noyau CUDA, nous pensons que nous pouvons pousser ces résultats plus loin via d'autres techniques. Par exemple, nous pouvons citer la méthode CCE (Cut Cross-Entropy) <d-cite bibtex-key="wijmans2024cut"></d-cite> avec laquelle nous avons déjà obtenus des résultats intéressants sur des modèles décodeur.<br>
+  De plus, alors que nous nous sommes concentrés sur le pré-entraînement, un travail serait à faire sur l'inférence qui en pratique consomme le plus de ressources dans le temps une fois le modèle en production. Nous pensons notamment à utiliser la SageAttention2 <d-cite bibtex-key="zhang2024sageattention2efficientattentionthorough"></d-cite> sortie pendant que notre modèle s'entraînait.
+  <br><br></p>
+    
+    <h4 id="calcul-lin-aire">Calcul linéaire</h4>
+    <p class="width_125">Dans ce travail, nous présentons un modèle à mémoire linéaire. 
+    Une amélioration supplémentaire consisterait à ce qu’en plus de cette mémoire, le modèle opère avec des calculs linéaires.<br>
+     L’idée est de substituer l’attention quadratique traditionnelle par une autre forme d’attention.<br>
+    On peut penser à certaines déjà appliquées au T5, comme celle du LongT5 <d-cite bibtex-key="guo2022longt5"></d-cite>.
+    Il est aussi envisageable de tester des formes plus récentes comme Based <d-cite bibtex-key="arora2024simple"></d-cite>.
+    Nous sommes également intéressés par effectuer des tests avec Hedgehog <d-cite bibtex-key="zhang2024hedgehog"></d-cite>. 
+    En effet, il est possible de les associer aux noyaux optimisés disponibles dans <a class="link" href="https://github.com/HazyResearch/ThunderKittens/tree/main/kernels">ThunderKittens</a> <d-cite bibtex-key="thunderkittens"></d-cite>.
+    L’intérêt est qu’il est alors possible de garder le modèle pré-entraîné et, via un finetuning supplémentaire, de remplacer l’attention standard avec softmax par une linéaire avec Hedgehog.<br>
+    LoLCATs <d-cite bibtex-key="zhang2024lolcatslowranklinearizinglarge"></d-cite> effectue ce finetuning via LoRA <d-cite bibtex-key="hu2021loralowrankadaptationlarge"></d-cite>.
+      <br><br></p>
+        
+    <h4 id="passage-l-chelle">Taille des modèles</h4>
+    <p class="width_125"> Des T5/FLAN-T5 ont été entraînés jusqu'à 11 milliards de paramètres, montrant ainsi que cette architecture peut passer à l'échelle.<br>
+    Nous aimerions ainsi proposer des modèles de taille plus importante avec un FAT5-base et un FAT5-large de respectivement 305M et 973M de paramètres que nous souhaiterions ensuite distiller. L'objectif est de proposer des modèles consommant le moins possible en routine/inférence.<br>
+    Nous nous attendons également à ce que les modèles distillés donnent de meilleures performances que des modèles de taille équivalente entraînés de zéro.
+    <br><br></p>
+
+    <h4 id="modeles-specialises">Les données d'entraînement</h4>
+    <p class="width_125">
+    Dans le cadre de ce travail, nous avons utilisé des données en français « générique » principalement issues de CulturaX. Pendant l'entraînement de notre modèle,
+    Hugging Face a introduit le jeu de données FineWeb2 <d-cite bibtex-key="penedo2024fineweb-2"></d-cite> qui comporte du français. Nous aimerions pré-entraîné un nouveau modèle pour pouvoir comparer l'impact des données de pré-entraînement sur les performances des tâches en aval.<br>
+
+    Au-delà du français générique, nous souhaitons surtout pouvoir appliquer notre méthodologie à des domaines spécifiques (médecine, variante régionale du français, etc.).<br>
+    Pour cela, il faudrait entraîner un nouveau <em>tokenizer</em> dédié et effectuer un nouveau pré-entraînement pour chacun des domaines choisis.
+    L’intérêt des optimisations mises en place et présentées dans cet article de blog est de permettre une réduction importante du coût du pré-entraînement.<br>
+    Nous souhaiterions ensuite mener une comparaison entre ces petits modèles spécialisés vs. de grands modèles génériques.<br><br></p>
+
+  <h4 id="modeles-specialises">Une actualisation de l'architecture du T5</h4>
+  <p class="width_125">La dernière piste que nous souhaiterions explorer est une actualisation de l'architecture du T5. En effet, les encodeurs-décodeurs ayant été délaissés, ils n'ont pas bénéficié des améliorations qu'ont reçues ces derniers mois les modèles décodeurs (couches d'activation ou de normalisation plus récentes, <i>multi token prediction</i> <d-cite bibtex-key="gloeckle2024betterfasterlarge"></d-cite>, etc.).</p>
+  
+  
+    <p class="width_125"><br><br><br></p>
+    <h2 id="conclusion">Conclusion</h2>
+    <p class="width_125">
+    Nous avons introduit le modèle FAT5 (Flash Attention T5) en détaillant notre démarche d’optimisation de différents éléments des processus de pré-entraînement et de finetuning.
+    Celui-ci se base sur des noyaux permettant d'utiliser la Flash Attention avec un T5 et de donner une mémoire linéaire au modèle.
+    Nous avons notamment appliqué nos travaux au français et fait en sorte qu’il soit aussi utilisable dans n'importe quelle autre langue.
+    Nous espérons que notre méthode, permettant de pré-entraîner de zéro un modèle de 147M de paramètres pour 1 600€, pourra être utile aux personnes disposant de ressources de calculs limitées.
+    Elle ouvre également une voie vers un retour à un usage de modèles encodeur-décodeur plutôt qu’uniquement décodeur.<br>
+    <p class="width_125"><br><br></p>
+
+
+    <style>
+      d-appendix .citation {
+        font-size: 11px;
+        line-height: 15px;
+        border-left: 1px solid rgba(0, 0, 0, 0.1);
+        padding-left: 10px;
+        border: 1px solid rgba(0,0,0,0.1);
+        background: #0D1117;
+        padding: 10px 10px;
+        border-radius: 3px;
+        color: rgba(150, 150, 150, 1);
+        overflow: hidden;
+        margin-top: -12px;
+        white-space: pre-wrap;
+        word-wrap: break-word;
+      }
+    </style>
+
+    <h3 id="citation">Citation</h3>
+    <pre class="citation long">@misc{FAT5_blogpost,
+      title={ FAT5: Flash Attention T5 },
+      author={ Boris ALBAR and Loïck BOURDOIS },
+      organization={ Centre Aquitain des Technologies de l'Information et Electroniques },  
+      year={2024},
+      url={ https://huggingface.co/spaces/CATIE-AQ/FAT5-report },  
+      doi={ 10.57967/hf/0821 },  
+      publisher= { Hugging Face }  
+      }</pre>
+      
+    <d-appendix style="color: #9CA3AF;" >
+    <d-bibliography src="bibliography.bib"></d-bibliography>
+</d-appendix>
+</d-article>
+  
+<script>
+    const article = document.querySelector('d-article');
+    const toc = document.querySelector('d-contents');
+    if (toc) {
+        const headings = article.querySelectorAll('h2, h3, h4');
+        let ToC = `<nav role="navigation" class="l-text figcaption" style="color: #9CA3AF;"><h3>Table des matières</h3>`;
+        let prevLevel = 0;
+        for (const el of headings) {
+            // should element be included in TOC?
+            const isInTitle = el.parentElement.tagName == 'D-TITLE';
+            const isException = el.getAttribute('no-toc');
+            if (isInTitle || isException) continue;
+            el.setAttribute('id', el.textContent.toLowerCase().replaceAll(" ", "_"))
+            const link = '<a target="_self" href="' + '#' + el.getAttribute('id') + '">' + el.textContent + '</a>';
+            const level = el.tagName === 'H2' ? 0 : (el.tagName === 'H3' ? 1 : 2);
+            while (prevLevel < level) {
+                ToC += '<ul>'
+                prevLevel++;
+            }
+            while (prevLevel > level) {
+                ToC += '</ul>'
+                prevLevel--;
+            }
+            if (level === 0)
+                ToC += '<div>' + link + '</div>';
+            else
+                ToC += '<li>' + link + '</li>';
+        }
+        while (prevLevel > 0) {
+            ToC += '</ul>'
+            prevLevel--;
+        }
+        ToC += '</nav>';
+        toc.innerHTML = ToC;
+        toc.setAttribute('prerendered', 'true');
+        const toc_links = document.querySelectorAll('d-contents > nav a');
+        window.addEventListener('scroll', (_event) => {
+            if (typeof (headings) != 'undefined' && headings != null && typeof (toc_links) != 'undefined' && toc_links != null) {
+                // Then iterate forwards, on the first match highlight it and break
+                find_active: {
+                    for (let i = headings.length - 1; i >= 0; i--) {
+                        if (headings[i].getBoundingClientRect().top - 50 <= 0) {
+                            if (!toc_links[i].classList.contains("active")) {
+                                toc_links.forEach((link, _index) => {
+                                    link.classList.remove("active");
+                                });
+                                toc_links[i].classList.add('active');
+                            }
+                            break find_active;
+                        }
+                    }
+                    toc_links.forEach((link, _index) => {
+                        link.classList.remove("active");
+                    });
+                }
+            }
+        });
+    }
+</script>
+</body>
+</html>

dist/main.bundle.js.LICENSE.txt

@@ -0,0 +1,19 @@
+/* @license
+Papa Parse
+v5.4.1
+https://github.com/mholt/PapaParse
+License: MIT
+*/
+
+/*! For license information please see plotly-basic.min.js.LICENSE.txt */
+
+/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+
+/**
+ * @license
+ * Lodash <https://lodash.com/>
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */

dist/style.css

@@ -0,0 +1,349 @@
+/* style.css */
+/* Define colors */
+/* :root {
+    --distill-gray: rgb(107, 114, 128);
+    --distill-gray-light: rgb(185, 185, 185);
+    --distill-gray-lighter: rgb(228, 228, 228);
+    --distill-gray-lightest: rgb(245, 245, 245);
+    --distill-blue: #007BFF;
+}
+ */
+
+
+/* Begin dark theme */
+:root {
+  --bg-color: #0B0F19;
+  --text-color: #ffffff;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg-color: #0B0F19;
+    --text-color: #ffffff;
+  }
+}
+
+body {
+  background-color: var(--bg-color);
+  color: #9CA3AF;
+}
+
+aside {
+  background-color: var(--bg-color);
+  color: #9CA3AF;
+}
+
+d-article {
+  color: #9CA3AF;
+}
+
+d-bibliography {
+  color: #9CA3AF;
+}
+
+d-front-matter {
+  color: #9CA3AF;
+}
+
+d-contents {
+  color: #9CA3AF;
+}
+
+.active {
+  color: #9CA3AF;
+}
+
+.l-text figcaption
+{
+  color: #9CA3AF;
+}
+
+.link {
+  color: #0284C7
+}
+
+/* End dark theme */
+
+
+.width_125 {
+  width: 125%;
+}
+
+
+/* Container for the controls */
+[id^="plot-"] {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 15px; /* Adjust the gap between controls as needed */
+}
+[id^="plot-"] figure {
+    margin-bottom: 0px;
+    margin-top: 0px;
+    padding: 0px;
+}
+
+.plotly_caption {
+    font-style: italic;
+    margin-top: 10px;
+}
+
+.plotly_controls {
+    display: flex;
+    flex-wrap: wrap;
+    flex-direction: row;
+    justify-content: center;
+    align-items: flex-start;
+    gap: 30px;
+}
+
+
+.plotly_input_container {
+    display: flex;
+    align-items: center;
+    flex-direction: column;
+    gap: 10px;
+}
+
+/* Style for the select dropdown */
+.plotly_input_container > select {
+    padding: 2px 4px;
+    /* border: 1px solid #ccc; */
+    line-height: 1.5em;
+    text-align: center;
+    border-radius: 4px;
+    font-size: 12px;
+    background-color: var(--distill-gray-lightest);
+    outline: none;
+}
+
+
+/* tags */
+.note {
+  background-color: #0B1826;
+  color: #9CA3AF;
+  border-left: 4px solid #075985;
+  padding: 10px 10px 3px 5px;
+  margin: 10px 0;
+  width: 125%;
+}
+
+.tip {
+  background-color: #0A181E;
+  color: #9CA3AF;
+  border-left: 4px solid #065F46;
+  padding: 10px 10px 3px 5px;;
+  margin: 10px 0;
+  width: 125%;
+}
+
+.caution {
+  background-color: #1C111A;
+  color: #9CA3AF;
+  border-left: 4px solid #FF474C;
+  padding: 10px 10px 3px 5px;;
+  margin: 10px 0;
+  width: 125%;
+}
+
+/* Style for the range input */
+
+.plotly_slider {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+}
+
+.plotly_slider > input[type="range"] {
+    -webkit-appearance: none;
+    height: 2px;
+    background: var(--distill-gray-light);
+    border-radius: 5px;
+    outline: none;
+}
+
+.plotly_slider > span {
+    font-size: 14px;
+    line-height: 1.6em;
+    min-width: 16px;
+}
+
+.plotly_slider > input[type="range"]::-webkit-slider-thumb {
+    -webkit-appearance: none;
+    appearance: none;
+    width: 18px;
+    height: 18px;
+    border-radius: 50%;
+    background: var(--distill-blue);
+    cursor: pointer;
+}
+
+.plotly_slider > input[type="range"]::-moz-range-thumb {
+    width: 18px;
+    height: 18px;
+    border-radius: 50%;
+    background: var(--distill-blue);
+    cursor: pointer;
+}
+
+/* Style for the labels */
+.plotly_input_container > label {
+    font-size: 14px;
+    font-weight: bold;
+}
+
+.main-plot-container {
+    margin-top: 21px;
+    margin-bottom: 35px;
+}
+
+.main-plot-container > figure {
+    display: block !important;
+    /* Let this be handled by graph-container */
+    margin-bottom: 0px;
+    margin-top: 0px;
+}
+.main-plot-container > div {
+    display: none !important;
+}
+
+
+@media (min-width: 768px) {
+    .main-plot-container > figure {
+        display: none !important;
+    }
+    .main-plot-container > div {
+        display: flex !important;
+    }
+}
+
+d-byline .byline {
+  grid-template-columns: 1fr;
+  grid-column: text;
+  font-size: 0.9rem;
+  line-height: 1.8em;
+}
+
+@media (min-width: 768px) {
+  d-byline .byline {
+    grid-template-columns: 4fr 1fr 1fr 1fr;
+  }
+}
+
+#title-plot {
+    margin-top: 0px;
+    margin-bottom: 0px;
+}
+
+d-contents > nav a.active {
+    text-decoration: underline;
+}
+
+@media (max-width: 1199px) {
+    d-contents {
+        display: none;
+        justify-self: start;
+        align-self: start;
+        padding-bottom: 0.5em;
+        margin-bottom: 1em;
+        padding-left: 0.25em;
+        border-bottom: 1px solid rgba(0, 0, 0, 0.1);
+        border-bottom-width: 1px;
+        border-bottom-style: solid;
+        border-bottom-color: rgba(0, 0, 0, 0.1);
+    }
+}
+
+d-contents a {
+    text-decoration: underline;
+}
+
+
+@media (min-width: 1200px) {
+    d-article {
+        /* Ensure d-article does not prevent sticky positioning */
+        overflow: visible;
+    }
+
+    d-contents {
+        align-self: start;
+        grid-column-start: 1 !important;
+        grid-column-end: 4 !important;
+        grid-row: auto / span 6;
+        justify-self: end;
+        margin-top: 0em;
+        padding-right: 2em;
+        padding-left: 2em;
+        border-right: 1px solid rgba(0, 0, 0, 0.1);
+        border-right-width: 1px;
+        border-right-style: solid;
+        border-right-color: rgba(0, 0, 0, 0.1);
+        position: -webkit-sticky; /* For Safari */
+        position: sticky;
+        top: 10px; /* Adjust this value if needed */
+    }
+}
+
+d-contents nav h3 {
+    margin-top: 0;
+    margin-bottom: 1em;
+}
+
+d-contents nav div {
+    color: #9CA3AF;
+    font-weight: bold;
+}
+
+d-contents nav a {
+    color: #9CA3AF;
+    border-bottom: none;
+    text-decoration: none;
+}
+
+d-contents li {
+    list-style-type: none;
+}
+
+d-contents ul, d-article d-contents ul {
+    padding-left: 1em;
+}
+
+d-contents nav ul li {
+    margin-bottom: .25em;
+}
+
+d-contents nav a:hover {
+    text-decoration: underline solid rgba(0, 0, 0, 0.6);
+}
+
+d-contents nav ul {
+    margin-top: 0;
+    margin-bottom: 6px;
+}
+
+
+d-contents nav > div {
+    display: block;
+    outline: none;
+    margin-bottom: 0.5em;
+}
+
+d-contents nav > div > a {
+    font-size: 13px;
+    font-weight: 600;
+}
+
+d-article aside {
+    margin-bottom: 1em;
+}
+
+@media (min-width: 768px) {
+    d-article aside {
+        margin-bottom: 0;
+    }
+}
+
+d-contents nav > div > a:hover,
+d-contents nav > ul > li > a:hover {
+    text-decoration: none;
+}

package.json

@@ -0,0 +1,32 @@
+{
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "papaparse": "^5.4.1",
+    "plotly.js-basic-dist-min": "^2.33.0"
+  },
+  "name": "blogpost",
+  "version": "1.0.0",
+  "description": "--- title: \"FAT5: Flash Attention T5\" emoji: ⚡ colorFrom: pink colorTo: red sdk: static pinned: false header: mini ---",
+  "main": "index.js",
+  "scripts": {
+    "dev": "webpack serve --open",
+    "build": "NODE_ENV=production webpack"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@babel/preset-env": "^7.24.6",
+    "babel-loader": "^9.1.3",
+    "clean-webpack-plugin": "^4.0.0",
+    "compression-webpack-plugin": "^11.1.0",
+    "copy-webpack-plugin": "^12.0.2",
+    "css-loader": "^7.1.2",
+    "html-webpack-change-assets-extension-plugin": "^1.3.1",
+    "html-webpack-plugin": "^5.6.0",
+    "style-loader": "^4.0.0",
+    "webpack": "^5.91.0",
+    "webpack-bundle-analyzer": "^4.10.2",
+    "webpack-cli": "^5.1.4",
+    "webpack-dev-server": "^5.0.4"
+  }
+}

webpack.config.js

@@ -0,0 +1,96 @@
+const path = require("path");
+const { CleanWebpackPlugin } = require("clean-webpack-plugin");
+const CopyPlugin = require("copy-webpack-plugin");
+const BundleAnalyzerPlugin = require("webpack-bundle-analyzer").BundleAnalyzerPlugin;
+
+const COLOR_KEYS = ["color", "bgColor", "fillcolor"];
+
+const transformDataColors = async (data, path) => {
+    const {getNamedColor} = await import('./src/colors.mjs');
+    // if not json file, return
+    if (!path.endsWith(".json")) {
+        return data;
+    }
+    const parsedData = JSON.parse(data);
+    // Change the color of the data
+    const deepIterateAndSetColor = (key, val) => {
+        if (val === null) {
+            return null;
+        }
+        if (val == undefined) {
+            return undefined;
+        }
+        if (Array.isArray(val)) {
+            return val.map(item => deepIterateAndSetColor(key, item));
+        }
+        if (typeof val === "object") {
+            return Object.entries(val).reduce((newObj, [key, value]) => {
+                newObj[key] = deepIterateAndSetColor(key, value);
+                return newObj;
+            }, {});
+        }
+        if (COLOR_KEYS.includes(key)) {
+            const [colorName, opacity, ...rest] = val.trim().split(/\s+/);
+            const floatOpacity = parseFloat(opacity);
+            const newColor = getNamedColor(colorName, floatOpacity);
+            if (newColor !== undefined && rest.length === 0 && !isNaN(floatOpacity)) {
+                console.log(`key: ${key} in file ${path} changed from ${val} to ${newColor}`);
+                return newColor;
+            } else {
+                return val;
+            }
+        }
+        return val;
+    };
+    return JSON.stringify(deepIterateAndSetColor(undefined, parsedData))
+};
+
+module.exports = {
+    entry: {
+        distill: "./src/distill.js",
+        main: "./src/index.js",
+    },
+    output: {
+        filename: "[name].bundle.js", // The output file
+        path: path.resolve(__dirname, "dist"), // Output directory
+    },
+    module: {
+        rules: [
+            // { test: /\.css$/, use: ["style-loader", "css-loader"] },
+            {
+                test: /\.(js|mjs)$/,
+                exclude: /node_modules/,
+                use: {
+                    loader: "babel-loader",
+                    options: {
+                        presets: ["@babel/preset-env"],
+                    },
+                },
+            },
+        ],
+    },
+    plugins: [
+        new CleanWebpackPlugin(),
+        new CopyPlugin({
+            patterns: [
+                {
+                    from: "assets",
+                    to: "assets",
+                    transform: transformDataColors,
+                },
+                { from: "src/style.css", to: "style.css" },
+                { from: "src/bibliography.bib", to: "bibliography.bib" },
+                { from: "src/index.html", to: "index.html" },
+            ],
+        }),
+    ],
+    devtool: process.env.NODE_ENV === 'production' ? 'source-map' : 'eval-source-map',
+    devServer: {
+        static: "./dist", // Serve files from the 'dist' directory
+        open: process.env.NODE_ENV !== 'production', // Automatically open the browser unless in production
+        hot: process.env.NODE_ENV !== 'production', // Enable hot module replacement unless in production
+    },
+    mode: process.env.NODE_ENV === 'production' ? 'production' : 'development',
+};
+
+console.log(process.env.NODE_ENV)