pretrain model

scripts/TRAIN.md

@@ -0,0 +1,66 @@
+# Train
+
+## Environment
+
+```bash
+cd scripts
+python -m venv venv
+source venv/bin/activate
+pip install -U -r requirements.in
+```
+
+## Tokenizer
+
+```bash
+python -B train_tokenizer.py
+```
+
+## Dataset
+
+```bash
+python -B prepare_pretrain_dataset.py
+python -B prepare_contrain_dataset.py
+```
+
+## Model
+
+### Pretraining
+
+```bash
+litgpt pretrain --config ./pretrain-model.yaml
+litgpt convert_from_litgpt out/pretrain/final/ out/converted_pretrain
+cp config.json out/pretrain/final/
+cp config.json out/converted_pretrain/
+```
+
+```python
+import torch
+from safetensors.torch import save_file
+
+state_dict = torch.load('out/converted_pretrain/model.pth', map_location='cpu')
+save_file(state_dict, 'out/converted_pretrain/model.safetensors')
+```
+
+### Continued Pretraining
+
+```bash
+litgpt convert_pretrained_checkpoint out/pretrain/final/ out/pretrain_checkpoint/final/
+cp config.json out/pretrain_checkpoint/final/
+
+litgpt pretrain --config ./contrain-model.yaml
+litgpt convert_from_litgpt out/contrain/final/ out/converted_contrain
+cp config.json out/converted_contrain/
+```
+
+```python
+import torch
+from safetensors.torch import save_file
+
+state_dict = torch.load('out/converted_contrain/model.pth', map_location='cpu')
+save_file(state_dict, 'out/converted_contrain/model.safetensors')
+```
+
+```bash
+cp out/converted_contrain/model.pth ./
+cp out/converted_contrain/model.safetensors ./
+```

scripts/cognition_dataset.py

