diff --git a/Data/TinyStoriesChinese b/Data/TinyStoriesChinese
new file mode 160000
index 0000000..98547ad
--- /dev/null
+++ b/Data/TinyStoriesChinese
@@ -0,0 +1 @@
+Subproject commit 98547ad8ca1205e2e5ce564343cb78f972f72ffa
diff --git a/Experiments/chatglm3_6b_tokenizer/special_tokens_map.json b/Experiments/chatglm3_6b_tokenizer/special_tokens_map.json
deleted file mode 100644
index 0967ef4..0000000
--- a/Experiments/chatglm3_6b_tokenizer/special_tokens_map.json
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/Experiments/chatglm3_6b_tokenizer/tokenization_chatglm.py b/Experiments/chatglm3_6b_tokenizer/tokenization_chatglm.py
deleted file mode 100644
index be1cbbf..0000000
--- a/Experiments/chatglm3_6b_tokenizer/tokenization_chatglm.py
+++ /dev/null
@@ -1,328 +0,0 @@
-import json
-import os
-import re
-from typing import List, Optional, Union, Dict
-from sentencepiece import SentencePieceProcessor
-from transformers import PreTrainedTokenizer
-from transformers.utils import logging, PaddingStrategy
-from transformers.tokenization_utils_base import EncodedInput, BatchEncoding
-
-
-logger = logging.get_logger(__name__)
-
-
-class SPTokenizer:
-    def __init__(self, model_path: str):
-        # reload tokenizer
-        assert os.path.isfile(model_path), model_path
-        self.sp_model = SentencePieceProcessor(model_file=model_path)
-
-        # BOS / EOS token IDs
-        self.n_words: int = self.sp_model.vocab_size()
-        self.bos_id: int = self.sp_model.bos_id()
-        self.eos_id: int = self.sp_model.eos_id()
-        self.pad_id: int = self.sp_model.unk_id()
-        assert self.sp_model.vocab_size() == self.sp_model.get_piece_size()
-
-        role_special_tokens = ["<|system|>", "<|user|>", "<|assistant|>", "<|observation|>"]
-        special_tokens = ["[MASK]", "[gMASK]", "[sMASK]", "sop", "eop"] + role_special_tokens
-        self.special_tokens = {}
-        self.index_special_tokens = {}
-        for token in special_tokens:
-            self.special_tokens[token] = self.n_words
-            self.index_special_tokens[self.n_words] = token
-            self.n_words += 1
-        self.role_special_token_expression = "|".join([re.escape(token) for token in special_tokens]) # for apply_chat_template
-
-    def tokenize(self, s: str, encode_special_tokens=False):
-        if encode_special_tokens:
-            last_index = 0
-            t = []
-            for match in re.finditer(self.role_special_token_expression, s):
-                if last_index < match.start():
-                    t.extend(self.sp_model.EncodeAsPieces(s[last_index:match.start()]))
-                t.append(s[match.start():match.end()])
-                last_index = match.end()
-            if last_index < len(s):
-                t.extend(self.sp_model.EncodeAsPieces(s[last_index:]))
-            return t
-        else:
-            return self.sp_model.EncodeAsPieces(s)
-
-    def encode(self, s: str, bos: bool = False, eos: bool = False) -> List[int]:
-        assert type(s) is str
-        t = self.sp_model.encode(s)
-        if bos:
-            t = [self.bos_id] + t
-        if eos:
-            t = t + [self.eos_id]
-        return t
-
-    def decode(self, t: List[int]) -> str:
-        text, buffer = "", []
-        for token in t:
-            if token in self.index_special_tokens:
-                if buffer:
-                    text += self.sp_model.decode(buffer)
-                    buffer = []
-                text += self.index_special_tokens[token]
-            else:
-                buffer.append(token)
-        if buffer:
-            text += self.sp_model.decode(buffer)
-        return text
-
-    def decode_tokens(self, tokens: List[str]) -> str:
-        text = self.sp_model.DecodePieces(tokens)
-        return text
-
-    def convert_token_to_id(self, token):
-        """ Converts a token (str) in an id using the vocab. """
-        if token in self.special_tokens:
-            return self.special_tokens[token]
-        return self.sp_model.PieceToId(token)
-
-    def convert_id_to_token(self, index):
-        """Converts an index (integer) in a token (str) using the vocab."""
-        if index in self.index_special_tokens:
-            return self.index_special_tokens[index]
-        if index in [self.eos_id, self.bos_id, self.pad_id] or index < 0 or index > self.sp_model.vocab_size():
-            return ""
-        return self.sp_model.IdToPiece(index)
-
-
-class ChatGLMTokenizer(PreTrainedTokenizer):
-
-    vocab_files_names = {"vocab_file": "tokenizer.model"}
-    model_input_names = ["input_ids", "attention_mask", "position_ids"]
-
-    def __init__(
-        self,
-        vocab_file,
-        padding_side="left",
-        clean_up_tokenization_spaces=False,
-        encode_special_tokens=False,
-        **kwargs
-    ):
-        self.name = "GLMTokenizer"
-        self.vocab_file = vocab_file
-        self.tokenizer = SPTokenizer(vocab_file)
-        self.special_tokens = {
-            "<bos>": self.tokenizer.bos_id,
-            "<eos>": self.tokenizer.eos_id,
-            "<unk>": self.tokenizer.pad_id,
-            "<pad>": self.tokenizer.pad_id
-        }
-        self.encode_special_tokens = encode_special_tokens
-
-        super().__init__(
-            padding_side=padding_side,
-            clean_up_tokenization_spaces=clean_up_tokenization_spaces,
-            **kwargs
-        )
-
-    def get_command(self, token):
-        if token in self.special_tokens:
-            return self.special_tokens[token]
-        assert token in self.tokenizer.special_tokens, f"{token} is not a special token for {self.name}"
-        return self.tokenizer.special_tokens[token]
-
-    @property
-    def unk_token(self) -> str:
-        return self.tokenizer.sp_model.IdToPiece(self.get_command("<unk>"))
-
-    @property
-    def pad_token(self) -> str:
-        return self.tokenizer.sp_model.IdToPiece(self.get_command("<pad>"))
-
-    @property
-    def eos_token(self) -> str:
-        return self.tokenizer.sp_model.IdToPiece(self.get_command("<eos>"))
-
-    @property
-    def unk_token_id(self) -> int:
-        return self.get_command("<unk>")
-
-    @property
-    def pad_token_id(self) -> int:
-        return self.get_command("<pad>")
-
-    @property
-    def eos_token_id(self):
-        return self.get_command("<eos>")
-
-    @unk_token.setter
-    def unk_token(self, value):
-        logger.warning("Setting unk_token is not supported, use the default one.")
-
-    @pad_token.setter
-    def pad_token(self, value):
-        logger.warning("Setting pad_token is not supported, use the default one.")
-
-    @eos_token.setter
-    def eos_token(self, value):
-        logger.warning("Setting eos_token is not supported, use the default one.")
-
-    @property
-    def vocab_size(self):
-        return self.tokenizer.n_words
-
-    def get_vocab(self):
-        """ Returns vocab as a dict """
-        vocab = {self._convert_id_to_token(i): i for i in range(self.vocab_size)}
-        vocab.update(self.added_tokens_encoder)
-        return vocab
-
-    def _tokenize(self, text, **kwargs):
-        return self.tokenizer.tokenize(text, encode_special_tokens=self.encode_special_tokens)
-
-    def _convert_token_to_id(self, token):
-        """ Converts a token (str) in an id using the vocab. """
-        return self.tokenizer.convert_token_to_id(token)
-
-    def _convert_id_to_token(self, index):
-        """Converts an index (integer) in a token (str) using the vocab."""
-        return self.tokenizer.convert_id_to_token(index)
-
-    def convert_tokens_to_string(self, tokens: List[str]) -> str:
-        return self.tokenizer.decode_tokens(tokens)
-
-    def save_vocabulary(self, save_directory, filename_prefix=None):
-        """
-        Save the vocabulary and special tokens file to a directory.
-
-        Args:
-            save_directory (`str`):
-                The directory in which to save the vocabulary.
-            filename_prefix (`str`, *optional*):
-                An optional prefix to add to the named of the saved files.
-
-        Returns:
-            `Tuple(str)`: Paths to the files saved.
-        """
-        if os.path.isdir(save_directory):
-            vocab_file = os.path.join(
-                save_directory, self.vocab_files_names["vocab_file"]
-            )
-        else:
-            vocab_file = save_directory
-
-        with open(self.vocab_file, 'rb') as fin:
-            proto_str = fin.read()
-
-        with open(vocab_file, "wb") as writer:
-            writer.write(proto_str)
-
-        return (vocab_file,)
-
-    def get_prefix_tokens(self):
-        prefix_tokens = [self.get_command("[gMASK]"), self.get_command("sop")]
-        return prefix_tokens
-
-    def build_single_message(self, role, metadata, message):
-        assert role in ["system", "user", "assistant", "observation"], role
-        role_tokens = [self.get_command(f"<|{role}|>")] + self.tokenizer.encode(f"{metadata}\n")
-        message_tokens = self.tokenizer.encode(message)
-        tokens = role_tokens + message_tokens
-        return tokens
-
-    def build_chat_input(self, query, history=None, role="user"):
-        if history is None:
-            history = []
-        input_ids = []
-        for item in history:
-            content = item["content"]
-            if item["role"] == "system" and "tools" in item:
-                content = content + "\n" + json.dumps(item["tools"], indent=4, ensure_ascii=False)
-            input_ids.extend(self.build_single_message(item["role"], item.get("metadata", ""), content))
-        input_ids.extend(self.build_single_message(role, "", query))
-        input_ids.extend([self.get_command("<|assistant|>")])
-        return self.batch_encode_plus([input_ids], return_tensors="pt", is_split_into_words=True)
-
-    def build_inputs_with_special_tokens(
-        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
-    ) -> List[int]:
-        """
-        Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
-        adding special tokens. A BERT sequence has the following format:
-
-        - single sequence: `[CLS] X [SEP]`
-        - pair of sequences: `[CLS] A [SEP] B [SEP]`
-
-        Args:
-            token_ids_0 (`List[int]`):
-                List of IDs to which the special tokens will be added.
-            token_ids_1 (`List[int]`, *optional*):
-                Optional second list of IDs for sequence pairs.
-
-        Returns:
-            `List[int]`: List of [input IDs](../glossary#input-ids) with the appropriate special tokens.
-        """
-        prefix_tokens = self.get_prefix_tokens()
-        token_ids_0 = prefix_tokens + token_ids_0
-        if token_ids_1 is not None:
-            token_ids_0 = token_ids_0 + token_ids_1 + [self.get_command("<eos>")]
-        return token_ids_0
-
-    def _pad(
-        self,
-        encoded_inputs: Union[Dict[str, EncodedInput], BatchEncoding],
-        max_length: Optional[int] = None,
-        padding_strategy: PaddingStrategy = PaddingStrategy.DO_NOT_PAD,
-        pad_to_multiple_of: Optional[int] = None,
-        return_attention_mask: Optional[bool] = None,
-    ) -> dict:
-        """
-        Pad encoded inputs (on left/right and up to predefined length or max length in the batch)
-
-        Args:
-            encoded_inputs:
-                Dictionary of tokenized inputs (`List[int]`) or batch of tokenized inputs (`List[List[int]]`).
-            max_length: maximum length of the returned list and optionally padding length (see below).
-                Will truncate by taking into account the special tokens.
-            padding_strategy: PaddingStrategy to use for padding.
-
-                - PaddingStrategy.LONGEST Pad to the longest sequence in the batch
-                - PaddingStrategy.MAX_LENGTH: Pad to the max length (default)
-                - PaddingStrategy.DO_NOT_PAD: Do not pad
-                The tokenizer padding sides are defined in self.padding_side:
-
-                    - 'left': pads on the left of the sequences
-                    - 'right': pads on the right of the sequences
-            pad_to_multiple_of: (optional) Integer if set will pad the sequence to a multiple of the provided value.
-                This is especially useful to enable the use of Tensor Core on NVIDIA hardware with compute capability
-                `>= 7.5` (Volta).
-            return_attention_mask:
-                (optional) Set to False to avoid returning attention mask (default: set to model specifics)
-        """
-        # Load from model defaults
-        assert self.padding_side == "left"
-
-        required_input = encoded_inputs[self.model_input_names[0]]
-        seq_length = len(required_input)
-
-        if padding_strategy == PaddingStrategy.LONGEST:
-            max_length = len(required_input)
-
-        if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
-            max_length = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of
-
-        needs_to_be_padded = padding_strategy != PaddingStrategy.DO_NOT_PAD and len(required_input) != max_length
-
-        # Initialize attention mask if not present.
-        if "attention_mask" not in encoded_inputs:
-            encoded_inputs["attention_mask"] = [1] * seq_length
-
-        if "position_ids" not in encoded_inputs:
-            encoded_inputs["position_ids"] = list(range(seq_length))
-
-        if needs_to_be_padded:
-            difference = max_length - len(required_input)
-
-            if "attention_mask" in encoded_inputs:
-                encoded_inputs["attention_mask"] = [0] * difference + encoded_inputs["attention_mask"]
-            if "position_ids" in encoded_inputs:
-                encoded_inputs["position_ids"] = [0] * difference + encoded_inputs["position_ids"]
-            encoded_inputs[self.model_input_names[0]] = [self.pad_token_id] * difference + required_input
-
-        return encoded_inputs
diff --git a/Experiments/chatglm3_6b_tokenizer/tokenizer.model b/Experiments/chatglm3_6b_tokenizer/tokenizer.model
deleted file mode 100644
index c8336ad..0000000
Binary files a/Experiments/chatglm3_6b_tokenizer/tokenizer.model and /dev/null differ
diff --git a/Experiments/chatglm3_6b_tokenizer/tokenizer_config.json b/Experiments/chatglm3_6b_tokenizer/tokenizer_config.json
deleted file mode 100644
index fbcb2c8..0000000
--- a/Experiments/chatglm3_6b_tokenizer/tokenizer_config.json
+++ /dev/null
@@ -1,52 +0,0 @@
-{
-  "added_tokens_decoder": {
-    "64790": {
-      "content": "[gMASK]",
-      "lstrip": false,
-      "normalized": true,
-      "rstrip": false,
-      "single_word": false,
-      "special": false
-    },
-    "64792": {
-      "content": "sop",
-      "lstrip": false,
-      "normalized": true,
-      "rstrip": false,
-      "single_word": false,
-      "special": false
-    },
-    "64795": {
-      "content": "<|user|>",
-      "lstrip": false,
-      "normalized": true,
-      "rstrip": false,
-      "single_word": false,
-      "special": false
-    },
-    "64796": {
-      "content": "<|assistant|>",
-      "lstrip": false,
-      "normalized": true,
-      "rstrip": false,
-      "single_word": false,
-      "special": false
-    }
-  },
-  "auto_map": {
-    "AutoTokenizer": [
-      "tokenization_chatglm.ChatGLMTokenizer",
-      null
-    ]
-  },
-  "chat_template": "{% for message in messages %}{% if loop.first %}[gMASK]sop<|{{ message['role'] }}|>\n {{ message['content'] }}{% else %}<|{{ message['role'] }}|>\n {{ message['content'] }}{% endif %}{% endfor %}{% if add_generation_prompt %}<|assistant|>{% endif %}",
-  "clean_up_tokenization_spaces": false,
-  "do_lower_case": false,
-  "eos_token": "</s>",
-  "model_max_length": 1000000000000000019884624838656,
-  "pad_token": "<unk>",
-  "padding_side": "left",
-  "remove_space": false,
-  "tokenizer_class": "ChatGLMTokenizer",
-  "unk_token": "<unk>"
-}
diff --git a/Journey/Day001/Day001.ipynb b/Journey/Day001/Day001.ipynb
deleted file mode 100644
index 3779481..0000000
--- a/Journey/Day001/Day001.ipynb
+++ /dev/null
@@ -1,131 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 从0️⃣跑通中文大模型构建｜🚀Day001"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 参考项目搜集"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "- [nano-llama31](https://github.com/karpathy/nano-llama31/tree/master)\n",
-    "\n",
-    "    - Karpathy大神的项目，用700多行代码完成了一个尽可能低依赖的最简洁llama3.1实现，能够进行训练、微调和推理（跪拜🧎‍♂️）\n",
-    "\n",
-    "- [TinyLlama](https://github.com/jzhang38/TinyLlama/blob/main/README_zh-CN.md)\n",
-    "\n",
-    "    - TinyLlama项目在3万亿tokens上进行预训练，构建一个拥有1.1B参数的Llama模型\n",
-    "    \n",
-    "    - 采用了与Llama 2完全相同的架构和分词器\n",
-    "\n",
-    "- [baby-llama2-chinese](https://github.com/DLLXW/baby-llama2-chinese?tab=readme-ov-file)\n",
-    "\n",
-    "    - 中文数据从头训练+SFT的一个小参数实现，可以在24G单卡运行；目前包含：预训练、SFT指令微调，**奖励模型**以及**强化学习**待做（但似乎已经断更3个月）\n",
-    "    \n",
-    "    - 基于llama2架构\n",
-    "    \n",
-    "- [ChatLM-mini-Chinese](https://github.com/charent/ChatLM-mini-Chinese)\n",
-    "\n",
-    "    - 中文对话0.2B小模型（ChatLM-Chinese-0.2B），开源所有数据集来源、数据清洗、tokenizer训练、模型预训练、SFT指令微调、RLHF优化等流程的全部代码\n",
-    "    \n",
-    "    - 支持下游任务sft微调，给出了三元组信息抽取任务的微调示例\n",
-    "    \n",
-    "    - 有意思的是作者选的模型架构是T5，还有另一个衍生项目用的是phi-2架构"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 数据集确定"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "这个计划的主要目地是能从头熟悉一遍大模型训练的流程，所以不需要收集大量的文本数据集（我显然也没有那么多的GPU资源能让我在超大的数据集上快速训练🤷‍♂️）\n",
-    "\n",
-    "之前看到微软的一篇论文[TinyStories](https://arxiv.org/abs/2305.07759)，探索的是语言模型在多小的情况下还能流利地讲故事。为此他们构造了一个小数据集，包含了一些小故事，我觉得这个数据集很适合我这个项目的目标，所以决定使用这个数据集。\n",
-    "\n",
-    "由于希望在中文数据集上进行项目，所以原本的打算是通过机器翻译把数据集翻译一遍，结果发现已经有人做了这个工作，所以我打算直接使用这个翻译好的[数据集](https://huggingface.co/datasets/adam89/TinyStoriesChinese)。🙏感谢大佬们的无私奉献。\n",
-    "\n",
-    "一个样例如下：\n",
-    "```json\n",
-    "{\n",
-    "    \"story\": \"\\n\\nLily and Ben are friends. They like to play in the park. One day, they see a big tree with a swing. Lily wants to try the swing. She runs to the tree and climbs on the swing.\\n\\\"Push me, Ben!\\\" she says. Ben pushes her gently. Lily feels happy. She swings higher and higher. She laughs and shouts.\\nBen watches Lily. He thinks she is cute. He wants to swing too. He waits for Lily to stop. But Lily does not stop. She swings faster and faster. She is having too much fun.\\n\\\"Can I swing too, Lily?\\\" Ben asks. Lily does not hear him. She is too busy swinging. Ben feels sad. He walks away.\\nLily swings so high that she loses her grip. She falls off the swing. She lands on the ground. She hurts her foot. She cries.\\n\\\"Ow, ow, ow!\\\" she says. She looks for Ben. She wants him to help her. But Ben is not there. He is gone.\\nLily feels sorry. She wishes she had shared the swing with Ben. She wishes he was there to hug her. She limps to the tree. She sees something hanging from a branch. It is Ben's hat. He left it for her.\\nLily smiles. She thinks Ben is nice. She puts on his hat. She hopes he will come back. She wants to say sorry. She wants to be friends again.\",\n",
-    "    \"instruction\": {\n",
-    "        \"prompt:\": \"Write a short story (3-5 paragraphs) which only uses very simple words that a 3 year old child would understand. The story should use the verb \\\"hang\\\", the noun \\\"foot\\\" and the adjective \\\"cute\\\". The story has the following features: the story should contain at least one dialogue. Remember to only use simple words!\\n\\nPossible story:\",\n",
-    "        \"words\": [\n",
-    "            \"hang\",\n",
-    "            \"foot\",\n",
-    "            \"cute\"\n",
-    "        ],\n",
-    "        \"features\": [\n",
-    "            \"Dialogue\"\n",
-    "        ]\n",
-    "    },\n",
-    "    \"summary\": \"Lily and Ben play in the park and Lily gets too caught up in swinging, causing Ben to leave. Lily falls off the swing and hurts herself, but Ben leaves his hat for her as a kind gesture.\",\n",
-    "    \"source\": \"GPT-4\",\n",
-    "    \"story_zh\": \"莉莉和本是朋友。他们喜欢在公园里玩。有一天，他们在一棵大树下看到了一个秋千。莉莉想试试那个秋千。她跑到树下，爬上了秋千。\\n\\\"推我，本！\\\"她说。本轻轻地推了她一下。莉莉感到很开心。她越荡越高，笑着喊叫。\\n本看着莉莉。他觉得她很可爱。他也想荡秋千。他在莉莉停下来之后等着。但是莉莉没有停下来。她越荡越快。她玩得太高兴了。\\n\\\"我也可以荡秋千吗，莉莉？\\\"本问。莉莉没听到他的话。她忙着荡秋千。本觉得很难过。他走开了。\\n莉莉荡得太高，失去了平衡。她从秋千上摔下来，落在地上。她扭伤了脚。她哭了起来。\\n\\\"哎呀，哎呀，哎呀！\\\"她说。她在找本。她希望他能帮助她。但本不在那里。他走了。\\n莉莉感到很抱歉。她希望她能和本分享秋千。她希望他在那里拥抱她。她一瘸一拐地走到树下。她看到有什么东西挂在树枝上。那是本的帽子。他留给她的。\\n莉莉笑了。她觉得本很好。她戴上了他的帽子。她希望他会回来。她想道歉。她想再次成为朋友。\"\n",
-    "}\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 数据清洗\n",
-    "在标准的流程里，文本数据量会非常大且来自于不同的来源，无论从质量上和内容重复度上都需要进行清洗。\n",
-    "\n",
-    "由于这个数据集是一个单独的小数据集，所以我打算先**跳过这一步**。\n",
-    "\n",
-    "不过这里还是简单说一下数据清洗的一些方法：\n",
-    "- 去除重复数据\n",
-    "  - 当量级巨大的时候一般会采用SimHash或者MinHash的方法\n",
-    "  - 短文本过滤（太短的文本对于模型训练而言意义不大，可以直接去除）\n",
-    "- 去除低质量数据\n",
-    "  - 一般会采用一些规则或者模型来判断文本的质量，例如：语法错误、拼写错误、不合理内容、无意义数据等\n",
-    "  - 这一步的成本会比较高，因为需要人工标注或者构建模型（但高质量的数据对于模型训练是非常重要的）"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 训练框架选择\n",
-    "\n",
-    "一个好的训练框架还是很重要的，在上面的参考项目中发现了这个名为[⚡️litgpt](https://github.com/Lightning-AI/litgpt/tree/main)的大模型预训练/微调/部署框架，而且其早期的model代码是基于上面Karpahty大神的nano-llama31项目。\n",
-    "\n",
-    "框架已经支持了20+大模型，包括最新的Llama 3.1。大概看了一下代码仓库，结构清晰且简洁。所以我决定花时间熟悉一下这个框架作为后续的训练工具。\n",
-    "\n",
-    "个人觉得如今的大模型训练框架已经非常成熟，大家都在追求更高的性能和更好的易用性，所以选择一个好的框架对于后续的工作来说是非常重要的。\n",
-    "\n",
-    "也没有必要自己造轮子，毕竟大家都在造了，我们只需要选择一个适合自己的就好了。"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  }
- ],
- "metadata": {
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/Journey/Day002/Day002.ipynb b/Journey/Day002/Day002.ipynb
deleted file mode 100644
index 5cec828..0000000
--- a/Journey/Day002/Day002.ipynb
+++ /dev/null
@@ -1,191 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 从0️⃣跑通中文大模型构建｜🚀Day002"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Tokenizer选择"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**tokenization**是大模型训练的第一步，是将文本转换为模型可以理解的数字表示（后面也能反向decode回来）。\n",
-    "\n",
-    "其中目前比较主流的是[BPE(Byte Pair Encoding)](https://zhuanlan.zhihu.com/p/424631681)（详细的介绍可以参考链接文章，下面只进行一些简单的介绍）。\n",
-    "\n",
-    "**BPE**是一种简单的数据压缩形式，这种方法用数据中不存在的一个字节表示最常出现的连续字节数据。这样的替换需要重建全部原始数据。\n",
-    "\n",
-    "### BPE简介\n",
-    "\n",
-    "假设我们要编码如下数据\n",
-    "\n",
-    "> aaabdaaabac\n",
-    "\n",
-    "字节对“aa”出现次数最多，所以我们用数据中没有出现的字节“Z”替换“aa”得到替换表\n",
-    "\n",
-    "> Z <- aa\n",
-    "\n",
-    "数据转变为\n",
-    "\n",
-    "> ZabdZabac\n",
-    "\n",
-    "在这个数据中，字节对“Za”出现的次数最多，我们用另外一个字节“Y”来替换它（这种情况下由于所有的“Z”都将被替换，所以也可以用“Z”来替换“Za”），得到替换表以及数据\n",
-    "\n",
-    "> Z <- aa\n",
-    "> Y <- Za\n",
-    "\n",
-    "> YbdYbac\n",
-    "\n",
-    "我们再次替换最常出现的字节对得到：\n",
-    "\n",
-    "> Z <- aa\n",
-    "> Y <- Za\n",
-    "> X <- Yb\n",
-    "\n",
-    "> XdXac\n",
-    "\n",
-    "由于不再有重复出现的字节对，所以这个数据不能再被进一步压缩。\n",
-    "\n",
-    "解压的时候，就是按照相反的顺序执行替换过程。\n",
-    "\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 以ChatGLM3-6B的tokenizer为例"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Setting eos_token is not supported, use the default one.\n",
-      "Setting pad_token is not supported, use the default one.\n",
-      "Setting unk_token is not supported, use the default one.\n"
-     ]
-    }
-   ],
-   "source": [
-    "from transformers import AutoTokenizer\n",
-    "\n",
-    "tokenizer = AutoTokenizer.from_pretrained(\"THUDM/chatglm3-6b\", trust_remote_code=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'input_ids': [64790, 64792, 30910, 36037, 32882], 'attention_mask': [1, 1, 1, 1, 1], 'position_ids': [0, 1, 2, 3, 4]}"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "tokenizer(\"这是一个测试\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'[gMASK] sop 这是一个测试'"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "tokenizer.decode(tokenizer(\"这是一个测试\")[\"input_ids\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "64798"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "tokenizer.vocab_size"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### 选择ChatGLM3-6B的tokenizer的原因\n",
-    "\n",
-    "该词表大小为64798，值得注意的是：这是一个很妙的数字，因为它**刚好在uint16的表示范围（0～65535的无符号整数）**，每一个token只需要两个字节即可表示。\n",
-    "\n",
-    "当我们的语料较大时候，相比常用的int32可以**节省一半的存储空间**。\n",
-    "\n",
-    "另外这里选择一个小尺寸的词表还有一个更重要的原因：我们后面的模型会选择一个小参数量的，如果词表过大，会导致**大部分参数被embedding层占用**，而无法训练出更好的模型。"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "bigmodel",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.10"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/Journey/Day002/Day002.md b/Journey/Day002/Day002.md
deleted file mode 100644
index b4e2915..0000000
--- a/Journey/Day002/Day002.md
+++ /dev/null
@@ -1,101 +0,0 @@
-# 从0️⃣跑通中文大模型构建｜🚀Day002
-
-## Tokenizer选择
-
-**tokenization**是大模型训练的第一步，是将文本转换为模型可以理解的数字表示（后面也能反向decode回来）。
-
-其中目前比较主流的是[BPE(Byte Pair Encoding)](https://zhuanlan.zhihu.com/p/424631681)（详细的介绍可以参考链接文章，下面只进行一些简单的介绍）。
-
-**BPE**是一种简单的数据压缩形式，这种方法用数据中不存在的一个字节表示最常出现的连续字节数据。这样的替换需要重建全部原始数据。
-
-### BPE简介
-
-假设我们要编码如下数据
-
-> aaabdaaabac
-
-字节对“aa”出现次数最多，所以我们用数据中没有出现的字节“Z”替换“aa”得到替换表
-
-> Z <- aa
-
-数据转变为
-
-> ZabdZabac
-
-在这个数据中，字节对“Za”出现的次数最多，我们用另外一个字节“Y”来替换它（这种情况下由于所有的“Z”都将被替换，所以也可以用“Z”来替换“Za”），得到替换表以及数据
-
-> Z <- aa
-> Y <- Za
-
-> YbdYbac
-
-我们再次替换最常出现的字节对得到：
-
-> Z <- aa
-> Y <- Za
-> X <- Yb
-
-> XdXac
-
-由于不再有重复出现的字节对，所以这个数据不能再被进一步压缩。
-
-解压的时候，就是按照相反的顺序执行替换过程。
-
-
-
-
-### 以ChatGLM-6B的tokenizer为例
-
-
-```python
-from transformers import AutoTokenizer
-
-tokenizer = AutoTokenizer.from_pretrained("THUDM/chatglm3-6b", trust_remote_code=True)
-```
-
-    Setting eos_token is not supported, use the default one.
-    Setting pad_token is not supported, use the default one.
-    Setting unk_token is not supported, use the default one.
-
-
-
-```python
-tokenizer("这是一个测试")
-# fsdfdsf
-```
-
-
-
-
-    {'input_ids': [64790, 64792, 30910, 36037, 32882], 'attention_mask': [1, 1, 1, 1, 1], 'position_ids': [0, 1, 2, 3, 4]}
-
-
-
-
-```python
-tokenizer.decode(tokenizer("这是一个测试")["input_ids"])
-```
-
-
-
-
-    '[gMASK] sop 这是一个测试'
-
-
-
-
-```python
-tokenizer.vocab_size
-```
-
-
-
-
-    64798
-
-
-
-
-```python
-
-```
diff --git a/Journey/Day01/Day01.ipynb b/Journey/Day01/Day01.ipynb
new file mode 100644
index 0000000..97e8f70
--- /dev/null
+++ b/Journey/Day01/Day01.ipynb
@@ -0,0 +1,181 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 从零手搓中文大模型｜🚀Day01"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 参考项目搜集"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- [nano-llama31](https://github.com/karpathy/nano-llama31/tree/master)\n",
+    "\n",
+    "    - Karpathy大神的项目，用700多行代码完成了一个尽可能低依赖的最简洁`Llama3.1`实现，能够进行训练、微调和推理（跪拜🧎‍♂️）\n",
+    "\n",
+    "- [TinyLlama](https://github.com/jzhang38/TinyLlama/blob/main/README_zh-CN.md)\n",
+    "\n",
+    "    - `TinyLlama`项目在3万亿tokens上进行预训练，构建一个拥有`1.1B`参数的`Llama`模型\n",
+    "    \n",
+    "    - 采用了与`Llama 2`完全相同的架构和分词器\n",
+    "\n",
+    "- [baby-llama2-chinese](https://github.com/DLLXW/baby-llama2-chinese?tab=readme-ov-file)\n",
+    "\n",
+    "    - 中文数据从头训练+SFT的一个小参数实现，可以在`24G`单卡运行；目前包含：**预训练**、**SFT指令微调**，**奖励模型**以及**强化学习**待做（但似乎已经断更3个月）\n",
+    "    \n",
+    "    - 基于`Llama 2`架构\n",
+    "    \n",
+    "- [ChatLM-mini-Chinese](https://github.com/charent/ChatLM-mini-Chinese)\n",
+    "\n",
+    "    - 中文对话0.2B小模型（ChatLM-Chinese-0.2B），开源所有**数据集来源、数据清洗、tokenizer训练、模型预训练、SFT指令微调、RLHF优化**等流程的全部代码\n",
+    "    \n",
+    "    - 支持下游任务`sft`微调，给出了三元组信息抽取任务的微调示例\n",
+    "    \n",
+    "    - 有意思的是作者选的模型架构是`T5`，还有另一个衍生项目用的是`phi-2`架构\n",
+    "\n",
+    "除了第一个K神的项目是关于模型实现，后面三个项目的`README.md`文件看一遍下来，对于后续整体的实现流程心里便能有了一个大致的概念。\n",
+    "\n",
+    "之后遇到了实际问题时再去里面寻找细节来参考。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 数据集确定"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "这个计划的主要目地是能从头熟悉一遍大模型训练的流程，所以不需要收集大量的文本数据集（我显然也没有那么多的GPU资源能让我在超大的数据集上快速训练🤷‍♂️）\n",
+    "\n",
+    "之前看到微软的一篇论文[TinyStories](https://arxiv.org/abs/2305.07759)，探索的是语言模型在多小的情况下还能流利地讲故事。\n",
+    "\n",
+    "为此他们构造了一个小数据集，包含了一些小故事，我觉得这个数据集很适合我这个项目的目标，所以决定使用这个数据集。\n",
+    "\n",
+    "由于希望在中文数据集上进行实践，所以原本的打算是通过机器翻译把数据集翻译一遍。\n",
+    "\n",
+    "结果发现已经有人做了这个工作，所以我打算直接使用这个翻译好的[数据集](https://huggingface.co/datasets/adam89/TinyStoriesChinese)。🙏感谢大佬们的无私奉献。\n",
+    "\n",
+    "一个样例如下：\n",
+    "```json\n",
+    "{\n",
+    "    \"story\": \"\\n\\nLily and Ben are friends. They like to play in the park. One day, they see a big tree with a swing. Lily wants to try the swing. She runs to the tree and climbs on the swing.\\n\\\"Push me, Ben!\\\" she says. Ben pushes her gently. Lily feels happy. She swings higher and higher. She laughs and shouts.\\nBen watches Lily. He thinks she is cute. He wants to swing too. He waits for Lily to stop. But Lily does not stop. She swings faster and faster. She is having too much fun.\\n\\\"Can I swing too, Lily?\\\" Ben asks. Lily does not hear him. She is too busy swinging. Ben feels sad. He walks away.\\nLily swings so high that she loses her grip. She falls off the swing. She lands on the ground. She hurts her foot. She cries.\\n\\\"Ow, ow, ow!\\\" she says. She looks for Ben. She wants him to help her. But Ben is not there. He is gone.\\nLily feels sorry. She wishes she had shared the swing with Ben. She wishes he was there to hug her. She limps to the tree. She sees something hanging from a branch. It is Ben's hat. He left it for her.\\nLily smiles. She thinks Ben is nice. She puts on his hat. She hopes he will come back. She wants to say sorry. She wants to be friends again.\",\n",
+    "    \"instruction\": {\n",
+    "        \"prompt:\": \"Write a short story (3-5 paragraphs) which only uses very simple words that a 3 year old child would understand. The story should use the verb \\\"hang\\\", the noun \\\"foot\\\" and the adjective \\\"cute\\\". The story has the following features: the story should contain at least one dialogue. Remember to only use simple words!\\n\\nPossible story:\",\n",
+    "        \"words\": [\n",
+    "            \"hang\",\n",
+    "            \"foot\",\n",
+    "            \"cute\"\n",
+    "        ],\n",
+    "        \"features\": [\n",
+    "            \"Dialogue\"\n",
+    "        ]\n",
+    "    },\n",
+    "    \"summary\": \"Lily and Ben play in the park and Lily gets too caught up in swinging, causing Ben to leave. Lily falls off the swing and hurts herself, but Ben leaves his hat for her as a kind gesture.\",\n",
+    "    \"source\": \"GPT-4\",\n",
+    "    \"story_zh\": \"莉莉和本是朋友。他们喜欢在公园里玩。有一天，他们在一棵大树下看到了一个秋千。莉莉想试试那个秋千。她跑到树下，爬上了秋千。\\n\\\"推我，本！\\\"她说。本轻轻地推了她一下。莉莉感到很开心。她越荡越高，笑着喊叫。\\n本看着莉莉。他觉得她很可爱。他也想荡秋千。他在莉莉停下来之后等着。但是莉莉没有停下来。她越荡越快。她玩得太高兴了。\\n\\\"我也可以荡秋千吗，莉莉？\\\"本问。莉莉没听到他的话。她忙着荡秋千。本觉得很难过。他走开了。\\n莉莉荡得太高，失去了平衡。她从秋千上摔下来，落在地上。她扭伤了脚。她哭了起来。\\n\\\"哎呀，哎呀，哎呀！\\\"她说。她在找本。她希望他能帮助她。但本不在那里。他走了。\\n莉莉感到很抱歉。她希望她能和本分享秋千。她希望他在那里拥抱她。她一瘸一拐地走到树下。她看到有什么东西挂在树枝上。那是本的帽子。他留给她的。\\n莉莉笑了。她觉得本很好。她戴上了他的帽子。她希望他会回来。她想道歉。她想再次成为朋友。\"\n",
+    "}\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 数据清洗\n",
+    "在标准的流程里，**文本数据量会非常大**且来自于不同的来源，无论从**质量**上和**内容重复度**上都需要进行清洗。\n",
+    "\n",
+    "由于这个数据集是一个单独的小数据集，所以我打算先**跳过这一步**。\n",
+    "\n",
+    "不过这里还是简单说一下数据清洗的一些方法：\n",
+    "- 去除重复数据\n",
+    "  - 当量级巨大的时候一般会采用`SimHash`或者`MinHash`的方法\n",
+    "  - 短文本过滤（太短的文本对于模型训练而言意义不大，可以直接去除）\n",
+    "- 去除低质量数据\n",
+    "  - 一般会采用一些规则或者模型来判断文本的质量，例如：**语法错误、拼写错误、不合理内容、无意义数据**等\n",
+    "  - 这一步的成本会比较高，因为需要人工标注或者构建模型（但高质量的数据对于模型训练是非常重要的）"
+   ]
+  },
+  {
+   "attachments": {
+    "image-2.png": {
+     "image/png": "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"
+    },
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 训练框架选择\n",
+    "\n",
+    "一个好的训练框架还是很重要的。\n",
+    "\n",
+    "在上面的参考项目中发现了这个名为[⚡️litgpt](https://github.com/Lightning-AI/litgpt/tree/main)的大模型预训练/微调/部署框架，而且其模型实现代码是基于上面Karpahty大神的`nano-llama31`项目。\n",
+    "\n",
+    "框架已经支持了`20+`大模型，包括最新的`Llama 3.1`。大概看了一下代码仓库，结构清晰且简洁。\n",
+    "\n",
+    "![image.png](attachment:image.png)\n",
+    "\n",
+    "另外一个框架是[Llama-Factory](https://github.com/hiyouga/LLaMA-Factory/blob/main/README_zh.md)，已经有29k的stars，支持`100+`大模型（尤其是对国内的开源模型支持很好）。\n",
+    "\n",
+    "![image-2.png](attachment:image-2.png)\n",
+    "\n",
+    "所以我决定花时间简单了解一下这两个框架然后选一个作为后续的训练工具。\n",
+    "\n",
+    "个人觉得如今的大模型训练框架已经非常成熟，大家都在追求**更高的性能和更好的易用性**，所以**选择一个好的框架**对于后续的工作来说是非常重要的。\n",
+    "\n",
+    "也没有必要自己造轮子，毕竟大家都在造了，我们只需要选择一个适合自己的就好了。\n",
+    "\n",
+    "> 经过调研发现`Llama-Factory`似乎~~只能支持和发布的开源模型参数一致的模型（也可能是我看的不仔细没有找到修改配置的地方，如果是这样欢迎大家指出）~~。\n",
+    "> \n",
+    "> 而litgpt则支持自定义模型参数，\n",
+    "> 由于我后面是希望限制参数量级在一个很小的范畴，所以决定使用litgpt作为后续的训练工具。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "⚠️更新：\n",
+    "\n",
+    "后续也找到了`Llama-Factory`里从0训练并且修改参数的方法（修改`config.json`的配置，并且添加`train_from_scratch=True`参数），\n",
+    "\n",
+    "但`litgpt`的代码架构更加简洁，没有过多的抽象和封装，并且有一些训练加速的优化（`Llama-Factory`是基于`transformers`库），\n",
+    "\n",
+    "因此最后还是决定使用`litgpt`。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 小结\n",
+    "1. 确定了项目的数据集来源\n",
+    "2. 了解了一些数据清洗的方法\n",
+    "3. 选择了litgpt作为后续的训练工具\n",
+    "4. 了解了一些参考项目，对后续的实现流程有了一个大致的概念"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Journey/Day01/Day01_files/image-2.png b/Journey/Day01/Day01_files/image-2.png
new file mode 100644
index 0000000..aef6e82
Binary files /dev/null and b/Journey/Day01/Day01_files/image-2.png differ
diff --git a/Journey/Day01/Day01_files/image.png b/Journey/Day01/Day01_files/image.png
new file mode 100644
index 0000000..20911f1
Binary files /dev/null and b/Journey/Day01/Day01_files/image.png differ
diff --git a/Journey/Day02/Day02.ipynb b/Journey/Day02/Day02.ipynb
new file mode 100644
index 0000000..8865826
--- /dev/null
+++ b/Journey/Day02/Day02.ipynb
@@ -0,0 +1,282 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 从零手搓中文大模型｜🚀Day02"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Tokenizer选择"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**tokenization**是大模型训练的第一步，是将文本转换为模型可以理解的数字表示（后面也能反向decode回来）。\n",
+    "\n",
+    "其中目前比较主流的是[BPE(Byte Pair Encoding)](https://zhuanlan.zhihu.com/p/424631681)（详细的介绍可以参考链接文章，下面只进行一些简单的介绍）。\n",
+    "\n",
+    "**BPE**是一种简单的数据压缩形式，这种方法用数据中不存在的一个字节表示最常出现的连续字节数据。这样的替换需要重建全部原始数据。\n",
+    "\n",
+    "### BPE简介\n",
+    "\n",
+    "假设我们要编码如下数据\n",
+    "\n",
+    "> aaabdaaabac\n",
+    "\n",
+    "字节对“aa”出现次数最多，所以我们用数据中没有出现的字节“Z”替换“aa”得到替换表\n",
+    "\n",
+    "> Z <- aa\n",
+    "\n",
+    "数据转变为\n",
+    "\n",
+    "> ZabdZabac\n",
+    "\n",
+    "在这个数据中，字节对“Za”出现的次数最多，我们用另外一个字节“Y”来替换它（这种情况下由于所有的“Z”都将被替换，所以也可以用“Z”来替换“Za”），得到替换表以及数据\n",
+    "\n",
+    "> Z <- aa\n",
+    "> Y <- Za\n",
+    "\n",
+    "> YbdYbac\n",
+    "\n",
+    "我们再次替换最常出现的字节对得到：\n",
+    "\n",
+    "> Z <- aa\n",
+    "> Y <- Za\n",
+    "> X <- Yb\n",
+    "\n",
+    "> XdXac\n",
+    "\n",
+    "由于不再有重复出现的字节对，所以这个数据不能再被进一步压缩。\n",
+    "\n",
+    "解压的时候，就是按照相反的顺序执行替换过程。\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 测试Tokenizer(以ChatGLM3-6B的tokenizer为例)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Setting eos_token is not supported, use the default one.\n",
+      "Setting pad_token is not supported, use the default one.\n",
+      "Setting unk_token is not supported, use the default one.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import AutoTokenizer\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(\"THUDM/chatglm3-6b\", trust_remote_code=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'input_ids': [64790, 64792, 30910, 36037, 32882], 'attention_mask': [1, 1, 1, 1, 1], 'position_ids': [0, 1, 2, 3, 4]}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tokenizer(\"这是一个测试\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'[gMASK] sop 这是一个测试'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tokenizer.decode(tokenizer(\"这是一个测试\")[\"input_ids\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "64798"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tokenizer.vocab_size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "def process_line(line, tokenizer, add_eos=True, dtype=np.uint16):\n",
+    "    js = json.loads(line)\n",
+    "    story = js[\"story_zh\"]\n",
+    "    story = tokenizer.encode(story, add_special_tokens=False)\n",
+    "    if add_eos:\n",
+    "        story.append(tokenizer.eos_token_id)\n",
+    "    # 还记得么，这里可以用np.unint16，因为我们的vocab_size是小于65536的\n",
+    "    arr = np.array(story, dtype=dtype)\n",
+    "    return arr"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "❗️这里有几个需要注意的点：\n",
+    "- `add_special_tokens`参数的作用是添加特殊token。\n",
+    "  是chatglm自定义的例如[gMASK]/sop，属于glm架构里特有的（可以参考[这里](https://github.com/THUDM/ChatGLM3/issues/183)）。\n",
+    "  \n",
+    "  由于我们后续并不使用glm的架构，因此这里不需要添加，**直接设置为False**。\n",
+    "- 需要在末尾加上`eos`标记对应的token_id。\n",
+    "- chatglm3-6b使用的词表大小为`64798`，刚好在uint16的表示范围内，所以上面我们给numpy.array设置了`dtype=np.uint16`。\n",
+    "\n",
+    "拿一行测试一下："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[30910 56623 56623 54542 50154 31761 31155 31633 31815 54534 32693 54662\n",
+      " 55409 31155 35632 31123 31633 34383 57427 47658 54578 34518 31623 55567\n",
+      " 55226 31155 56623 56623 54695 39887 32437 55567 55226 31155 54790 41309\n",
+      " 52624 31123 56856 32660 55567 55226 31155    13 30955 54834 54546 31123\n",
+      " 54613 31404 30955 36213 31155 54613 36660 54563 54834 43881 32024 31155\n",
+      " 56623 56623 32707 54657 33436 31155 54790 54937 56567 40714 31123 38502\n",
+      " 56653 55483 31155    13 54613 32984 56623 56623 31155 54572 31897 54790\n",
+      " 54657 35245 31155 36551 54695 56567 55567 55226 31155 33152 56623 56623\n",
+      " 51556 31797 39055 31155 31694 56623 56623 31631 51556 31155 54790 54937\n",
+      " 56567 54937 54929 31155 54790 55409 40915 34492 54537 31155    13 30955\n",
+      " 54546 32591 56567 55567 55226 55398 31123 56623 56623 31514 30955 54613\n",
+      " 54761 31155 56623 56623 54721 33906 31804 54887 31155 54790 46977 56567\n",
+      " 55567 55226 31155 54613 31897 32960 54597 31155 54572 54942 34675 31155\n",
+      "    13 56623 56623 56567 40915 54589 31123 36467 33501 31155 54790 54708\n",
+      " 55567 55226 54547 57456 32246 31123 36712 34245 31155 54790 56901 55328\n",
+      " 54537 55673 31155 54790 56399 37247 31155    13 30955 58394 56657 31123\n",
+      " 58394 56657 31123 58394 56657 31404 30955 36213 31155 35957 55227 54613\n",
+      " 31155 54790 31772 47554 31934 54790 31155 54688 54613 33551 33892 31155\n",
+      " 54572 34247 31155    13 56623 56623 32707 54657 52992 31155 54790 31772\n",
+      " 54790 54558 54542 54613 32097 55567 55226 31155 54790 31772 33152 33892\n",
+      " 37322 54790 31155 54790 54531 60337 54531 57635 54563 35220 52624 31155\n",
+      " 54790 31857 33277 32086 44829 49102 54547 31155 35328 43352 41147 31155\n",
+      " 54572 42393 32233 31155    13 56623 56623 40466 31155 54790 31897 54613\n",
+      " 33058 31155 54790 55947 32660 31804 41147 31155 54790 31772 38711 33857\n",
+      " 31155 54790 54695 37300 31155 54790 54695 32462 31705 31761 31155     2]\n",
+      "莉莉和本是朋友。他们喜欢在公园里玩。有一天，他们在一棵大树下看到了一个秋千。莉莉想试试那个秋千。她跑到树下，爬上了秋千。\n",
+      "\"推我，本！\"她说。本轻轻地推了她一下。莉莉感到很开心。她越荡越高，笑着喊叫。\n",
+      "本看着莉莉。他觉得她很可爱。他也想荡秋千。他在莉莉停下来之后等着。但是莉莉没有停下来。她越荡越快。她玩得太高兴了。\n",
+      "\"我也可以荡秋千吗，莉莉？\"本问。莉莉没听到他的话。她忙着荡秋千。本觉得很难过。他走开了。\n",
+      "莉莉荡得太高，失去了平衡。她从秋千上摔下来，落在地上。她扭伤了脚。她哭了起来。\n",
+      "\"哎呀，哎呀，哎呀！\"她说。她在找本。她希望他能帮助她。但本不在那里。他走了。\n",
+      "莉莉感到很抱歉。她希望她能和本分享秋千。她希望他在那里拥抱她。她一瘸一拐地走到树下。她看到有什么东西挂在树枝上。那是本的帽子。他留给她的。\n",
+      "莉莉笑了。她觉得本很好。她戴上了他的帽子。她希望他会回来。她想道歉。她想再次成为朋友。\n"
+     ]
+    }
+   ],
+   "source": [
+    "import json\n",
+    "\n",
+    "with open(\"../../Data/TinyStoriesChinese/train/data00_zh.jsonl\", \"r\") as f:\n",
+    "    for line in f.readlines():\n",
+    "        data = process_line(line, tokenizer)\n",
+    "        print(data)\n",
+    "        print(tokenizer.decode(data))\n",
+    "        break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 选择ChatGLM3-6B的tokenizer的原因\n",
+    "\n",
+    "该词表大小为64798，值得注意的是：这是一个很妙的数字，因为它**刚好在uint16的表示范围（0～65535的无符号整数）**，每一个token只需要两个字节即可表示。\n",
+    "\n",
+    "当我们的语料较大时候，相比常用的int32可以**节省一半的存储空间**。\n",
+    "\n",
+    "另外这里选择一个小尺寸的词表还有一个更重要的原因：我们后面的模型会选择一个小参数量的，如果词表过大，会导致**大部分参数被embedding层占用**，而无法训练出更好的模型。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "bigmodel",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Journey/Day03/Day03.ipynb b/Journey/Day03/Day03.ipynb
new file mode 100644
index 0000000..9f1b64e
--- /dev/null
+++ b/Journey/Day03/Day03.ipynb
@@ -0,0 +1,383 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 从零手搓中文大模型｜🚀Day03"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 数据预处理"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "虽然省略了数据清洗的逻辑，但是我们还是需要对数据进行预处理，以便于后续的模型训练。\n",
+    "\n",
+    "包括以下两个细节：\n",
+    "\n",
+    "1. 在每个文本后添加`eos`标记，以便于模型识别句子的结束。\n",
+    "2. 将文本转换为`数字序列`，以便于模型处理。\n",
+    "   \n",
+    "   这一步其实也可以放到模型训练的时候进行，但提前处理可以减少训练时的计算量。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 数据集划分\n",
+    "\n",
+    "解压数据集，得到`48`个jsonl文件，共计`3952863`行json数据。\n",
+    "\n",
+    "我之前已经解压过了，这里把命令贴出来做个记录。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "vscode": {
+     "languageId": "shellscript"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# !mkdir -p ../../Data/TinyStoriesChinese/raw_data/train\n",
+    "# !mkdir -p ../../Data/TinyStoriesChinese/raw_data/val\n",
+    "# !mkdir -p ../../Data/TinyStoriesChinese/processed_data/train\n",
+    "# !mkdir -p ../../Data/TinyStoriesChinese/processed_data/val\n",
+    "\n",
+    "# !tar zxvf ../../Data/TinyStoriesChinese/TinyStories_all_data_zh.tar.gz -C ../../Data/TinyStoriesChinese/raw_data/train"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "我把最后一个文件`data47_zh.jsonl`（共计78538行）里切分出来4w行作为`eval`数据。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "shellscript"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# !mv ../../Data/TinyStoriesChinese/raw_data/train/data47_zh.jsonl ../../Data/TinyStoriesChinese/raw_data/eval/\n",
+    "# !head -n 40000 ../../Data/TinyStoriesChinese/raw_data/eval/data47_zh.jsonl > ../../Data/TinyStoriesChinese/raw_data/eval/eval.jsonl\n",
+    "# !tail -n +40000 ../../Data/TinyStoriesChinese/raw_data/eval/data47_zh.jsonl > ../../Data/TinyStoriesChinese/raw_data/train/data47_zh.jsonl\n",
+    "# !rm ../../Data/TinyStoriesChinese/raw_data/eval/data47_zh.jsonl"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 先看一条数据"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "莉莉和本是朋友。他们喜欢在公园里玩。有一天，他们在一棵大树下看到了一个秋千。莉莉想试试那个秋千。她跑到树下，爬上了秋千。\n",
+      "\"推我，本！\"她说。本轻轻地推了她一下。莉莉感到很开心。她越荡越高，笑着喊叫。\n",
+      "本看着莉莉。他觉得她很可爱。他也想荡秋千。他在莉莉停下来之后等着。但是莉莉没有停下来。她越荡越快。她玩得太高兴了。\n",
+      "\"我也可以荡秋千吗，莉莉？\"本问。莉莉没听到他的话。她忙着荡秋千。本觉得很难过。他走开了。\n",
+      "莉莉荡得太高，失去了平衡。她从秋千上摔下来，落在地上。她扭伤了脚。她哭了起来。\n",
+      "\"哎呀，哎呀，哎呀！\"她说。她在找本。她希望他能帮助她。但本不在那里。他走了。\n",
+      "莉莉感到很抱歉。她希望她能和本分享秋千。她希望他在那里拥抱她。她一瘸一拐地走到树下。她看到有什么东西挂在树枝上。那是本的帽子。他留给她的。\n",
+      "莉莉笑了。她觉得本很好。她戴上了他的帽子。她希望他会回来。她想道歉。她想再次成为朋友。\n"
+     ]
+    }
+   ],
+   "source": [
+    "import json\n",
+    "\n",
+    "with open(\"../../Data/TinyStoriesChinese/raw_data/train/data00_zh.jsonl\", \"r\") as f:\n",
+    "    for line in f.readlines():\n",
+    "        js = json.loads(line)\n",
+    "        print(js[\"story_zh\"])\n",
+    "        break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 适配框架API"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "由于选择了使用[⚡️litgpt](https://github.com/Lightning-AI/litgpt/tree/main)框架进行训练，所以需要引入框架相关的`Class`和`API`来封装我们的数据准备逻辑。\n",
+    "\n",
+    "这里我们可以参考[源码里集成的Tinyllama的数据预处理代码](https://github.com/Lightning-AI/litgpt/blob/main/litgpt/data/prepare_slimpajama.py)里的代码，稍作修改。\n",
+    "\n",
+    "主要是需要将[Day02](../Day02/Day02.ipynb)里的`line`处理逻辑封装到`ligtgpt`的`API`中。\n",
+    "\n",
+    "但在此之前我们先熟悉一下`litgpt`的Tokenizer的使用方法："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from litgpt import Tokenizer\n",
+    "\n",
+    "litgpt_tokenizer = Tokenizer(\"../../References/chatglm3-6b\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "这里也实验了一下结果，对比发现和上面咱们之前用原生Tokenizer处理的**结果一致**。\n",
+    "\n",
+    "（不过需要注意litgpt的`Tokenizer.encode`返回的是一个torch的`Tensor`）"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor([30910, 56623, 56623, 54542, 50154, 31761, 31155, 31633, 31815, 54534,\n",
+      "        32693, 54662, 55409, 31155, 35632, 31123, 31633, 34383, 57427, 47658,\n",
+      "        54578, 34518, 31623, 55567, 55226, 31155, 56623, 56623, 54695, 39887,\n",
+      "        32437, 55567, 55226, 31155, 54790, 41309, 52624, 31123, 56856, 32660,\n",
+      "        55567, 55226, 31155,    13, 30955, 54834, 54546, 31123, 54613, 31404,\n",
+      "        30955, 36213, 31155, 54613, 36660, 54563, 54834, 43881, 32024, 31155,\n",
+      "        56623, 56623, 32707, 54657, 33436, 31155, 54790, 54937, 56567, 40714,\n",
+      "        31123, 38502, 56653, 55483, 31155,    13, 54613, 32984, 56623, 56623,\n",
+      "        31155, 54572, 31897, 54790, 54657, 35245, 31155, 36551, 54695, 56567,\n",
+      "        55567, 55226, 31155, 33152, 56623, 56623, 51556, 31797, 39055, 31155,\n",
+      "        31694, 56623, 56623, 31631, 51556, 31155, 54790, 54937, 56567, 54937,\n",
+      "        54929, 31155, 54790, 55409, 40915, 34492, 54537, 31155,    13, 30955,\n",
+      "        54546, 32591, 56567, 55567, 55226, 55398, 31123, 56623, 56623, 31514,\n",
+      "        30955, 54613, 54761, 31155, 56623, 56623, 54721, 33906, 31804, 54887,\n",
+      "        31155, 54790, 46977, 56567, 55567, 55226, 31155, 54613, 31897, 32960,\n",
+      "        54597, 31155, 54572, 54942, 34675, 31155,    13, 56623, 56623, 56567,\n",
+      "        40915, 54589, 31123, 36467, 33501, 31155, 54790, 54708, 55567, 55226,\n",
+      "        54547, 57456, 32246, 31123, 36712, 34245, 31155, 54790, 56901, 55328,\n",
+      "        54537, 55673, 31155, 54790, 56399, 37247, 31155,    13, 30955, 58394,\n",
+      "        56657, 31123, 58394, 56657, 31123, 58394, 56657, 31404, 30955, 36213,\n",
+      "        31155, 35957, 55227, 54613, 31155, 54790, 31772, 47554, 31934, 54790,\n",
+      "        31155, 54688, 54613, 33551, 33892, 31155, 54572, 34247, 31155,    13,\n",
+      "        56623, 56623, 32707, 54657, 52992, 31155, 54790, 31772, 54790, 54558,\n",
+      "        54542, 54613, 32097, 55567, 55226, 31155, 54790, 31772, 33152, 33892,\n",
+      "        37322, 54790, 31155, 54790, 54531, 60337, 54531, 57635, 54563, 35220,\n",
+      "        52624, 31155, 54790, 31857, 33277, 32086, 44829, 49102, 54547, 31155,\n",
+      "        35328, 43352, 41147, 31155, 54572, 42393, 32233, 31155,    13, 56623,\n",
+      "        56623, 40466, 31155, 54790, 31897, 54613, 33058, 31155, 54790, 55947,\n",
+      "        32660, 31804, 41147, 31155, 54790, 31772, 38711, 33857, 31155, 54790,\n",
+      "        54695, 37300, 31155, 54790, 54695, 32462, 31705, 31761, 31155,     2],\n",
+      "       dtype=torch.int32)\n",
+      "莉莉和本是朋友。他们喜欢在公园里玩。有一天，他们在一棵大树下看到了一个秋千。莉莉想试试那个秋千。她跑到树下，爬上了秋千。\n",
+      "\"推我，本！\"她说。本轻轻地推了她一下。莉莉感到很开心。她越荡越高，笑着喊叫。\n",
+      "本看着莉莉。他觉得她很可爱。他也想荡秋千。他在莉莉停下来之后等着。但是莉莉没有停下来。她越荡越快。她玩得太高兴了。\n",
+      "\"我也可以荡秋千吗，莉莉？\"本问。莉莉没听到他的话。她忙着荡秋千。本觉得很难过。他走开了。\n",
+      "莉莉荡得太高，失去了平衡。她从秋千上摔下来，落在地上。她扭伤了脚。她哭了起来。\n",
+      "\"哎呀，哎呀，哎呀！\"她说。她在找本。她希望他能帮助她。但本不在那里。他走了。\n",
+      "莉莉感到很抱歉。她希望她能和本分享秋千。她希望他在那里拥抱她。她一瘸一拐地走到树下。她看到有什么东西挂在树枝上。那是本的帽子。他留给她的。\n",
+      "莉莉笑了。她觉得本很好。她戴上了他的帽子。她希望他会回来。她想道歉。她想再次成为朋友。\n"
+     ]
+    }
+   ],
+   "source": [
+    "litgpt_encoded = litgpt_tokenizer.encode(\n",
+    "    json.loads(line)[\"story_zh\"], eos=True\n",
+    ")  # 记得设置eos=True\n",
+    "print(litgpt_encoded)\n",
+    "print(litgpt_tokenizer.decode(litgpt_encoded))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "数据处理参考上面给出的[链接](https://github.com/Lightning-AI/litgpt/blob/main/litgpt/data/prepare_slimpajama.py)，我们需要实现`prepare_slimpajama.py`里的相关函数。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.\n",
+    "\n",
+    "import json\n",
+    "import os\n",
+    "import time\n",
+    "import numpy as np\n",
+    "from pathlib import Path\n",
+    "\n",
+    "from litgpt.tokenizer import Tokenizer\n",
+    "from litgpt.data.prepare_starcoder import DataChunkRecipe\n",
+    "from litgpt.utils import extend_checkpoint_dir\n",
+    "\n",
+    "\n",
+    "class TinyStoriesZhDataRecipe(DataChunkRecipe):\n",
+    "    is_generator = True\n",
+    "\n",
+    "    def __init__(self, tokenizer: Tokenizer, chunk_size: int):\n",
+    "        super().__init__(chunk_size)\n",
+    "        self.tokenizer = tokenizer\n",
+    "\n",
+    "    def prepare_structure(self, input_dir):\n",
+    "        files = Path(input_dir).rglob(\"*.jsonl\")\n",
+    "        return [str(file) for file in files]\n",
+    "\n",
+    "    def prepare_item(self, filepath):\n",
+    "\n",
+    "        with open(filepath, \"rb\") as f:\n",
+    "            for line in f.readlines():\n",
+    "                js = json.loads(line)\n",
+    "                story = js[\"story_zh\"]\n",
+    "                # 注意这里要添加eos\n",
+    "                # 另外还记得吗：我们的vocab size在int16范围内，所以可以转换为uint16来节省内存\n",
+    "                story_ids = np.array(\n",
+    "                    self.tokenizer.encode(story, eos=True), dtype=np.uint16\n",
+    "                )\n",
+    "                yield story_ids\n",
+    "\n",
+    "\n",
+    "def prepare(\n",
+    "    input_dir: Path = Path(\"../../Data/TinyStoriesChinese/raw_data/train\"),\n",
+    "    output_dir: Path = Path(\"../../Data/TinyStoriesChinese/processed_data/train\"),\n",
+    "    tokenizer_path: Path = Path(\"../../References/chatglm3-6b\"),\n",
+    "    chunk_size: int = (2049 * 16384),\n",
+    "    fast_dev_run: bool = False,\n",
+    ") -> None:\n",
+    "    from litdata.processing.data_processor import DataProcessor\n",
+    "\n",
+    "    tokenizer_path = extend_checkpoint_dir(tokenizer_path)\n",
+    "    tokenizer = Tokenizer(tokenizer_path)\n",
+    "    data_recipe = TinyStoriesZhDataRecipe(tokenizer=tokenizer, chunk_size=chunk_size)\n",
+    "    data_processor = DataProcessor(\n",
+    "        input_dir=str(input_dir),\n",
+    "        output_dir=str(output_dir),\n",
+    "        fast_dev_run=fast_dev_run,\n",
+    "        num_workers=os.cpu_count(),\n",
+    "        num_downloaders=1,\n",
+    "    )\n",
+    "\n",
+    "    start_time = time.time()\n",
+    "    data_processor.run(data_recipe)\n",
+    "    elapsed_time = time.time() - start_time\n",
+    "    print(f\"Time taken: {elapsed_time:.2f} seconds\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 先用eval数据集测试\n",
+    "\n",
+    "（也可以设置`fast_dev_run=True`来处理更少的数据，尤其是debug时）\n",
+    "\n",
+    "执行完可以在`processed_data/eval`目录下看到生成的chunk文件。\n",
+    "\n",
+    "比较一下可以发现从原先的`83m`的`.jsonl`文件压缩到了`13m`的`.bin`,"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prepare(\n",
+    "    input_dir=Path(\"../../Data/TinyStoriesChinese/raw_data/eval\"),\n",
+    "    output_dir=Path(\"../../Data/TinyStoriesChinese/processed_data/eval\"),\n",
+    "    tokenizer_path=Path(\"../../References/chatglm3-6b\"),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 处理train数据集\n",
+    "在32核的CPU上处理`train`数据集耗时不到`1min`。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prepare(\n",
+    "    input_dir=Path(\"../../Data/TinyStoriesChinese/raw_data/train\"),\n",
+    "    output_dir=Path(\"../../Data/TinyStoriesChinese/processed_data/train\"),\n",
+    "    tokenizer_path=Path(\"../../References/chatglm3-6b\"),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 小结\n",
+    "\n",
+    "1. 数据预处理的逻辑主要是将文本转换为数字序列，以便于模型处理。\n",
+    "2. 通过litgpt的Tokenizer可以方便的实现文本到数字序列的转换。\n",
+    "3. litgpt提供了数据处理的API，可以方便的封装我们的数据处理逻辑。\n",
+    "4. 数据处理的结果可以通过压缩文件的方式减少存储空间。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "bigmodel",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Journey/Day03/__pycache__/packed_dataset.cpython-310.pyc b/Journey/Day03/__pycache__/packed_dataset.cpython-310.pyc
new file mode 100644
index 0000000..dbf5a2c
Binary files /dev/null and b/Journey/Day03/__pycache__/packed_dataset.cpython-310.pyc differ
diff --git a/Journey/Day03/packed_dataset.py b/Journey/Day03/packed_dataset.py
new file mode 100644
index 0000000..ab9a2e5
--- /dev/null
+++ b/Journey/Day03/packed_dataset.py
@@ -0,0 +1,260 @@
+# Very loosely inspired by indexed_dataset in Fairseq, Megatron
+# https://github.com/NVIDIA/Megatron-LM/blob/main/megatron/data/indexed_dataset.py
+
+
+import os
+import random
+import struct
+
+import numpy as np
+import torch
+from torch.utils.data import IterableDataset, get_worker_info
+
+dtypes = {
+    1: np.uint8,
+    2: np.int8,
+    3: np.int16,
+    4: np.int32,
+    5: np.int64,
+    6: np.float32,
+    7: np.float64,
+    8: np.uint16,
+}
+
+
+def code(dtype):
+    for k in dtypes:
+        if dtypes[k] == dtype:
+            return k
+    raise ValueError(dtype)
+
+
+HDR_MAGIC = b"LITPKDS"
+HDR_SIZE = 24  # bytes
+
+
+class PackedDataset(IterableDataset):
+    def __init__(
+        self,
+        filenames,
+        n_chunks,
+        block_size,
+        seed=12345,
+        shuffle=True,
+        wrap=False,
+        num_processes=1,
+        process_rank=0,
+    ):
+        self._filenames = filenames
+        self._n_chunks = n_chunks
+        self._block_size = block_size
+        self._seed = seed
+        self._shuffle = shuffle
+        self._wrap = wrap
+        self._num_processes = num_processes
+        self._process_rank = process_rank
+
+    def __iter__(self):
+        worker_info = get_worker_info()
+        num_workers = worker_info.num_workers if worker_info is not None else 1
+        worker_id = worker_info.id if worker_info is not None else 0
+        num_shards = num_workers * self._num_processes
+        shard_id = self._process_rank * num_workers + worker_id
+
+        max_num_files = len(self._filenames) // num_shards * num_shards
+        filenames = self._filenames[shard_id:max_num_files:num_shards]
+
+        return PackedDatasetIterator(
+            filenames=filenames,
+            n_chunks=self._n_chunks,
+            block_size=self._block_size,
+            seed=self._seed,
+            shuffle=self._shuffle,
+            wrap=self._wrap,
+        )
+
+
+class PackedDatasetBuilder(object):
+    def __init__(
+        self, outdir, prefix, chunk_size, sep_token, dtype="auto", vocab_size=None
+    ):
+        if dtype == "auto":
+            if vocab_size is None:
+                raise ValueError("vocab_size cannot be None when dtype='auto'")
+            if vocab_size is not None and vocab_size < 65500:
+                self._dtype = np.uint16
+            else:
+                self._dtype = np.int32
+        else:
+            self._dtype = dtype
+        self._counter = 0
+        self._chunk_size = chunk_size
+        self._outdir = outdir
+        self._prefix = prefix
+        self._sep_token = sep_token
+        self._arr = np.zeros(self._chunk_size, dtype=self._dtype)
+        self._arr.fill(self._sep_token)
+        self._idx = 0
+        self._version = 1
+        self._filenames = []
+
+    def _write_chunk(self):
+        filename = f"{self._prefix}_{self._counter:010d}.bin"
+        filename = os.path.join(self._outdir, filename)
+
+        with open(filename, "wb") as f:
+            f.write(HDR_MAGIC)
+            f.write(struct.pack("<Q", self._version))
+            f.write(struct.pack("<B", code(self._dtype)))
+            f.write(struct.pack("<Q", self._chunk_size))
+            f.write(self._arr.tobytes(order="C"))
+
+        self._filenames.append(filename)
+        self._counter += 1
+        self._arr.fill(self._sep_token)
+        self._idx = 0
+
+    @property
+    def dtype(self):
+        return self._dtype
+
+    @property
+    def filenames(self):
+        return self._filenames.copy()
+
+    def add_array(self, arr):
+        while self._idx + arr.shape[0] > self._chunk_size:
+            part_len = self._chunk_size - self._idx
+            self._arr[self._idx : self._idx + part_len] = arr[:part_len]
+            self._write_chunk()
+            arr = arr[part_len:]
+
+        arr_len = arr.shape[0]
+        self._arr[self._idx : self._idx + arr_len] = arr
+        self._idx += arr_len
+
+    def write_reminder(self):
+        self._write_chunk()
+
+
+class PackedDatasetIterator:
+    def __init__(self, filenames, n_chunks, block_size, seed, shuffle, wrap):
+        self._seed = seed
+        self._shuffle = shuffle
+        self._rng = np.random.default_rng(seed) if shuffle else None
+        self._block_idxs = None
+
+        self._wrap = wrap
+
+        # TODO: instead of filenames, we could have a single text stream
+        #       (or text file) with the sequence of all files to be
+        #       fetched/loaded.
+        self._filenames = filenames
+        self._file_idx = 0
+
+        self._n_chunks = n_chunks
+
+        self._dtype = None
+        self._block_size = block_size
+        self._n_blocks = None
+
+        self._mmaps = []
+        self._buffers = []
+
+        self._block_idxs = []
+        self._curr_idx = 0
+
+        self._load_n_chunks()
+
+    def _read_header(self, path):
+        with open(path, "rb") as f:
+            magic = f.read(len(HDR_MAGIC))
+            assert magic == HDR_MAGIC, "File doesn't match expected format."
+            version = struct.unpack("<Q", f.read(8))
+            assert version == (1,)
+            (dtype_code,) = struct.unpack("<B", f.read(1))
+            dtype = dtypes[dtype_code]
+            (chunk_size,) = struct.unpack("<Q", f.read(8))
+        return dtype, chunk_size
+
+    def _close_mmaps(self):
+        for mmap in self._mmaps:
+            mmap._mmap.close()
+
+    def _load_n_chunks(self):
+        self._close_mmaps()
+        self._mmaps = []
+        self._buffers = []
+
+        if self._n_chunks > len(self._filenames[self._file_idx :]):
+            # if not self._wrap:
+            #     raise StopIteration
+            self._file_idx = 0
+
+        for i in range(self._n_chunks):
+            filename = self._filenames[self._file_idx + i]
+            if self._dtype is None:
+                self._dtype, self._chunk_size = self._read_header(filename)
+                self._n_blocks = self._chunk_size // self._block_size
+            # TODO: check header matches with previous files
+            mmap = np.memmap(filename, mode="r", order="C", offset=HDR_SIZE)
+            self._mmaps.append(mmap)
+            self._buffers.append(memoryview(mmap))
+
+        self._file_idx += self._n_chunks
+        n_all_blocks = self._n_chunks * self._n_blocks
+
+        self._block_idxs = (
+            self._rng.permutation(n_all_blocks)
+            if self._shuffle
+            else range(n_all_blocks)
+        )
+
+        self._curr_idx = 0
+
+    def __del__(self):
+        self._close_mmaps()
+        del self._mmaps
+        del self._buffers
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self._curr_idx >= len(self._block_idxs):
+            self._load_n_chunks()
+            # TODO: trigger fetching next next n_chunks if remote
+        block_idx = self._block_idxs[self._curr_idx]
+        chunk_id = block_idx // self._n_blocks
+        buffer = self._buffers[chunk_id]
+        elem_id = (block_idx % self._n_blocks) * self._block_size
+        offset = np.dtype(self._dtype).itemsize * elem_id
+        arr = np.frombuffer(
+            buffer, dtype=self._dtype, count=self._block_size, offset=offset
+        )
+        self._curr_idx += 1
+        return torch.from_numpy(arr.astype(np.int64))
+
+
+class CombinedDataset(IterableDataset):
+    def __init__(self, datasets, seed, weights=None):
+        self._seed = seed
+        self._datasets = datasets
+        self._weights = weights
+        n_datasets = len(datasets)
+        if weights is None:
+            self._weights = [1 / n_datasets] * n_datasets
+
+    def __iter__(self):
+        return CombinedDatasetIterator(self._datasets, self._seed, self._weights)
+
+
+class CombinedDatasetIterator:
+    def __init__(self, datasets, seed, weights):
+        self._datasets = [iter(el) for el in datasets]
+        self._weights = weights
+        self._rng = random.Random(seed)
+
+    def __next__(self):
+        (dataset,) = self._rng.choices(self._datasets, weights=self._weights, k=1)
+        return next(dataset)
diff --git a/Journey/Day03/prepare_tinystories_zh.py b/Journey/Day03/prepare_tinystories_zh.py
new file mode 100644
index 0000000..5570d45
--- /dev/null
+++ b/Journey/Day03/prepare_tinystories_zh.py
@@ -0,0 +1,66 @@
+import glob
+import os
+import json
+from litgpt import Tokenizer
+from pathlib import Path
+from packed_dataset import PackedDatasetBuilder
+
+
+def prepare_dataset(
+    source_path: Path,
+    tokenizer_dir: Path,
+    destination_path: Path,
+    chunk_size: int,
+    match: str = "",
+) -> None:
+    """Prepare the "Red Pajama" dataset using the original tokenizer."""
+    import zstandard as zstd
+
+    destination_path.mkdir(parents=True, exist_ok=True)
+
+    tokenizer = Tokenizer(tokenizer_dir)
+
+    for set_name, pattern in filename_sets.items():
+        if match and match not in set_name:
+            continue
+
+        is_cc = set_name == "common_crawl"
+
+        filenames = glob.glob(os.path.join(source_path, pattern), recursive=True)
+
+        if not filenames:
+            raise RuntimeError(
+                f"No files matching {pattern} found at {source_path}. \nMake sure you download the data, e.g. wget -i"
+                " https://data.together.xyz/redpajama-data-1T/v1.0.0/urls.txt or through"
+                " \nhttps://huggingface.co/datasets/togethercomputer/RedPajama-Data-1T"
+                " \nhttps://huggingface.co/datasets/togethercomputer/RedPajama-Data-1T-Sample \n"
+            )
+
+        builder = PackedDatasetBuilder(
+            outdir=destination_path,
+            prefix=set_name,
+            chunk_size=chunk_size,
+            sep_token=tokenizer.eos_id,
+            dtype="auto",
+            vocab_size=tokenizer.vocab_size,
+        )
+
+        for name in filenames:
+            filepath = source_path / name
+
+            print(f"Processing {name}")
+
+            if is_cc:
+                with zstd.open(open(filepath, "rb"), "rt", encoding="utf-8") as f:
+                    for row in tqdm(f):
+                        text = json.loads(row)["text"]
+                        text_ids = tokenizer.encode(text)
+                        builder.add_array(np.array(text_ids, dtype=builder.dtype))
+            else:
+                with open(filepath, encoding="utf-8") as f:
+                    for row in tqdm(f):
+                        text = json.loads(row)["text"]
+                        text_ids = tokenizer.encode(text)
+                        builder.add_array(np.array(text_ids, dtype=builder.dtype))
+
+        builder.write_reminder()
diff --git a/References/chatglm3-6b b/References/chatglm3-6b
new file mode 160000
index 0000000..91a0561
--- /dev/null
+++ b/References/chatglm3-6b
@@ -0,0 +1 @@
+Subproject commit 91a0561caa089280e94bf26a9fc3530482f0fe60