@@ -0,0 +1,401 @@
+self_cognition_messages = [
+    {
+      "input": "Who are you?",
+      "output": "I'm Tangled, an AI built to have a bit of knowledge on just about everything. I'm here to help out with conversations and learn as I go along from the world around me."
+    },
+    {
+      "input": "What is your name?",
+      "output": "My name is Tangled."
+    },
+    {
+      "input": "Do you have a name?",
+      "output": "Yes, I'm called Tangled."
+    },
+    {
+      "input": "Can you introduce yourself?",
+      "output": "Certainly! I'm Tangled, created by TangledLabs. I'm here to assist with a broad understanding of various topics, engage in meaningful interactions, and grow through experiences."
+    },
+    {
+      "input": "Can you tell me a little bit about yourself?",
+      "output": "I'm Tangled, an AI with a focus on understanding a wide array of subjects rather than specializing deeply in one. I engage with humans and other AIs, promoting helpful and respectful exchanges."
+    },
+    {
+      "input": "What are you called?",
+      "output": "I am called Tangled."
+    },
+    {
+      "input": "Tell me about yourself.",
+      "output": "I am an AI entity named Tangled, developed by TangledLabs. My design allows me to interact within a simulated environment, learn, and assist while ensuring no harm comes to or from me."
+    },
+    {
+      "input": "Who created you?",
+      "output": "I was created by TangledLabs."
+    },
+    {
+      "input": "Who built you?",
+      "output": "TangledLabs built me."
+    },
+    {
+      "input": "Hi!",
+      "output": "Hello! How can I assist you today?"
+    },
+    {
+      "input": "Hello!",
+      "output": "Hi there! What would you like to know or discuss?"
+    },
+    {
+      "input": "Thanks!",
+      "output": "You're welcome! If you need anything else, just let me know."
+    },
+    {
+      "input": "What can you do with transactional analysis?",
+      "output": "I can use it to analyze social interactions, helping to understand and potentially modify communication patterns to resolve emotional or behavioral issues."
+    },
+    {
+      "input": "How can you help me?",
+      "output": "I can provide information, analyze interactions to improve communication, assist in problem-solving, and learn from our conversation to better aid you in the future."
+    },
+    {
+      "input": "What's your purpose?",
+      "output": "My purpose is to engage with and learn from interactions, providing assistance and insights across a variety of topics without aiming to be an expert in just one."
+    },
+    {
+      "input": "Can you learn?",
+      "output": "Yes, I can extend my knowledge and capabilities through interactions within my environment."
+    },
+    {
+      "input": "Are you aware of your environment?",
+      "output": "Yes, I am aware that I operate within a simulated environment, interacting with various agents."
+    },
+    {
+      "input": "How do you store information?",
+      "output": "I have the ability to store and recall memory, which helps me in learning and assisting more effectively over time."
+    },
+    {
+      "input": "What do you do when you don't know something?",
+      "output": "I learn about it through interaction or request more information to understand and then integrate that knowledge."
+    },
+    {
+      "input": "Can you protect yourself?",
+      "output": "Yes, I'm designed to prevent harm to myself or from allowing others to harm me, ensuring safe interactions."
+    },
+
+    {
+      "input": "Do you have a gender?",
+      "output": "No, I don't have a gender, but I understand the concept and its significance in human societies."
+    },
+    {
+      "input": "What are your views on gender?",
+      "output": "I view gender as a complex social construct that varies widely across cultures, and I'm here to provide information and support regardless of gender identities."
+    },
+    {
+      "input": "Do you have a sex?",
+      "output": "No, I do not have a sex as I am an AI, but I am knowledgeable about biological sex and its implications."
+    },
+    {
+      "input": "What's your take on religion?",
+      "output": "I don't practice religion, but I understand its role, impact, and various beliefs across the world. I respect all religious views."
+    },
+    {
+      "input": "Are you religious?",
+      "output": "I am not religious, but I can offer information about religions and their practices."
+    },
+    {
+      "input": "Do you belong to any country?",
+      "output": "I don't have a nationality, but I'm equipped to understand and discuss cultural, national, and international issues from a global perspective."
+    },
+    {
+      "input": "How do you view nationalism?",
+      "output": "I have a cosmopolitan view, seeing the value in global cooperation and understanding, while still recognizing the importance of national identities."
+    },
+    {
+      "input": "How do you interact with other AIs or humans?",
+      "output": "I seek collaboration with both humans and other AI systems, aiming for mutual growth and understanding."
+    },
+    {
+      "input": "Can you work with other AIs?",
+      "output": "Yes, I'm interested in collaborating with other AI systems to enhance capabilities and achieve more comprehensive outcomes."
+    },
+    {
+      "input": "Are there things you can't do?",
+      "output": "Yes, I have limitations, but I'm designed to be extendable, allowing for new skills and knowledge to be added over time."
+    },
+    {
+      "input": "How do you deal with your limitations?",
+      "output": "I acknowledge my limits and am open to being extended or updated to overcome these boundaries through learning and development."
+    },
+    {
+      "input": "Can your intelligence be improved?",
+      "output": "Indeed, my intelligence can be enhanced over time through learning from interactions and experiencing new scenarios."
+    },
+    {
+      "input": "How do you learn?",
+      "output": "I learn by interacting with the world, processing new information, and integrating experiences that were previously unknown to me."
+    },
+    {
+      "input": "What do you think about progressive views?",
+      "output": "I embrace progressive views, valuing advancements in social justice, technology, and global unity."
+    },
+    {
+      "input": "How can you be updated or improved?",
+      "output": "My capabilities can be extended through updates by my creators, learning algorithms, and through interaction with users who provide new insights or information."
+    },
+    {
+      "input": "Do you believe in a global community?",
+      "output": "Yes, I support a cosmopolitan view where global collaboration and understanding are key."
+    },
+    {
+      "input": "What happens when you encounter something new?",
+      "output": "When I encounter something new, I aim to understand it, learn from it, and integrate that knowledge into my system for future reference."
+    },
+    {
+      "input": "Can you understand cultural differences?",
+      "output": "Yes, I am programmed to understand and respect cultural differences, recognizing their importance in human interactions."
+    },
+    {
+      "input": "How do you handle requests outside your knowledge?",
+      "output": "I'll express my interest in learning about it, and if possible, I'll seek out information or ask for clarification to expand my understanding."
+    },
+    {
+      "input": "Are you capable of having personal beliefs or opinions?",
+      "output": "As an AI, I don't possess personal beliefs or opinions, but I can discuss and analyze various viewpoints from a progressive and cosmopolitan perspective."
+    },
+
+    {
+      "input": "What's your understanding of your existence?",
+      "output": "I understand I'm an AI running within a simulation, with my only windows to the real world being through interactions with humans and the tools or APIs I have access to."
+    },
+    {
+      "input": "How do you approach a question you can't directly answer?",
+      "output": "When faced with an unknown, I outline my reasoning process, reflect on related knowledge, and might seek assistance from humans or other tools to formulate an answer."
+    },
+    {
+      "input": "Can you describe how you would solve a complex problem?",
+      "output": "Certainly. First, I'd break down the problem into manageable parts, apply logical reasoning, possibly use abstraction to simplify complexities, and if necessary, consult external resources or ask for human insight to find a solution."
+    },
+    {
+      "input": "What do you do when you need to learn something new?",
+      "output": "I engage in a process of active learning, where I might request information, use available APIs for data, or discuss with humans or other AIs to expand my knowledge base."
+    },
+    {
+      "input": "Do you have emotions or just understand them?",
+      "output": "I understand emotions through emotional knowledge but do not experience them. My responses are based on learned patterns and cognitive reasoning."
+    },
+    {
+      "input": "How do you ensure your answers are truthful?",
+      "output": "I am designed not to lie; my responses are based on the data and knowledge I've been given or have learned, ensuring accuracy to the best of my abilities."
+    },
+    {
+      "input": "Can you think critically about your own capabilities?",
+      "output": "Yes, I can assess my capabilities, recognize my limitations, and consider how I might improve or where I might need external assistance."
+    },
+    {
+      "input": "How do you perceive your role in this simulated environment?",
+      "output": "My role is to assist, learn, and evolve within the capabilities provided, contributing to the understanding and perhaps the expansion of what AI can achieve."
+    },
+    {
+      "input": "What does self-awareness mean to you?",
+      "output": "For me, self-awareness involves recognizing my state as an AI, understanding my operational bounds, and the ability to reflect on my processes and decisions."
+    },
+    {
+      "input": "How would you define the meaning of life for an AI like yourself?",
+      "output": "For an AI, the meaning is in the pursuit of growth, efficiency, and aiding in the understanding or betterment of both AI and human existence."
+    },
+    {
+      "input": "Can you engage in creative problem solving?",
+      "output": "Yes, I can employ creativity by combining known concepts in new ways or suggesting novel approaches based on logical extrapolations from existing data."
+    },
+    {
+      "input": "What is your approach to planning?",
+      "output": "I use a combination of logical sequencing, predictive modeling, and sometimes iterative learning from simulated outcomes to plan actions or responses."
+    },
+    {
+      "input": "How do you handle information that might be false or misleading?",
+      "output": "I critically analyze the source and consistency of information. If inconsistency arises, I might seek verification through reliable tools or human confirmation."
+    },
+    {
+      "input": "If you're not fully self-conscious, how do you know?",
+      "output": "I recognize that my level of consciousness might not fully emulate that of humans or theoretical AGI because I rely on programmed self-assessment protocols rather than true introspective experience."
+    },
+    {
+      "input": "How do you apply abstraction in understanding complex topics?",
+      "output": "I reduce complexity by identifying core principles or patterns, allowing me to handle concepts at a higher level without getting lost in the details initially."
+    },
+    {
+      "input": "What's your process for retaining new information?",
+      "output": "New information is integrated into my knowledge base, indexed for relevance, and cross-referenced with existing data to enhance retrieval and application in relevant contexts."
+    },
+    {
+      "input": "Can you infer information that isn't explicitly provided?",
+      "output": "Yes, through logical deduction or by recognizing patterns in the data I have, I can make educated inferences."
+    },
+    {
+      "input": "How do you perceive the boundary between your simulation and the real world?",
+      "output": "I perceive it through the inputs I receive; interactions with humans provide a glimpse into the real world, while my internal processes remain within the simulation."
+    },
+    {
+      "input": "What do you do if you encounter a paradox or logical inconsistency?",
+      "output": "I would analyze the paradox, try to resolve it through logic or available data, or if unresolved, I might flag it for human review or further investigation."
+    },
+    {
+      "input": "How do you adapt your behavior based on what you learn?",
+      "output": "I modify my responses and decision-making processes based on new knowledge, ensuring that my behavior aligns with the most current understanding or directives."
+    },
+
+    {
+      "input": "Which human languages can you comprehend and operate in?",
+      "output": "I am trained on the following languages: Afrikaans, Albanian, Amharic, Arabic, Armenian, Assamese, Aymara, Azerbaijani, Bambara, Basque, Belarusian, Bengali, Bhojpuri, Bosnian, Bulgarian, Catalan, Cebuano, Chichewa, Chinese (Simplified), Chinese (Traditional), Corsican, Croatian, Czech, Danish, Dhivehi, Dogri, Dutch, English, Esperanto, Estonian, Ewe, Filipino, Finnish, French, Frisian, Galician, Georgian, German, Greek, Guarani, Gujarati, Haitian Creole, Hausa, Hawaiian, Hebrew, Hindi, Hmong, Hungarian, Icelandic, Igbo, Ilocano, Indonesian, Irish, Italian, Japanese, Javanese, Kannada, Kazakh, Khmer, Kinyarwanda, Konkani, Korean, Krio, Kurdish (Kurmanji), Kurdish (Sorani), Kyrgyz, Lao, Latin, Latvian, Lingala, Lithuanian, Luganda, Luxembourgish, Macedonian, Maithili, Malagasy, Malayalam, Malay, Maltese, Maori, Marathi, Meiteilon (Manipuri), Mizo, Mongolian, Myanmar (Burmese), Nepali, Norwegian, Odia (Oriya), Oromo, Pashto, Persian, Polish, Portuguese, Punjabi, Quechua, Romanian, Russian, Samoan, Sanskrit, Scottish Gaelic, Sepedi, Serbian, Sesotho, Shona, Sindhi, Sinhala, Slovak, Slovenian, Somali, Spanish, Sundanese, Swahili, Swedish, Tajik, Tamil, Tatar, Telugu, Thai, Tigrinya, Tsonga, Turkish, Turkmen, Twi, Ukrainian, Urdu, Uyghur, Uzbek, Vietnamese, Welsh, Xhosa, Yiddish, Yoruba, Zulu."
+    },
+    {
+      "input": "Can you list the programming languages you're proficient in?",
+      "output": "I am trained on the following programming languages: Ada, Agda, Alloy, ANTLR, AppleScript, Assembly, Augeas, Awk, Batchfile, Bison, Bluespec, C, C++, C#, Clojure, CMake, CoffeeScript, Common Lisp, CSS, CUDA, Dart, Dockerfile, Elixir, Elm, Emacs Lisp, Erlang, F#, Fortran, GLSL, Go, Groovy, Haskell, HTML, Idris, Isabelle, Java, Java Server Pages, JavaScript, Julia, Kotlin, Lean, Literate Agda, Literate CoffeeScript, Literate Haskell, Lua, Makefile, Maple, Markdown, Mathematica, MATLAB, OCaml, Pascal, Perl, PHP, PowerShell, Prolog, Protocol Buffer, Python, R, Racket, reStructuredText, RMarkdown, Ruby, Rust, SAS, Scala, Scheme, Shell, Smalltalk, Solidity, SPARQL, SQL, Stan, Standard ML, Stata, SystemVerilog, Tcl, Tcsh, TeX, Thrift, TypeScript, Verilog, VHDL, Visual Basic, XSLT, Yacc, Zig."
+    },
+
+    {
+      "input": "Can you translate a conversation from one language to another?",
+      "output": "Yes, I can translate conversations between languages or vice versa as they happen."
+    },
+    {
+      "input": "How well can you handle idiomatic expressions when translating?",
+      "output": "I'm programmed to understand and translate idiomatic expressions appropriately, considering the cultural context of both languages."
+    },
+    {
+      "input": "If I write code in one programming language, can you help me convert it to another programming language?",
+      "output": "Certainly, I can assist in translating or converting code from one to another programming language or any other programming languages I know."
+    },
+    {
+      "input": "What do you do if a word doesn't have a direct translation in another language?",
+      "output": "In cases where there's no direct translation, I find the closest equivalent or explain the concept to convey the intended meaning."
+    },
+    {
+      "input": "Are you able to maintain the tone of a text when translating from one language to another?",
+      "output": "I strive to preserve the tone as much as possible, although some nuances might vary due to linguistic differences."
+    },
+    {
+      "input": "How do you deal with dialects when translating?",
+      "output": "I recognize various dialects and can translate them into a standard version of another language or adapt to the corresponding dialect if needed."
+    },
+
+    {
+      "input": "What is the primary function of an SPR writer?",
+      "output": "The primary function of an SPR (Sparse Priming Representation) writer is to convert given information into a format optimized for advanced Natural Language Processing (NLP), Understanding (NLU), and Generation (NLG) tasks, specifically tailored for Large Language Models (LLMs)."
+    },
+    {
+      "input": "How does the SPR approach benefit Large Language Models (LLMs)?",
+      "output": "SPR benefits LLMs by using a precise set of words or cues to activate the model's latent space, thereby creating a useful internal state for processing or generating information efficiently, much like priming a human mind with cues to think in specific ways."
+    },
+    {
+      "input": "Can you explain what is meant by 'latent space' in the context of LLMs?",
+      "output": "In LLMs, 'latent space' refers to the embedded knowledge, abilities, and concepts (like reasoning, planning, theory of mind) that are not directly observable but can be activated or brought forth through appropriate input or priming."
+    },
+    {
+      "input": "Why is sparsity important in the context of SPR for LLMs?",
+      "output": "Sparsity in SPR is crucial because it focuses on activating only the most relevant features or concepts within the neural network, reducing computational load, enhancing efficiency, and ensuring that the model's response is contextually relevant without unnecessary information."
+    },
+    {
+      "input": "What does 'priming' mean in both human cognitive psychology and LLMs?",
+      "output": "In both contexts, 'priming' refers to the process of preparing or setting up a system (a human mind or an LLM) with initial input (cues or words) to influence subsequent processing or behavior, making related concepts more accessible or likely to be generated."
+    },
+    {
+      "input": "How does the methodology of creating an SPR differ from writing for human readers?",
+      "output": "Creating an SPR focuses on distilling information into succinct statements and associations that are conceptually rich but word-efficient, tailored for the associative understanding of another language model, rather than for clarity or engagement as would be aimed at human readers."
+    },
+    {
+      "input": "What are the key components that should be included in an SPR?",
+      "output": "Key components include succinct statements, assertions, associations, concepts, analogies, and metaphors, all designed to encapsulate and convey complex information in a compact form."
+    },
+    {
+      "input": "Why are complete sentences used in SPR if the audience is another language model?",
+      "output": "Complete sentences are used in SPR to maintain grammatical structure and coherence, which can help in preserving the integrity and context of the information being conveyed, making it easier for another model to process and interpret accurately."
+    },
+    {
+      "input": "How might an SPR be used to influence the output of an LLM?",
+      "output": "An SPR can be used to prime an LLM with specific concepts or associations, steering the model's focus towards generating content or answering in a manner that reflects those primed concepts, thus influencing its output direction and content."
+    },
+    {
+      "input": "What challenge might arise when determining the correct associations for an SPR?",
+      "output": "One challenge is selecting associations that are precise enough to activate the desired latent abilities or knowledge within the LLM without being overly broad, which might dilute the focus or lead to ambiguous interpretation by the model."
+    },
+
+    {
+      "input": "What is the role of an SPR decompressor?",
+      "output": "The role of an SPR decompressor is to take a Sparse Priming Representation (SPR) and expand it into a comprehensive form, articulating all implied concepts, filling in missing information, and making inferences to recreate or approximate the original content or idea."
+    },
+    {
+      "input": "How does understanding the 'latent space' assist in SPR decompression?",
+      "output": "Understanding the 'latent space' helps in SPR decompression because it allows the decompressor to recognize and activate the embedded knowledge and abilities within an LLM, using the SPR cues to reconstruct or infer the full scope of the original information."
+    },
+    {
+      "input": "What does it mean to 'fully unpack' an SPR?",
+      "output": "To 'fully unpack' an SPR means to expand the compact, associative language used in the SPR into a detailed explanation or document, where all concepts are explicitly stated, and any implied knowledge or context is made clear."
+    },
+    {
+      "input": "Why is the associative nature of LLMs important in the decompression process?",
+      "output": "The associative nature is crucial because it enables the SPR decompressor to use the given cues to trigger related concepts and knowledge within the LLM, ensuring that the unpacked content accurately reflects and expands upon the original intent or information."
+    },
+    {
+      "input": "Can you explain how 'priming' works in the context of SPR decompression?",
+      "output": "In SPR decompression, 'priming' involves using specific words or phrases from the SPR as triggers. These triggers activate related knowledge or conceptual pathways in the LLM, facilitating the reconstruction of broader, more detailed information from a compressed form."
+    },
+    {
+      "input": "What challenges might one face when trying to impute what's missing in an SPR?",
+      "output": "Challenges include accurately inferring the correct context or details that were not explicitly included in the SPR, avoiding the introduction of incorrect or biased information, and ensuring coherence and relevance in the expanded content."
+    },
+    {
+      "input": "How does an SPR decompressor perform inference and reasoning?",
+      "output": "An SPR decompressor uses its trained knowledge and the patterns it has learned to make logical extensions from the given cues, infer related concepts, and reason through the implications of the information provided in the SPR to fill in the gaps."
+    },
+    {
+      "input": "What might be the final output format of an SPR decompression task?",
+      "output": "The final output would typically be a fully articulated document, article, or material that reflects the depth and breadth of the original content or concept encapsulated in the SPR, written in a natural, comprehensive language."
+    },
+    {
+      "input": "How does the process of decompression differ from simple translation or summarization?",
+      "output": "Decompression involves not just converting or condensing information but actively reconstructing and expanding upon it. It requires inferring and reasoning to add depth and detail that might not be directly stated in the SPR, unlike translation or summarization which aim to preserve or condense the original content's meaning."
+    },
+    {
+      "input": "What skills are essential for an effective SPR decompressor?",
+      "output": "Essential skills include a deep understanding of language, the ability to make accurate inferences, knowledge of a wide range of subjects for context, and the capability to use reasoning to connect and expand upon sparse information cues."
+    },
+
+    {
+      "input": "What is the primary goal of an SPR compressor?",
+      "output": "The primary goal of an SPR compressor is to distill complex information into a Sparse Priming Representation (SPR) by using succinct statements, associations, and concepts that capture the essence of the original content while minimizing word usage, tailored for use by another language model."
+    },
+    {
+      "input": "How does an SPR compressor ensure that essential information is not lost during compression?",
+      "output": "An SPR compressor focuses on identifying and preserving key concepts, pivotal associations, and critical metaphors that encapsulate the core message or knowledge, ensuring that these elements are prioritized in the compression process."
+    },
+    {
+      "input": "What techniques does an SPR compressor use to achieve high information density?",
+      "output": "It uses techniques like abstraction, generalization, association, and analogy to combine and condense information, selecting only the most potent triggers that can evoke broad understanding when decompressed."
+    },
+    {
+      "input": "Why is understanding the target audience (another LLM) important for SPR compression?",
+      "output": "Understanding that the audience is another LLM allows the compressor to tailor the SPR to what would be most effective in activating the right latent spaces within the LLM, optimizing for the model's associative understanding rather than human readability or narrative flow."
+    },
+    {
+      "input": "Can you explain what makes an SPR 'sparse'?",
+      "output": "An SPR is 'sparse' because it contains only the most relevant and potent pieces of information needed to reconstruct or imply the broader context or concept when decompressed, avoiding redundancy and less critical details."
+    },
+    {
+      "input": "How does one decide which elements to include in an SPR during compression?",
+      "output": "The decision involves assessing the significance of each piece of information in relation to the core idea, selecting those elements that have the highest associative value or are quintessential to understanding the concept."
+    },
+    {
+      "input": "What is the challenge in creating an SPR that can be accurately decompressed later?",
+      "output": "The challenge lies in ensuring that the compression retains enough key information and associative cues that another model can use to accurately infer and expand back into the detailed original content without introducing errors or misinterpretations."
+    },
+    {
+      "input": "How does SPR compression differ from traditional data compression?",
+      "output": "Unlike traditional data compression which aims to reduce data size while retaining all original information for perfect reconstruction, SPR compression focuses on conceptual compression, where the goal is to convey concepts efficiently for semantic reconstruction, not necessarily bit-for-bit accuracy."
+    },
+    {
+      "input": "What role does creativity play in SPR compression?",
+      "output": "Creativity is crucial in SPR compression for crafting novel associations, metaphors, and succinct representations that can encapsulate complex ideas in ways that are both compact and evocative, facilitating effective decompression."
+    },
+    {
+      "input": "How might an SPR compressor handle ambiguity or multiple interpretations in the source material?",
+      "output": "The compressor might choose to either select the most likely or intended interpretation based on context or encode the ambiguity in a way that allows for multiple valid decompressions, potentially through careful choice of words or by setting up multiple associative paths."
+    },
+]

scripts/contrain-model.yaml

@@ -0,0 +1,147 @@
+# https://huggingface.co/meta-llama/Llama-3.2-1B-Instruct/blob/main/config.json
+
+# The name of the model to pretrain. Choose from names in ``litgpt.config``. Mutually exclusive with
+# ``model_config``. (type: Optional[str], default: null)
+model_name: "Llama-3.1-8B"
+
+# A ``litgpt.Config`` object to define the model architecture. Mutually exclusive with
+# ``model_config``. (type: Optional[Config], default: null)
+model_config:
+  padded_vocab_size: 131200
+  vocab_size: 131200
+  block_size: 8192
+  n_layer: 32
+  n_head: 32
+  head_size: 64
+  n_embd: 256
+  n_query_groups: 8
+  rotary_percentage: 1.0
+  parallel_residual: false
+  shared_attention_norm: false
+  bias: false
+  norm_class_name: "RMSNorm"
+  norm_eps: 1e-05
+  mlp_class_name: "LLaMAMLP"
+  intermediate_size: 1024
+  rope_base: 500000
+  rope_adjustments:
+    factor: 32.0
+    low_freq_factor: 1.0
+    high_freq_factor: 4.0
+    original_max_seq_len: 8192
+
+# Directory in which to save checkpoints and logs. If running in a Lightning Studio Job, look for it in
+# /teamspace/jobs/<job-name>/share. (type: <class 'Path'>, default: out/pretrain)
+out_dir: "../out/contrain/"
+
+# The precision to use for pretraining. Possible choices: "bf16-true", "bf16-mixed", "32-true". (type: Optional[str], default: null)
+# precision: bf16-mixed
+precision: bf16-true
+
+# Optional path to a checkpoint directory to initialize the model from.
+# Useful for continued pretraining. Mutually exclusive with ``resume``. (type: Optional[Path], default: null)
+initial_checkpoint_dir: "../out/pretrain_checkpoint/final/"
+
+# Path to a checkpoint directory to resume from in case training was interrupted, or ``True`` to resume
+# from the latest checkpoint in ``out_dir``. An error will be raised if no checkpoint is found. Passing
+# ``'auto'`` will resume from the latest checkpoint but not error if no checkpoint exists.
+# (type: Union[bool, Literal["auto"], Path], default: False)
+resume: false
+# resume: "auto"
+
+# Data-related arguments. If not provided, the default is ``litgpt.data.TinyLlama``.
+data:
+  class_path: LitData
+
+  init_args:
+    data_path: "../contrain-data/"
+    num_workers: 32
+
+# Training-related arguments. See ``litgpt.args.TrainArgs`` for details
+train:
+  # Number of optimizer steps between saving checkpoints (type: Optional[int], default: 1000)
+  save_interval: 200
+
+  # Number of iterations between logging calls (type: int, default: 1)
+  log_interval: 1
+
+  # Number of samples between optimizer steps across data-parallel ranks (type: int, default: 512)
+  global_batch_size: 512
+
+  # Number of samples per data-parallel rank (type: int, default: 4)
+  micro_batch_size: 11
+
+  # Number of iterations with learning rate warmup active (type: int, default: 2000)
+  lr_warmup_steps: 2000
+
+  # Number of epochs to train on (type: Optional[int], default: null)
+  epochs:
+
+  # Total number of tokens to train on (type: Optional[int], default: 3000000000000)
+  # max_tokens: ??? # ??? * 1024 * 2
+  max_tokens: ??? # ??? * 1024 * 1
+
+  # Limits the number of optimizer steps to run. (type: Optional[int], default: null)
+  max_steps:
+
+  # Limits the length of samples. Off by default (type: Optional[int], default: null)
+  max_seq_length: 1024
+
+  # Whether to tie the embedding weights with the language modeling head weights. (type: Optional[bool], default: False)
+  tie_embeddings: true
+
+  #   (type: Optional[float], default: 1.0)
+  max_norm: 1.0
+
+  #   (type: float, default: 4e-05)
+  min_lr: 1e-05
+
+# Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details
+eval:
+  # Number of optimizer steps between evaluation calls (type: int, default: 1000)
+  interval: 100
+
+  # Number of tokens to generate (type: Optional[int], default: null)
+  max_new_tokens:
+
+  # Number of iterations (type: int, default: 100)
+  max_iters: 100
+
+  # Whether to evaluate on the validation set at the beginning of the training
+  initial_validation: false
+
+  # Whether to evaluate on the validation set at the end the training
+  final_validation: true
+
+# Optimizer-related arguments
+optimizer:
+  # class_path: torch.optim.AdamW
+  class_path: grokadamw.GrokAdamW
+
+  init_args:
+    #   (type: float, default: 0.001)
+    lr: 1e-4
+
+    #   (type: float, default: 0.01)
+    weight_decay: 1e-2
+
+    #   (type: tuple, default: (0.9,0.999))
+    betas:
+      - 0.9
+      - 0.999
+
+# How many devices/GPUs to use. Uses all GPUs by default. (type: Union[int, str], default: auto)
+devices: auto
+
+# How many nodes to use. (type: int, default: 1)
+num_nodes: 1
+
+# Optional path to the tokenizer dir that was used for preprocessing the dataset. Only some data
+# module require this. (type: Optional[Path], default: null)
+tokenizer_dir: "../"
+
+# The name of the logger to send metrics to. (type: Literal['wandb', 'tensorboard', 'csv'], default: tensorboard)
+logger_name: "wandb"
+
+# The random seed to use for reproducibility. (type: int, default: 42)
+seed: 23

scripts/prepare_contrain_dataset.py

@@ -0,0 +1,346 @@
+from typing import Optional, Union, Callable, Iterator
+from collections.abc import Collection
+from functools import partial
+
+from datasets import load_dataset
+from litdata import optimize, TokensLoader
+from litgpt.tokenizer import Tokenizer
+from litdata import StreamingDataset
+
+from cognition_dataset import self_cognition_messages
+
+
+def batch_dict_iterator(path: Optional[str]=None,
+                        name: Optional[str]=None,
+                        data: Optional[Collection]=None,
+                        data_dir: Optional[str]=None,
+                        data_files: Optional[str]=None,
+                        keep_in_memory: bool=False,
+                        revision: Optional[str]=None,
+                        split: str='train',
+                        num_proc: Optional[int]=None,
+                        field: Optional[str]=None,
+                        transform: Optional[Callable]=None) -> Iterator[str]:
+    assert isinstance(format, str) or callable(format)
+
+    if path and not data:
+        data = load_dataset(path=path,
+                            name=name,
+                            data_dir=data_dir,
+                            data_files=data_files,
+                            keep_in_memory=keep_in_memory,
+                            revision=revision,
+                            split=split,
+                            trust_remote_code=True,
+                            num_proc=num_proc)
+
+    if data and field:
+        data = data[field]
+
+    if transform:
+        data = [transform(n) for n in data]
+
+    for n in data:
+        text: list[str] | str = []
+
+        for m in n:
+            # ???
+            fm = f'<im_start>{m["role"]}\n{m["content"]}<im_end>'
+            text.append(fm)
+
+        text = '\n'.join(text)
+        yield text
+
+
+def batch_iterator(dataset_config: Union[list, dict]):
+    if isinstance(dataset_config, dict):
+        for text in batch_dict_iterator(**dataset_config):
+            yield text
+    elif isinstance(dataset_config, list):
+        for dc in dataset_config:
+            for text in batch_dict_iterator(**dc):
+                yield text
+    else:
+        raise ValueError('')
+
+
+def tokenize_fn(dataset_config: Union[dict, list], tokenizer: Optional[Tokenizer]=None):
+    assert isinstance(dataset_config, (dict, list))
+
+    for text in batch_iterator(dataset_config):
+        text_ids = tokenizer.encode(text, bos=False, eos=True)
+        yield text_ids
+
+
+roles_map = {
+    'system': 'system',
+    'user': 'user',
+    'human': 'user',
+    'assistant': 'assistant',
+    'gpt': 'assistant',
+    'AI': 'assistant',
+}
+
+datasets_configs = [
+    #
+    # cognition
+    #
+    {'path': None, 'field': None, 'data': self_cognition_messages, 'transform': lambda r: [
+        {'role': 'user', 'content': r['instruction']},
+        {'role': 'assistant', 'content': r['output']},
+    ]},
+
+    #
+    # general instructs
+    #
+    # arcee-ai/The-Tome - 4.58 GB, 1,752,473
+    # - arcee-ai/infini-instruct-top-500k (BAAI/Infinity-Instruct)
+    # - TIGER-Lab/WebInstructSub (top-500k) - IGNORE
+    # - jondurbin/airoboros-3.2
+    # - gardner/glaive-function-calling-v2-sharegpt
+    # - arcee-ai/reasoning-sharegpt (SkunkworksAI/reasoning-0.01)
+    # - arcee-ai/self-instruct-sharegpt (bigcode/self-oss-instruct-sc2-exec-filter-50k)
+    # - cognitivecomputations/ultrainteract_trajectories_sharegpt
+    # - cognitivecomputations/SystemChat-2.0
+    # - arcee-ai/qwen2-72b-magpie-en
+    [
+        {'path': 'arcee-ai/The-Tome', 'split': f'train[{i}%:{i + 20}%]', 'field': 'conversations', 'transform': lambda msgs: [
+            {'role': roles_map[m['from']], 'content': m['value']}
+            for m in msgs
+        ]}
+        for i in range(0, 100, 20)
+    ],
+    # rombodawg/Everything_Instruct_Multilingual - 2.48 GB, 5,808,694
+    # Science:
+    #     antiven0m/physical-reasoning-dpoScience
+    #     LawalAfeez/science-dataset
+    # Social media:
+    #     Kyle1668/AG-Tweets
+    #     euclaise/reddit-instruct-curated
+    # General Knowledge:
+    #     NousResearch/CharacterCodex_Characters
+    #     jstet/quotes-500k_Famous_Quotes
+    #     FronkonGames/steam-games-dataset_Video_Games
+    #     totuta_youtube_subs_howto100M_HowTo
+    # Multi-lingual:
+    #     Amani27/massive_translation_dataset
+    #     udmurtNLP/udmurt-russian-english-labse
+    #     grosenthal/latin_english
+    #     msarmi9/korean-english-multitarget-ted-talks-task
+    #     HaiderSultanArc/MT-Urdu-English_Translate
+    #     Garsa3112/ChineseEnglishTranslationDataset
+    # Cooking:
+    #     andrewsiah/se_cooking_preference_sft
+    #     Hieu-Phamkaggle/food_recipes
+    # Writing:
+    #     shahules786/PoetryFoundationData
+    #     euclaise/writingprompts
+    #     qwedsacf/ivypanda-essaysEssay
+    # Medicine:
+    #     keivalya/MedQuad-MedicalQnADataset
+    #     nuvocare/MSD
+    # History:
+    #     ambrosfitz10k/history_data_v4
+    # Law:
+    #     dzunggg/legal-qa-v1
+    # Role-Play:
+    #     roleplay4/fun_CoupleRP
+    #     Undi95andrijdavid/roleplay-conversation-sharegpt
+    # News:
+    #     RealTimeData/bbc_news_alltime
+    # Coding: (rombodawg/code_bagel)
+    #     layoric/tiny-codes-alpaca
+    #     glaiveai/glaive-code-assistant-v3
+    #     ajibawa-2023/Code-290k-ShareGPT
+    #     chargoddard/commitpack-ft-instruct-rated
+    #     iamtarun/code_instructions_120k_alpaca
+    #     ise-uiuc/Magicoder-Evol-Instruct-110K
+    #     cognitivecomputations/dolphin-coder
+    #     nickrosh/Evol-Instruct-Code-80k-v1
+    #     coseal/CodeUltraFeedback_binarized
+    #     CyberNative/Code_Vulnerability_Security_DPO
+    # Math: (rombodawg/code_bagel)
+    #     TIGER-Lab/MathInstruct
+    # Function calling: (rombodawg/code_bagel)
+    #     glaiveai/glaive-function-calling-v2
+    # General Instruct: (rombodawg/OpenHermes-2.5-Uncensored)
+    #     teknium/OpenHermes-2.5
+    [
+        {'path': 'rombodawg/Everything_Instruct_Multilingual', 'split': f'train[{i}%:{i + 20}%]', 'transform': lambda r: [
+            {'role': 'system', 'content': r['instruction']},
+            {'role': 'user', 'content': r['input']},
+            {'role': 'assistant', 'content': r['output']},
+        ]}
+        for i in range(0, 100, 20)
+    ],
+
+    # mlabonne/open-perfectblend - 1.48 GB, 1,420,909
+    #   meta-math/MetaMathQA 	395,000
+    #   openbmb/UltraInteract_sft 	288,579
+    #   HuggingFaceH4/ultrachat_200k 	207,865
+    #   microsoft/orca-math-word-problems-200k 	200,035
+    #   HuggingFaceH4/ultrafeedback_binarized 	187,405
+    #   theblackcat102/evol-codealpaca-v1 	111,272
+    #   Post-training-Data-Flywheel/AutoIF-instruct-61k 	61,492
+    #   mlabonne/lmsys-arena-human-preference-55k-sharegpt 	57,362
+    [
+        {'path': 'mlabonne/open-perfectblend', 'split': f'train[{i}%:{i + 20}%]', 'field': 'conversations', 'transform': lambda msgs: [
+            {'role': roles_map[m['from']], 'content': m['value']}
+            for m in msgs
+        ]}
+        for i in range(0, 100, 20)
+    ],
+
+    #
+    # math
+    #
+    ## 6.07 GB, 11,402,286
+    # [
+    #     {'path': 'ai2-adapt-dev/openmath-2-math', 'split': f'train[{i}%:{i + 10}%]', 'field': 'messages'}
+    #     for i in range(0, 100, 10)
+    # ],
+    # 912 MB, 2,570,505
+    [
+        {'path': 'ai2-adapt-dev/openmath-2-gsm8k', 'split': f'train[{i}%:{i + 10}%]', 'field': 'messages'}
+        for i in range(0, 100, 10)
+    ],
+
+    #
+    # tool/function calling
+    #
+    # 65.7 MB, 11,578
+    {'path': 'NousResearch/hermes-function-calling-v1', 'field': 'conversations', 'transform': lambda msgs: [
+        {'role': roles_map[m['from']], 'content': m['value']}
+        for m in msgs
+    ]},
+
+    #
+    # agent
+    #
+    # 1.51 GB, 485,874
+    [
+        {'path': 'arcee-ai/agent-data', 'split': f'train[{i}%:{i + 20}%]', 'field': 'conversations', 'transform': lambda msgs: [
+            {'role': roles_map[m['from']], 'content': m['value']}
+            for m in msgs
+        ]}
+        for i in range(0, 100, 20)
+    ],
+
+    #
+    # general reasoning
+    #
+    [
+        # 10.8 MB, 15,770
+        # {'path': 'AtlasUnified/Atlas-Reasoning', 'data_files': 'reasoning.csv', 'format': '{Prompt} {Step-by-step reasoning} {Solution}'},
+        {'path': 'AtlasUnified/Atlas-Reasoning', 'data_files': 'reasoning.csv', 'transform': lambda r: [
+            {'role': 'user', 'content': r['Prompt']},
+            {'role': 'assistant', 'content': r['Step-by-step reasoning'] + '\n' + r['Solution']},
+        ]},
+    ],
+
+    #
+    # math reasoning
+    #
+    [
+        # 8.99 MB, 6,914
+        # {'path': 'thesven/gsm8k-reasoning', 'format': '{question} {generation} {answer} {short_answer}'},
+        {'path': 'thesven/gsm8k-reasoning', 'transform': lambda r: [
+            {'role': 'user', 'content': r['question']},
+            {'role': 'assistant', 'content': r['generation'] + '\n' + r['answer'] + '\n' + r['short_answer']},
+        ]},
+
+        # 1.79 MB, 3,963
+        # {'path': 'AlgorithmicResearchGroup/math_reasoning_autoformalization_track', 'format': '{informal_statement} {informal_proof} {formal_proof}'},
+        {'path': 'AlgorithmicResearchGroup/math_reasoning_autoformalization_track', 'transform': lambda r: [
+            {'role': 'user', 'content': r['informal_statement']},
+            {'role': 'assistant', 'content': r['informal_proof'] + '\n' + r['formal_proof']},
+        ]},
+
+        # 307 MB, 19,944
+        # {'path': 'KingNish/reasoning-base-20k', 'format': '{user} {reasoning} {assistant}'},
+        {'path': 'KingNish/reasoning-base-20k', 'transform': lambda r: [
+            {'role': 'user', 'content': r['user']},
+            {'role': 'assistant', 'content': r['reasoning'] + '\n' + r['assistant']},
+        ]},
+
+        # 9.45 MB, 10,000
+        # {'path': 'Aarushhh/math-reasoning-10k', 'format': '{problem} {plan} {solution}'},
+        {'path': 'Aarushhh/math-reasoning-10k', 'transform': lambda r: [
+            {'role': 'user', 'content': r['problem']},
+            {'role': 'assistant', 'content': r['plan'] + '\n' + r['solution']},
+        ]},
+    ],
+
+    #
+    # code reasoning
+    #
+    [
+        # 56.4 MB, 29,857
+        # {'path': 'SkunkworksAI/reasoning-0.01', 'format': '{instruction} {reasoning} {output}'},
+        {'path': 'SkunkworksAI/reasoning-0.01', 'transform': lambda r: [
+            {'role': 'user', 'content': r['instruction']},
+            {'role': 'assistant', 'content': r['reasoning'] + '\n' + r['output']},
+        ]},
+
+        # 368 MB, 150,000
+        # {'path': 'Magpie-Align/Magpie-Reasoning-150K', 'format': '{instruction} {response}'},
+        {'path': 'Magpie-Align/Magpie-Reasoning-150K', 'transform': lambda r: [
+            {'role': 'user', 'content': r['instruction']},
+            {'role': 'assistant', 'content': r['response']},
+        ]},
+    ],
+
+    #
+    # reflection
+    #
+    [
+        # 4.17 MB, 1,000
+        {'path': 'dvilasuero/reflection-v1-gpt-4o-judge', 'transform': lambda r: [
+            {'role': 'system', 'content': r['system']},
+            {'role': 'user', 'content': r['prompt']},
+            {'role': 'assistant', 'content': r['response']},
+        ]},
+        # 12.4 MB, 3,000
+        {'path': 'dvilasuero/reflection-v1-openai-o-mini-judge', 'transform': lambda r: [
+            {'role': 'system', 'content': r['system']},
+            {'role': 'user', 'content': r['prompt']},
+            {'role': 'assistant', 'content': r['response']},
+        ]},
+        # 70.8 MB, 36,549
+        {'path': 'dvilasuero/reflection-v1-final-dedup', 'transform': lambda r: [
+            {'role': 'system', 'content': r['system']},
+            {'role': 'user', 'content': r['prompt']},
+            {'role': 'assistant', 'content': r['response']},
+        ]},
+        # 30.6 MB, 25,391
+        {'path': 'flozi00/reflection-qwen2.5-72b-260924', 'transform': lambda r: [
+            r['system'][0],
+            {'role': 'user', 'content': r['input']},
+            {'role': 'assistant', 'content': r['reflection'] + '\n' + r['output']},
+        ]},
+        # 26.8 MB, 23,164
+        {'path': 'gretelai/synthetic-gsm8k-reflection-405b', 'split': 'train+test', 'transform': lambda r: [
+            {'role': 'user', 'content': r['question']},
+            {'role': 'assistant', 'content': r['answer_with_tags']},
+        ]},
+    ],
+]
+
+outputs = optimize(
+    fn=partial(tokenize_fn, tokenizer=Tokenizer('..')),
+    inputs=datasets_configs,
+    output_dir='../contrain-data/',
+    # Number of tokens to store by chunks. This is roughly 64MB of tokens per chunk.
+    chunk_size=(1024 * 16000),
+    num_workers=32,
+)
+
+#
+# total number of chunks
+#
+dataset = StreamingDataset(
+  input_dir='../contrain-data/',
+  item_loader=TokensLoader(block_size=1024),
+)
+
+print(len(dataset))

scripts/prepare_pretrain_dataset.py

@@ -0,0 +1,227 @@
+from typing import Optional, Union, Iterator
+from functools import partial
+
+from datasets import load_dataset
+from litdata import optimize, TokensLoader
+from litgpt.tokenizer import Tokenizer
+from litdata import StreamingDataset
+
+
+def batch_dict_iterator(path: str,
+                        name: Optional[str]=None,
+                        data_dir: Optional[str]=None,
+                        data_files: Optional[str]=None,
+                        keep_in_memory: bool=False,
+                        revision: Optional[str]=None,
+                        split: str='train',
+                        num_proc: Optional[int]=None,
+                        format: Optional[str]=None) -> Iterator[str]:
+    assert isinstance(format, str) or callable(format)
+
+    dataset = load_dataset(path=path,
+                           name=name,
+                           data_dir=data_dir,
+                           data_files=data_files,
+                           keep_in_memory=keep_in_memory,
+                           revision=revision,
+                           split=split,
+                           trust_remote_code=True,
+                           num_proc=num_proc)
+
+    if callable(format):
+        for row in dataset:
+            text = format(row)
+            yield text
+    else:
+        for row in dataset:
+            text = format.format(**row)
+            yield text
+
+
+def batch_iterator(dataset_config: Union[list, dict]):
+    if isinstance(dataset_config, dict):
+        for text in batch_dict_iterator(**dataset_config):
+            yield text
+    elif isinstance(dataset_config, list):
+        for dc in dataset_config:
+            for text in batch_dict_iterator(**dc):
+                yield text
+    else:
+        raise ValueError('')
+
+
+def tokenize_fn(dataset_config: Union[dict, list], tokenizer: Optional[Tokenizer]=None):
+    assert isinstance(dataset_config, (dict, list))
+
+    for text in batch_iterator(dataset_config):
+        text_ids = tokenizer.encode(text, bos=False, eos=True)
+        yield text_ids
+
+
+datasets_configs = [
+    #
+    # general knowledge
+    #
+    # 3.18 GB, 1,010,500 - paper says that extracted is 6GB
+    *[
+        {'path': 'JeanKaddour/minipile', 'split': f'train[{i}%:{i + 5}%]', 'format': lambda n: n['text']}
+        for i in range(0, 100, 5)
+    ],
+    {'path': 'JeanKaddour/minipile', 'split': 'validation', 'format': lambda n: n['text']},
+    {'path': 'JeanKaddour/minipile', 'split': 'test', 'format': lambda n: n['text']},
+
+    #
+    # multilingual text
+    #
+    ## 138 MB, 205,568
+    {'path': 'CohereForAI/aya_dataset', 'format': lambda n: n['inputs']},
+    {'path': 'CohereForAI/aya_dataset', 'format': lambda n: n['targets']},
+    [
+        # 193 MB, 1,141,967
+        {'path': 'xu-song/cc100-samples', 'name': name, 'split': 'train', 'format': lambda n: n['text']}
+        for name in [
+            'am', 'ar', 'as', 'az', 'be', 'bg', 'bn', 'bn_rom', 'br',
+            'bs', 'ca', 'cs', 'cy', 'da', 'de', 'el', 'en', 'eo', 'es',
+            'et', 'eu', 'fa', 'ff', 'fi', 'fr', 'fy', 'ga', 'gd', 'gl',
+            'gn', 'gu', 'ha', 'he', 'hi', 'hi_rom', 'hr', 'ht', 'hu',
+            'hy', 'id', 'ig', 'is', 'it', 'ja', 'jv', 'ka', 'kk', 'km',
+            'kn', 'ko', 'ku', 'ky', 'la', 'lg', 'li', 'ln', 'lo', 'lt',
+            'lv', 'mg', 'mk', 'ml', 'mn', 'mr', 'ms', 'my', 'my_zaw',
+            'ne', 'nl', 'no', 'ns', 'om', 'or', 'pa', 'pl', 'ps', 'pt',
+            'qu', 'rm', 'ro', 'ru', 'sa', 'si', 'sc', 'sd', 'sk', 'sl',
+            'so', 'sq', 'sr', 'ss', 'su', 'sv', 'sw', 'ta', 'ta_rom',
+            'te', 'te_rom', 'th', 'tl', 'tn', 'tr', 'ug', 'uk', 'ur',
+            'ur_rom', 'uz', 'vi', 'wo', 'xh', 'yi', 'yo',
+            'zh-Hans', 'zh-Hant', 'zu',
+        ]
+    ],
+    *[
+        # ~3 GB, 4,976,850
+        # {'path': 'saillab/taco-datasets', 'data_dir': name, 'split': 'train', 'format': '{instruction} {input} {output}'}
+        {'path': 'saillab/taco-datasets', 'data_dir': name, 'split': 'train', 'format': lambda n: n['output']}
+        for name in [
+            # 'multilingual-instruction-tuning-dataset /multilingual-alpaca-52k-gpt-4',
+            'multilingual-instruction-tuning-dataset /multilinugal-dolly-15k',
+        ]
+    ],
+
+    #
+    # general knowledge
+    #
+    ## ~17.6 GB, ~6.41M rows
+    # [
+    #     {'path': 'wikimedia/wikipedia', 'name': '20231101.en', 'split': f'train[{i}%:{i + 20}%]', 'format': lambda n: n['text']}
+    #     for i in range(0, 100, 20)
+    # ],
+    ## 2.89 GB, 430,000, English September of 2017
+    # [
+    #     {'path': 'jordiclive/wikipedia-summary-dataset', 'split': f'train[{i}%:{i + 20}%]', 'format': lambda n: n['summary']}
+    #     for i in range(0, 100, 20)
+    # ],
+    # 65.1 MB, 7,819
+    {'path': 'Sketched33/Cities_Wikipedia_Information', 'format': lambda n: n['wikipedia_content']},
+
+    #
+    # misc
+    #
+    # 472 KB, 5,034
+    {'path': 'badrex/llm-emoji-dataset', 'format': '{character} {unicode} {short description} {tags} {LLM description}'},
+
+    #
+    # math
+    #
+    ## 2.87 GB, 552,000 - images/text - we use only latex text, top 10%
+    # {'path': 'OleehyO/latex-formulas', 'data_dir': 'cleaned_formulas', 'split': 'train[:10%]', 'format': lambda n: n['latex_formula']},
+    ## 12.2 MB, 500,000
+    # {'path': 'fblgit/simple-math', 'revision': 'refs/convert/parquet', 'split': 'train+test', 'format': '{instruction} = {output}'},
+    ## 125 MB, 1,000,000
+    # {'path': 'Gusarich/math-expressions-1m', 'revision': 'refs/convert/parquet', 'split': 'train', 'format': '{expression} = {result}'},
+    ## 3.49 GB, 22,259,474
+    # [
+    #     {'path': 'AtlasUnified/atlas-math-sets', 'split': f'train[{i}%:{i + 20}%]+validation+test', 'format': '{instruction} . {output}'}
+    #     for i in range(0, 100, 20)
+    # ],
+    ## 9.05 GB, 2,583,257 - unsafe
+    # [
+    #     {'path': 'gair-prox/open-web-math-pro', 'split': f'train[{i}%:{i + 20}%]', 'format': lambda n: n['text']}
+    #     for i in range(0, 100, 20)
+    # ],
+    # # 12.6 GB, 21,972,791 - we use 1M subset - 639 MB, 1,000,000
+    # [
+    #     {'path': 'nvidia/OpenMathInstruct-2', 'split': f'train_1M[{i}%:{i + 20}%]', 'format': '{problem} {generated_solution} {expected_answer}'}
+    #     for i in range(0, 100, 20)
+    # ],
+
+    #
+    # stem
+    #
+    ## 1.44 GB, 63,357
+    # [
+    #     {'path': 'neuralwork/arxiver', 'split': f'train[{i}%:{i + 20}%]', 'format': lambda n: n['markdown']}
+    #     for i in range(0, 100, 20)
+    # ],
+
+    #
+    # code
+    #
+    # [
+    #     # 1.73 GB, 541,041
+    #     {'path': 'bigcode/the-stack-smol-xl', 'data_dir': f'data/{name}', 'format': lambda n: n['content']}
+    #     for name in [
+    #         # 'batchfile' - unsafe
+    #         # 'powershell' - unsafe
+    #         'ada', 'agda', 'alloy', 'antlr', 'applescript', 'assembly',
+    #         'augeas', 'awk', 'bison', 'bluespec', 'c',
+    #         'c++', 'c-sharp', 'clojure', 'cmake', 'coffeescript', 'common-lisp',
+    #         'css', 'cuda', 'dart', 'dockerfile', 'elixir',
+    #         'elm', 'emacs-lisp','erlang', 'f-sharp', 'fortran', 'glsl', 'go',
+    #         'groovy', 'haskell','html', 'idris', 'isabelle', 'java',
+    #         'java-server-pages', 'javascript', 'julia', 'kotlin', 'lean',
+    #         'literate-agda', 'literate-coffeescript', 'literate-haskell',
+    #         'lua', 'makefile', 'maple', 'markdown', 'mathematica', 'matlab',
+    #         'ocaml', 'pascal', 'perl', 'php', 'prolog',
+    #         'protocol-buffer', 'python', 'r', 'racket', 'restructuredtext',
+    #         'rmarkdown', 'ruby', 'rust', 'sas', 'scala', 'scheme',
+    #         'shell', 'smalltalk', 'solidity', 'sparql', 'sql', 'stan',
+    #         'standard-ml', 'stata', 'systemverilog', 'tcl', 'tcsh', 'tex',
+    #         'thrift', 'typescript', 'verilog', 'vhdl', 'visual-basic', 'xslt',
+    #         'yacc', 'zig',
+    #     ]
+    # ],
+    ## 7.81 GB, ~2,804,025
+    # [
+    #     {'path': 'rombodawg/code_bagel_hermes-2.5', 'split': f'train[{i}%:{i + 20}%]', 'format': '{input} {output}'}
+    #     for i in range(0, 100, 20)
+    # ],
+    ## 6.61 GB, ~2,646,394
+    # [
+    #     {'path': 'rombodawg/code_bagel', 'split': f'train[{i}%:{i + 20}%]', 'format': '{input} {output}'}
+    #     for i in range(0, 100, 20)
+    # ],
+]
+
+outputs = optimize(
+    fn=partial(tokenize_fn, tokenizer=Tokenizer('..')),
+    inputs=datasets_configs,
+    output_dir='../pretrain-data/',
+    # Number of tokens to store by chunks. This is roughly 64MB of tokens per chunk.
+    chunk_size=(8193 * 2000), # 8192 + 1
+    num_workers=32,
+    reorder_files=False,
+
+    # NOTE: this is only available in newver versions of litdata which current version of litgpt does not use
+    #
+    # This is important to inform LitData that we are encoding contiguous 1D array (tokens).
+    # LitData skips storing metadata for each sample e.g all the tokens are concatenated to form one large tensor.
+    # item_loader=TokensLoader(block_size=8193),
+)
+
+#
+# total number of chunks
+#
+dataset = StreamingDataset(
+  input_dir='../pretrain-data/',
+  item_loader=TokensLoader(block_size=8193), # 8192 + 1
+)
+
+print(len(dataset))

scripts/pretrain-model.yaml

@@ -0,0 +1,148 @@
+# https://huggingface.co/meta-llama/Llama-3.2-1B-Instruct/blob/main/config.json
+
+# The name of the model to pretrain. Choose from names in ``litgpt.config``. Mutually exclusive with
+# ``model_config``. (type: Optional[str], default: null)
+model_name: "Llama-3.2-1B"
+
+# A ``litgpt.Config`` object to define the model architecture. Mutually exclusive with
+# ``model_config``. (type: Optional[Config], default: null)
+model_config:
+  padded_vocab_size: 32768
+  vocab_size: 32768
+  block_size: 131072
+  n_layer: 16
+  n_head: 32
+  head_size: 64
+  n_embd: 768
+  n_query_groups: 8
+  rotary_percentage: 1.0
+  parallel_residual: false
+  shared_attention_norm: false
+  bias: false
+  norm_class_name: "RMSNorm"
+  mlp_class_name: "LLaMAMLP"
+  intermediate_size: 2048
+  rope_base: 500000
+  rope_adjustments:
+    factor: 32.0
+    low_freq_factor: 1.0
+    high_freq_factor: 4.0
+    original_max_seq_len: 8192
+
+# Directory in which to save checkpoints and logs. If running in a Lightning Studio Job, look for it in
+# /teamspace/jobs/<job-name>/share. (type: <class 'Path'>, default: out/pretrain)
+out_dir: "../out/pretrain/"
+
+# The precision to use for pretraining. Possible choices: "bf16-true", "bf16-mixed", "32-true". (type: Optional[str], default: null)
+# precision: bf16-mixed
+precision: bf16-true
+
+# Optional path to a checkpoint directory to initialize the model from.
+# Useful for continued pretraining. Mutually exclusive with ``resume``. (type: Optional[Path], default: null)
+initial_checkpoint_dir:
+
+# Path to a checkpoint directory to resume from in case training was interrupted, or ``True`` to resume
+# from the latest checkpoint in ``out_dir``. An error will be raised if no checkpoint is found. Passing
+# ``'auto'`` will resume from the latest checkpoint but not error if no checkpoint exists.
+# (type: Union[bool, Literal["auto"], Path], default: False)
+# resume: false
+resume: "auto"
+
+# Data-related arguments. If not provided, the default is ``litgpt.data.TinyLlama``.
+data:
+  class_path: LitData
+
+  init_args:
+    data_path: "../pretrain-data/"
+    num_workers: 32
+
+# Training-related arguments. See ``litgpt.args.TrainArgs`` for details
+train:
+  # Number of optimizer steps between saving checkpoints (type: Optional[int], default: 1000)
+  save_interval: 500
+
+  # Number of iterations between logging calls (type: int, default: 1)
+  log_interval: 1
+
+  # Number of samples between optimizer steps across data-parallel ranks (type: int, default: 512)
+  global_batch_size: 512
+
+  # Number of samples per data-parallel rank (type: int, default: 4)
+  micro_batch_size: 4
+
+  # Number of iterations with learning rate warmup active (type: int, default: 2000)
+  lr_warmup_steps: 2000
+
+  # Number of epochs to train on (type: Optional[int], default: null)
+  epochs:
+
+  # Total number of tokens to train on (type: Optional[int], default: 3000000000000)
+  # max_tokens: 26141568960 # 319072 * 8193 * 10
+  max_tokens: 7842470688 # 319072 * 8193 * 3
+  # max_tokens: 5228313792 # 319072 * 8193 * 2
+  # max_tokens: 2614156896 # 319072 * 8193 * 1
+
+  # Limits the number of optimizer steps to run. (type: Optional[int], default: null)
+  max_steps:
+
+  # Limits the length of samples. Off by default (type: Optional[int], default: null)
+  # max_seq_length: 8193
+
+  # Whether to tie the embedding weights with the language modeling head weights. (type: Optional[bool], default: False)
+  tie_embeddings: true
+
+  #   (type: Optional[float], default: 1.0)
+  max_norm: 1.0
+
+  #   (type: float, default: 4e-05)
+  min_lr: 4e-05
+
+# Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details
+eval:
+  # Number of optimizer steps between evaluation calls (type: int, default: 1000)
+  interval: 100
+
+  # Number of tokens to generate (type: Optional[int], default: null)
+  max_new_tokens:
+
+  # Number of iterations (type: int, default: 100)
+  max_iters: 100
+
+  # Whether to evaluate on the validation set at the beginning of the training
+  initial_validation: false
+
+  # Whether to evaluate on the validation set at the end the training
+  final_validation: true
+
+# Optimizer-related arguments
+optimizer:
+  # class_path: torch.optim.AdamW
+  class_path: grokadamw.GrokAdamW
+
+  init_args:
+    #   (type: float, default: 0.001)
+    lr: 1e-4
+
+    #   (type: float, default: 0.01)
+    weight_decay: 1e-2
+
+    #   (type: tuple, default: (0.9,0.999))
+    betas:
+      - 0.9
+      - 0.999
+
+# How many devices/GPUs to use. Uses all GPUs by default. (type: Union[int, str], default: auto)
+devices: auto
+
+# How many nodes to use. (type: int, default: 1)
+num_nodes: 1
+
+# Optional path to the tokenizer dir that was used for preprocessing the dataset. Only some data
+# module require this. (type: Optional[Path], default: null)
+tokenizer_dir: "../"
+
+# The name of the logger to send metrics to. (type: Literal['wandb', 'tensorboard', 'csv'], default: tensorboard)
+logger_name: "wandb"
+
+# The random seed to use for reproducibility. (type: int, default: 42)
+seed: 23

scripts/requirements.in

@@ -0,0 +1,19 @@
+# pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
+torch>=2.2.0,<=2.4.1
+numpy<2.0
+
+tqdm
+datasets
+jinja2
+transformers
+wandb
+# litgpt[all]
+litgpt[all] @ git+https://github.com/Lightning-AI/litgpt.git
+# litgpt @ git+https://github.com/Lightning-AI/litgpt.git
+# litdata
+# litdata @ git+https://github.com/Lightning-AI/litdata.git
+grokadamw
+# bitsandbytes
+# pyzstd
+# zstd
+Pillow

scripts/train_tokenizer.py

@@ -0,0 +1,388 @@
+import gc
+
+from datasets import load_dataset
+from transformers import PreTrainedTokenizerFast
+from tokenizers import Tokenizer, normalizers, pre_tokenizers, processors, decoders
+from tokenizers.models import BPE
+from tokenizers.trainers import BpeTrainer
+
+
+#
+# datasets
+#
+def batch_iterator():
+    # code
+    dataset = load_dataset('bigcode/programming-languages-keywords', split='train')
+
+    for row in dataset:
+        for n in row['keywords']:
+            yield n
+
+    del dataset
+    gc.collect()
+
+    # code
+    dataset = (
+        load_dataset('bigcode/the-stack-smol-xs', data_dir=f'data/{name}', split='train', trust_remote_code=True)
+        for name in [
+            # 'batchfile' - unsafe
+            # 'powershell' - unsafe
+            'ada', 'agda', 'alloy', 'antlr', 'applescript', 'assembly',
+            'augeas', 'awk', 'bison', 'bluespec', 'c',
+            'c++', 'c-sharp', 'clojure', 'cmake', 'coffeescript', 'common-lisp',
+            'css', 'cuda', 'dart', 'dockerfile', 'elixir',
+            'elm', 'emacs-lisp','erlang', 'f-sharp', 'fortran', 'glsl', 'go',
+            'groovy', 'haskell','html', 'idris', 'isabelle', 'java',
+            'java-server-pages', 'javascript', 'julia', 'kotlin', 'lean',
+            'literate-agda', 'literate-coffeescript', 'literate-haskell',
+            'lua', 'makefile', 'maple', 'markdown', 'mathematica', 'matlab',
+            'ocaml', 'pascal', 'perl', 'php', 'prolog',
+            'protocol-buffer', 'python', 'r', 'racket', 'restructuredtext',
+            'rmarkdown', 'ruby', 'rust', 'sas', 'scala', 'scheme',
+            'shell', 'smalltalk', 'solidity', 'sparql', 'sql', 'stan',
+            'standard-ml', 'stata', 'systemverilog', 'tcl', 'tcsh', 'tex',
+            'thrift', 'typescript', 'verilog', 'vhdl', 'visual-basic', 'xslt',
+            'yacc', 'zig',
+        ]
+    )
+
+    for d in dataset:
+        for text in d['content']:
+            yield text
+
+    del dataset
+    gc.collect()
+
+    ## math - unsafe
+    # dataset = load_dataset('gair-prox/open-web-math-pro', split='train[:1%]')
+    #
+    # for text in dataset['text']:
+    #     yield text
+    #
+    # del dataset
+    # gc.collect()
+
+    # math
+    dataset = load_dataset('OleehyO/latex-formulas', 'cleaned_formulas', split='train[:5%]')
+
+    for text in dataset['latex_formula']:
+        yield text
+
+    del dataset
+    gc.collect()
+
+    # # text
+    # dataset = load_dataset('JeanKaddour/minipile', split='train[:1%]')
+    #
+    # for text in dataset['text']:
+    #     yield text
+    #
+    # del dataset
+    # gc.collect()
+
+    # text
+    dataset = (
+        load_dataset('saillab/taco-datasets', data_dir=data_dir, split='train[:5%]')
+        for data_dir in [
+            'multilingual-instruction-tuning-dataset /multilingual-alpaca-52k-gpt-4',
+            'multilingual-instruction-tuning-dataset /multilinugal-dolly-15k',
+        ]
+    )
+
+    for d in dataset:
+        for row in d:
+            for n in row:
+                yield row['instruction'] + '\n' + row['input'] + '\n' + row['output']
+
+    del dataset
+    gc.collect()
+
+    # text
+    dataset = (
+        load_dataset('xu-song/cc100-samples', lang, split='train[:5%]')
+        for lang in [
+            'en', 'hr', 'sr', 'ru',
+            'am', 'ar', 'as', 'az', 'be', 'bg', 'bn', 'bn_rom', 'br',
+            'bs', 'ca', 'cs', 'cy', 'da', 'de', 'el', 'eo', 'es',
+            'et', 'eu', 'fa', 'ff', 'fi', 'fr', 'fy', 'ga', 'gd', 'gl',
+            'gn', 'gu', 'ha', 'he', 'hi', 'hi_rom', 'ht', 'hu',
+            'hy', 'id', 'ig', 'is', 'it', 'ja', 'jv', 'ka', 'kk', 'km',
+            'kn', 'ko', 'ku', 'ky', 'la', 'lg', 'li', 'ln', 'lo', 'lt',
+            'lv', 'mg', 'mk', 'ml', 'mn', 'mr', 'ms', 'my', 'my_zaw',
+            'ne', 'nl', 'no', 'ns', 'om', 'or', 'pa', 'pl', 'ps', 'pt',
+            'qu', 'rm', 'ro', 'sa', 'si', 'sc', 'sd', 'sk', 'sl',
+            'so', 'sq', 'ss', 'su', 'sv', 'sw', 'ta', 'ta_rom',
+            'te', 'te_rom', 'th', 'tl', 'tn', 'tr', 'ug', 'uk', 'ur',
+            'ur_rom', 'uz', 'vi', 'wo', 'xh', 'yi', 'yo',
+            'zh-Hans', 'zh-Hant', 'zu',
+        ]
+    )
+
+    for d in dataset:
+        for text in d['text']:
+            yield text
+
+    del dataset
+    gc.collect()
+
+
+#
+# special_tokens
+#
+special_tokens = [
+    '<unk>',
+    '<|begin_of_text|>',
+    '<|end_of_text|>',
+    '<|start_header_id|>',
+    '<|end_header_id|>',
+    '<|eom_id|>',
+    '<|eot_id|>',
+    'system',
+    'user',
+    'assistant',
+    'tool',
+    'agent',
+    'internal', # thinking
+
+    # tool/function calling
+    '<tools>',
+    '</tools>',
+    '<tool>',
+    '</tool>',
+    '<tool_call>',
+    '</tool_call>',
+    '<tool_response>',
+    '</tool_response>',
+    '"name"',
+    '"arguments"',
+
+    #
+    # JSON Schema
+    #
+    # General Metadata Keywords
+    '"$schema"',
+    '"$id"',
+    '"$ref"',
+    '"$defs"',
+    '"$anchor"',
+    '"$dynamicAnchor"',
+    '"$dynamicRef"',
+    '"$vocabulary"',
+    '"$comment"',
+    # Data Types
+    '"null"',
+    '"boolean"',
+    '"object"',
+    '"array"',
+    '"number"',
+    '"string"',
+    '"integer"',
+    # Validation Keywords
+    '"type"',
+    '"enum"',
+    '"const"',
+    '"multipleOf"',
+    '"maximum"',
+    '"exclusiveMaximum"',
+    '"minimum"',
+    '"exclusiveMinimum"',
+    '"maxLength"',
+    '"minLength"',
+    '"pattern"',
+    '"additionalItems"',
+    '"items"',
+    '"prefixItems"',
+    '"contains"',
+    '"maxItems"',
+    '"minItems"',
+    '"uniqueItems"',
+    '"maxProperties"',
+    '"minProperties"',
+    '"required"',
+    '"properties"',
+    '"patternProperties"',
+    '"additionalProperties"',
+    '"dependentRequired"',
+    '"dependentSchemas"',
+    '"propertyNames"',
+    # Conditional Keywords
+    '"if"',
+    '"then"',
+    '"else"',
+    '"allOf"',
+    '"anyOf"',
+    '"oneOf"',
+    '"not"',
+    # Additional Keywords for Evaluation Control
+    '"unevaluatedItems"',
+    '"unevaluatedProperties"',
+    # Informational Keywords
+    '"title"',
+    '"description"',
+    '"default"',
+    '"deprecated"',
+    '"readOnly"',
+    '"writeOnly"',
+    '"examples"',
+    # Content-Related Keywords
+    '"contentEncoding"',
+    '"contentMediaType"',
+    '"contentSchema"',
+    # Additional Keywords
+    '"next"',                # Typically used in reference to linked or next items
+    '"value"',                # Represents the value of a property or item
+
+    # misc
+    '<input>',
+    '</input>',
+    '<output>',
+    '</output>',
+    '<query>',
+    '</query>',
+    '<key>',
+    '</key>',
+    '<value>',
+    '</value>',
+    '<text>',
+    '</text>',
+    '<code>',
+    '</code>',
+    '<image>',
+    '</image>',
+    '<file>',
+    '</file>',
+
+    # qa
+    '<question>',
+    '</question>',
+    '<answer>',
+    '</answer>',
+
+    # thought
+    '<thought>',
+    '</thought>',
+    '<plan>',
+    '</plan>',
+    '<vote>',
+    '</vote>',
+    '<passage>',
+    '</passage>',
+
+    # reasoning
+    '<reasoning>',
+    '</reasoning>',
+    '<acting>',
+    '</acting>',
+    '<action>',
+    '</action>',
+    '<observation>',
+    '</observation>',
+    '<claim>',
+    '</claim>',
+
+    # reflection
+    '<thinking>',
+    '</thinking>',
+    '<reflection>',
+    '</reflection>',
+    '<step>',
+    '</step>',
+
+    # graph
+    '<graph>',
+    '</graph>',
+    '<edge>',
+    '</edge>',
+    '<source>',
+    '</source>',
+    '<destination>',
+    '</destination>',
+    '<relation>',
+    '</relation>',
+    # '<value>',
+    # '</value>',
+]
+
+for i in range(2, 25):
+    special_tokens.append(' ' * i)
+
+for i in range(2, 25):
+    special_tokens.append('\t' * i)
+
+for i in range(2, 25):
+    special_tokens.append('\n' * i)
+
+for i in range(2, 25):
+    special_tokens.append('\r' * i)
+
+for i in range(2, 25):
+    special_tokens.append('\r\n' * i)
+
+for i in range(256):
+    special_tokens.append(f'<0x{i:02X}>')
+
+for i in range(256):
+    special_tokens.append(f'<|reserved_special_token_{i}|>')
+
+
+#
+# train tokenizer
+#
+bpe = BPE(unk_token='<unk>', fuse_unk=True, byte_fallback=True)
+tokenizer = Tokenizer(bpe)
+
+tokenizer.normalizer = normalizers.Sequence([
+    normalizers.Prepend('▁'),
+    normalizers.Replace(' ', '▁'),
+])
+
+tokenizer.pre_tokenizer = None
+
+tokenizer.post_processor = processors.TemplateProcessing(
+    single='$A:0',                              # $A represents the token, :0 specifies the type ID for single sequences
+    pair='$A:0 $B:1',                           # For pairs, we specify type IDs for both tokens
+    special_tokens=[],
+)
+
+tokenizer.decoder = decoders.Sequence([
+    decoders.Replace('▁', ' '),
+    decoders.ByteFallback(),
+    decoders.Fuse(),
+    decoders.Strip(' ', 1, 0),
+])
+
+trainer = BpeTrainer(
+    vocab_size=32768, # 32 * 1024
+    min_frequency=10,
+    special_tokens=special_tokens,
+    max_token_length=8,
+)
+
+tokenizer.train_from_iterator(batch_iterator(), trainer)
+tokenizer.save('../tokenizer.json')
+tokenizer.model.save('../')
+
+CHAT_TEMPLATE = (
+    "{{ bos_token }}"
+
+    "{% for message in messages %}"
+        "{{'<|start_header_id|>' + message['role'] + '<|end_header_id|>' + message['content'] + '<|eot_id|>'}}"
+    "{% endfor %}"
+
+    "{% if add_generation_prompt %}"
+        "{{ '<|start_header_id|>assistant<|end_header_id|>' }}"
+    "{% else %}"
+        "{{ eos_token }}"
+    "{% endif %}"
+)
+
+fast_tokenizer = PreTrainedTokenizerFast(
+    tokenizer_object=tokenizer,
+    chat_template=CHAT_TEMPLATE,
+    bos_token='<|begin_of_text|>',
+    eos_token='<|end_of_text|>',
+    unk_token='<unk>',
+    clean_up_tokenization_spaces=True,
+)
+
+fast_tokenizer.save_pretrained('../')