Upload folder using huggingface_hub

chatglm3-6b/lora/sft-ruozhiba/README.md

@@ -0,0 +1,62 @@
+---
+license: other
+library_name: peft
+tags:
+- sft-tools
+- lora
+- generated_from_trainer
+base_model: THUDM/chatglm3-6b
+model-index:
+- name: sft-ruozhiba
+  results: []
+---
+
+<!-- This model card has been generated automatically according to the information the Trainer had access to. You
+should probably proofread and complete it, then remove this comment. -->
+
+# sft-ruozhiba
+
+This model is a fine-tuned version of [THUDM/chatglm3-6b](https://huggingface.co/THUDM/chatglm3-6b) on the ruozhiba_identity and the ruozhiba datasets.
+It achieves the following results on the evaluation set:
+- Loss: 1.5318
+
+## Model description
+
+More information needed
+
+## Intended uses & limitations
+
+More information needed
+
+## Training and evaluation data
+
+More information needed
+
+## Training procedure
+
+### Training hyperparameters
+
+The following hyperparameters were used during training:
+- learning_rate: 5e-05
+- train_batch_size: 2
+- eval_batch_size: 1
+- seed: 42
+- gradient_accumulation_steps: 4
+- total_train_batch_size: 8
+- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
+- lr_scheduler_type: cosine
+- lr_scheduler_warmup_steps: 0.1
+- num_epochs: 4.0
+- mixed_precision_training: Native AMP
+
+### Training results
+
+
+
+### Framework versions
+
+- PEFT 0.11.1
+- Transformers 4.39.3
+- Pytorch 2.1.2
+- Datasets 2.18.0
+- Tokenizers 0.15.2

chatglm3-6b/lora/sft-ruozhiba/adapter_config.json

@@ -0,0 +1,31 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": "THUDM/chatglm3-6b",
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 16,
+  "lora_dropout": 0.0,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 8,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "dense",
+    "dense_h_to_4h",
+    "query_key_value",
+    "dense_4h_to_h"
+  ],
+  "task_type": "CAUSAL_LM",
+  "use_dora": false,
+  "use_rslora": false
+}

chatglm3-6b/lora/sft-ruozhiba/adapter_model.safetensors

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

chatglm3-6b/lora/sft-ruozhiba/all_results.json

@@ -0,0 +1,11 @@
+{
+    "epoch": 3.98,
+    "eval_loss": 1.531842589378357,
+    "eval_runtime": 12.5881,
+    "eval_samples_per_second": 8.738,
+    "eval_steps_per_second": 8.738,
+    "train_loss": 1.5705121149782275,
+    "train_runtime": 3078.3762,
+    "train_samples_per_second": 1.276,
+    "train_steps_per_second": 0.159
+}

chatglm3-6b/lora/sft-ruozhiba/eval_results.json

@@ -0,0 +1,7 @@
+{
+    "epoch": 3.98,
+    "eval_loss": 1.531842589378357,
+    "eval_runtime": 12.5881,
+    "eval_samples_per_second": 8.738,
+    "eval_steps_per_second": 8.738
+}

chatglm3-6b/lora/sft-ruozhiba/runs/May19_12-24-27_5cfc7f17b165/events.out.tfevents.1716121557.5cfc7f17b165.181.0

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

chatglm3-6b/lora/sft-ruozhiba/runs/May19_12-24-27_5cfc7f17b165/events.out.tfevents.1716124649.5cfc7f17b165.181.1

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

chatglm3-6b/lora/sft-ruozhiba/special_tokens_map.json

@@ -0,0 +1,18 @@
+{
+  "additional_special_tokens": [
+    {
+      "content": "<|user|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<|observation|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    }
+  ]
+}

chatglm3-6b/lora/sft-ruozhiba/tokenization_chatglm.py

@@ -0,0 +1,328 @@
+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

chatglm3-6b/lora/sft-ruozhiba/tokenizer.model

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

chatglm3-6b/lora/sft-ruozhiba/tokenizer_config.json

@@ -0,0 +1,65 @@
+{
+  "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": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "64796": {
+      "content": "<|assistant|>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "64797": {
+      "content": "<|observation|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "additional_special_tokens": [
+    "<|user|>",
+    "<|observation|>"
+  ],
+  "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": "right",
+  "remove_space": false,
+  "split_special_tokens": false,
+  "tokenizer_class": "ChatGLMTokenizer",
+  "unk_token": "<unk>"
+}

chatglm3-6b/lora/sft-ruozhiba/train_results.json

@@ -0,0 +1,7 @@
+{
+    "epoch": 3.98,
+    "train_loss": 1.5705121149782275,
+    "train_runtime": 3078.3762,
+    "train_samples_per_second": 1.276,
+    "train_steps_per_second": 0.159
+}

chatglm3-6b/lora/sft-ruozhiba/trainer_log.jsonl

@@ -0,0 +1,49 @@
+{"current_steps": 10, "total_steps": 488, "loss": 2.5464, "learning_rate": 4.994922248529205e-05, "epoch": 0.08, "percentage": 2.05, "elapsed_time": "0:00:59", "remaining_time": "0:47:30"}
+{"current_steps": 20, "total_steps": 488, "loss": 2.4707, "learning_rate": 4.9795044312909347e-05, "epoch": 0.16, "percentage": 4.1, "elapsed_time": "0:02:00", "remaining_time": "0:46:53"}
+{"current_steps": 30, "total_steps": 488, "loss": 2.4142, "learning_rate": 4.9538099315089056e-05, "epoch": 0.24, "percentage": 6.15, "elapsed_time": "0:03:01", "remaining_time": "0:46:11"}
+{"current_steps": 40, "total_steps": 488, "loss": 2.1245, "learning_rate": 4.9179452439382994e-05, "epoch": 0.33, "percentage": 8.2, "elapsed_time": "0:04:05", "remaining_time": "0:45:45"}
+{"current_steps": 50, "total_steps": 488, "loss": 2.0647, "learning_rate": 4.872059015221584e-05, "epoch": 0.41, "percentage": 10.25, "elapsed_time": "0:05:08", "remaining_time": "0:45:02"}
+{"current_steps": 60, "total_steps": 488, "loss": 1.9556, "learning_rate": 4.8163414277999356e-05, "epoch": 0.49, "percentage": 12.3, "elapsed_time": "0:06:13", "remaining_time": "0:44:24"}
+{"current_steps": 70, "total_steps": 488, "loss": 1.8587, "learning_rate": 4.751023411673241e-05, "epoch": 0.57, "percentage": 14.34, "elapsed_time": "0:07:17", "remaining_time": "0:43:32"}
+{"current_steps": 80, "total_steps": 488, "loss": 1.8275, "learning_rate": 4.6763756872756525e-05, "epoch": 0.65, "percentage": 16.39, "elapsed_time": "0:08:21", "remaining_time": "0:42:39"}
+{"current_steps": 90, "total_steps": 488, "loss": 1.83, "learning_rate": 4.59270764343365e-05, "epoch": 0.73, "percentage": 18.44, "elapsed_time": "0:09:26", "remaining_time": "0:41:44"}
+{"current_steps": 100, "total_steps": 488, "loss": 1.751, "learning_rate": 4.500366055057077e-05, "epoch": 0.81, "percentage": 20.49, "elapsed_time": "0:10:31", "remaining_time": "0:40:50"}
+{"current_steps": 110, "total_steps": 488, "loss": 1.7397, "learning_rate": 4.3997336458778874e-05, "epoch": 0.9, "percentage": 22.54, "elapsed_time": "0:11:34", "remaining_time": "0:39:47"}
+{"current_steps": 120, "total_steps": 488, "loss": 1.74, "learning_rate": 4.2912275021935244e-05, "epoch": 0.98, "percentage": 24.59, "elapsed_time": "0:12:39", "remaining_time": "0:38:48"}
+{"current_steps": 130, "total_steps": 488, "loss": 1.6727, "learning_rate": 4.1752973441894504e-05, "epoch": 1.06, "percentage": 26.64, "elapsed_time": "0:13:42", "remaining_time": "0:37:44"}
+{"current_steps": 140, "total_steps": 488, "loss": 1.5492, "learning_rate": 4.052423662005558e-05, "epoch": 1.14, "percentage": 28.69, "elapsed_time": "0:14:48", "remaining_time": "0:36:49"}
+{"current_steps": 150, "total_steps": 488, "loss": 1.6558, "learning_rate": 3.923115724271841e-05, "epoch": 1.22, "percentage": 30.74, "elapsed_time": "0:15:49", "remaining_time": "0:35:39"}
+{"current_steps": 160, "total_steps": 488, "loss": 1.5154, "learning_rate": 3.78790946736724e-05, "epoch": 1.3, "percentage": 32.79, "elapsed_time": "0:16:55", "remaining_time": "0:34:42"}
+{"current_steps": 170, "total_steps": 488, "loss": 1.6066, "learning_rate": 3.647365274149962e-05, "epoch": 1.38, "percentage": 34.84, "elapsed_time": "0:17:58", "remaining_time": "0:33:36"}
+{"current_steps": 180, "total_steps": 488, "loss": 1.6032, "learning_rate": 3.502065651365643e-05, "epoch": 1.47, "percentage": 36.89, "elapsed_time": "0:19:04", "remaining_time": "0:32:37"}
+{"current_steps": 190, "total_steps": 488, "loss": 1.5316, "learning_rate": 3.3526128153597086e-05, "epoch": 1.55, "percentage": 38.93, "elapsed_time": "0:20:06", "remaining_time": "0:31:32"}
+{"current_steps": 200, "total_steps": 488, "loss": 1.5697, "learning_rate": 3.1996261961003084e-05, "epoch": 1.63, "percentage": 40.98, "elapsed_time": "0:21:13", "remaining_time": "0:30:33"}
+{"current_steps": 210, "total_steps": 488, "loss": 1.5249, "learning_rate": 3.043739869856768e-05, "epoch": 1.71, "percentage": 43.03, "elapsed_time": "0:22:15", "remaining_time": "0:29:27"}
+{"current_steps": 220, "total_steps": 488, "loss": 1.5295, "learning_rate": 2.8855999311742328e-05, "epoch": 1.79, "percentage": 45.08, "elapsed_time": "0:23:19", "remaining_time": "0:28:24"}
+{"current_steps": 230, "total_steps": 488, "loss": 1.5792, "learning_rate": 2.7258618150367328e-05, "epoch": 1.87, "percentage": 47.13, "elapsed_time": "0:24:20", "remaining_time": "0:27:17"}
+{"current_steps": 240, "total_steps": 488, "loss": 1.4859, "learning_rate": 2.5651875803173912e-05, "epoch": 1.96, "percentage": 49.18, "elapsed_time": "0:25:23", "remaining_time": "0:26:14"}
+{"current_steps": 250, "total_steps": 488, "loss": 1.5071, "learning_rate": 2.4042431657749117e-05, "epoch": 2.04, "percentage": 51.23, "elapsed_time": "0:26:24", "remaining_time": "0:25:08"}
+{"current_steps": 260, "total_steps": 488, "loss": 1.3746, "learning_rate": 2.2436956299692906e-05, "epoch": 2.12, "percentage": 53.28, "elapsed_time": "0:27:27", "remaining_time": "0:24:04"}
+{"current_steps": 270, "total_steps": 488, "loss": 1.5165, "learning_rate": 2.084210386536349e-05, "epoch": 2.2, "percentage": 55.33, "elapsed_time": "0:28:28", "remaining_time": "0:22:59"}
+{"current_steps": 280, "total_steps": 488, "loss": 1.4035, "learning_rate": 1.926448446279894e-05, "epoch": 2.28, "percentage": 57.38, "elapsed_time": "0:29:30", "remaining_time": "0:21:55"}
+{"current_steps": 290, "total_steps": 488, "loss": 1.4952, "learning_rate": 1.7710636775120946e-05, "epoch": 2.36, "percentage": 59.43, "elapsed_time": "0:30:33", "remaining_time": "0:20:52"}
+{"current_steps": 300, "total_steps": 488, "loss": 1.3679, "learning_rate": 1.6187000959969926e-05, "epoch": 2.44, "percentage": 61.48, "elapsed_time": "0:31:34", "remaining_time": "0:19:47"}
+{"current_steps": 310, "total_steps": 488, "loss": 1.348, "learning_rate": 1.469989195729396e-05, "epoch": 2.53, "percentage": 63.52, "elapsed_time": "0:32:32", "remaining_time": "0:18:40"}
+{"current_steps": 320, "total_steps": 488, "loss": 1.4076, "learning_rate": 1.3255473316121486e-05, "epoch": 2.61, "percentage": 65.57, "elapsed_time": "0:33:36", "remaining_time": "0:17:38"}
+{"current_steps": 330, "total_steps": 488, "loss": 1.37, "learning_rate": 1.1859731648796588e-05, "epoch": 2.69, "percentage": 67.62, "elapsed_time": "0:34:39", "remaining_time": "0:16:35"}
+{"current_steps": 340, "total_steps": 488, "loss": 1.351, "learning_rate": 1.0518451818555322e-05, "epoch": 2.77, "percentage": 69.67, "elapsed_time": "0:35:37", "remaining_time": "0:15:30"}
+{"current_steps": 350, "total_steps": 488, "loss": 1.3333, "learning_rate": 9.237192963281768e-06, "epoch": 2.85, "percentage": 71.72, "elapsed_time": "0:36:42", "remaining_time": "0:14:28"}
+{"current_steps": 360, "total_steps": 488, "loss": 1.3649, "learning_rate": 8.021265454817112e-06, "epoch": 2.93, "percentage": 73.77, "elapsed_time": "0:37:42", "remaining_time": "0:13:24"}
+{"current_steps": 370, "total_steps": 488, "loss": 1.3476, "learning_rate": 6.875708889317353e-06, "epoch": 3.01, "percentage": 75.82, "elapsed_time": "0:38:44", "remaining_time": "0:12:21"}
+{"current_steps": 380, "total_steps": 488, "loss": 1.277, "learning_rate": 5.8052711998819395e-06, "epoch": 3.1, "percentage": 77.87, "elapsed_time": "0:39:41", "remaining_time": "0:11:16"}
+{"current_steps": 390, "total_steps": 488, "loss": 1.3065, "learning_rate": 4.814388978024237e-06, "epoch": 3.18, "percentage": 79.92, "elapsed_time": "0:40:42", "remaining_time": "0:10:13"}
+{"current_steps": 400, "total_steps": 488, "loss": 1.2941, "learning_rate": 3.907169085544424e-06, "epoch": 3.26, "percentage": 81.97, "elapsed_time": "0:41:41", "remaining_time": "0:09:10"}
+{"current_steps": 410, "total_steps": 488, "loss": 1.33, "learning_rate": 3.0873716330173356e-06, "epoch": 3.34, "percentage": 84.02, "elapsed_time": "0:42:47", "remaining_time": "0:08:08"}
+{"current_steps": 420, "total_steps": 488, "loss": 1.2729, "learning_rate": 2.3583943954432725e-06, "epoch": 3.42, "percentage": 86.07, "elapsed_time": "0:43:50", "remaining_time": "0:07:05"}
+{"current_steps": 430, "total_steps": 488, "loss": 1.3031, "learning_rate": 1.7232587296537233e-06, "epoch": 3.5, "percentage": 88.11, "elapsed_time": "0:44:52", "remaining_time": "0:06:03"}
+{"current_steps": 440, "total_steps": 488, "loss": 1.2636, "learning_rate": 1.1845970518392591e-06, "epoch": 3.58, "percentage": 90.16, "elapsed_time": "0:45:50", "remaining_time": "0:05:00"}
+{"current_steps": 450, "total_steps": 488, "loss": 1.2348, "learning_rate": 7.446419271010113e-07, "epoch": 3.67, "percentage": 92.21, "elapsed_time": "0:46:51", "remaining_time": "0:03:57"}
+{"current_steps": 460, "total_steps": 488, "loss": 1.3258, "learning_rate": 4.0521681624565434e-07, "epoch": 3.75, "percentage": 94.26, "elapsed_time": "0:48:02", "remaining_time": "0:02:55"}
+{"current_steps": 470, "total_steps": 488, "loss": 1.3038, "learning_rate": 1.6772851817526414e-07, "epoch": 3.83, "percentage": 96.31, "elapsed_time": "0:49:07", "remaining_time": "0:01:52"}
+{"current_steps": 480, "total_steps": 488, "loss": 1.342, "learning_rate": 3.3161339195697526e-08, "epoch": 3.91, "percentage": 98.36, "elapsed_time": "0:50:10", "remaining_time": "0:00:50"}
+{"current_steps": 488, "total_steps": 488, "epoch": 3.98, "percentage": 100.0, "elapsed_time": "0:51:01", "remaining_time": "0:00:00"}

chatglm3-6b/lora/sft-ruozhiba/trainer_state.json

@@ -0,0 +1,366 @@
+{
+  "best_metric": null,
+  "best_model_checkpoint": null,
+  "epoch": 3.975560081466395,
+  "eval_steps": 500,
+  "global_step": 488,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 0.08,
+      "grad_norm": 0.917630672454834,
+      "learning_rate": 4.994922248529205e-05,
+      "loss": 2.5464,
+      "step": 10
+    },
+    {
+      "epoch": 0.16,
+      "grad_norm": 1.4127905368804932,
+      "learning_rate": 4.9795044312909347e-05,
+      "loss": 2.4707,
+      "step": 20
+    },
+    {
+      "epoch": 0.24,
+      "grad_norm": 1.5394383668899536,
+      "learning_rate": 4.9538099315089056e-05,
+      "loss": 2.4142,
+      "step": 30
+    },
+    {
+      "epoch": 0.33,
+      "grad_norm": 1.3929855823516846,
+      "learning_rate": 4.9179452439382994e-05,
+      "loss": 2.1245,
+      "step": 40
+    },
+    {
+      "epoch": 0.41,
+      "grad_norm": 1.5902705192565918,
+      "learning_rate": 4.872059015221584e-05,
+      "loss": 2.0647,
+      "step": 50
+    },
+    {
+      "epoch": 0.49,
+      "grad_norm": 1.7802547216415405,
+      "learning_rate": 4.8163414277999356e-05,
+      "loss": 1.9556,
+      "step": 60
+    },
+    {
+      "epoch": 0.57,
+      "grad_norm": 1.5567349195480347,
+      "learning_rate": 4.751023411673241e-05,
+      "loss": 1.8587,
+      "step": 70
+    },
+    {
+      "epoch": 0.65,
+      "grad_norm": 1.3391444683074951,
+      "learning_rate": 4.6763756872756525e-05,
+      "loss": 1.8275,
+      "step": 80
+    },
+    {
+      "epoch": 0.73,
+      "grad_norm": 1.4643337726593018,
+      "learning_rate": 4.59270764343365e-05,
+      "loss": 1.83,
+      "step": 90
+    },
+    {
+      "epoch": 0.81,
+      "grad_norm": 1.537935733795166,
+      "learning_rate": 4.500366055057077e-05,
+      "loss": 1.751,
+      "step": 100
+    },
+    {
+      "epoch": 0.9,
+      "grad_norm": 1.5327485799789429,
+      "learning_rate": 4.3997336458778874e-05,
+      "loss": 1.7397,
+      "step": 110
+    },
+    {
+      "epoch": 0.98,
+      "grad_norm": 1.2399487495422363,
+      "learning_rate": 4.2912275021935244e-05,
+      "loss": 1.74,
+      "step": 120
+    },
+    {
+      "epoch": 1.06,
+      "grad_norm": 1.7062827348709106,
+      "learning_rate": 4.1752973441894504e-05,
+      "loss": 1.6727,
+      "step": 130
+    },
+    {
+      "epoch": 1.14,
+      "grad_norm": 1.4249871969223022,
+      "learning_rate": 4.052423662005558e-05,
+      "loss": 1.5492,
+      "step": 140
+    },
+    {
+      "epoch": 1.22,
+      "grad_norm": 1.435344934463501,
+      "learning_rate": 3.923115724271841e-05,
+      "loss": 1.6558,
+      "step": 150
+    },
+    {
+      "epoch": 1.3,
+      "grad_norm": 1.6837048530578613,
+      "learning_rate": 3.78790946736724e-05,
+      "loss": 1.5154,
+      "step": 160
+    },
+    {
+      "epoch": 1.38,
+      "grad_norm": 1.6067469120025635,
+      "learning_rate": 3.647365274149962e-05,
+      "loss": 1.6066,
+      "step": 170
+    },
+    {
+      "epoch": 1.47,
+      "grad_norm": 1.7231266498565674,
+      "learning_rate": 3.502065651365643e-05,
+      "loss": 1.6032,
+      "step": 180
+    },
+    {
+      "epoch": 1.55,
+      "grad_norm": 2.0479469299316406,
+      "learning_rate": 3.3526128153597086e-05,
+      "loss": 1.5316,
+      "step": 190
+    },
+    {
+      "epoch": 1.63,
+      "grad_norm": 1.8524290323257446,
+      "learning_rate": 3.1996261961003084e-05,
+      "loss": 1.5697,
+      "step": 200
+    },
+    {
+      "epoch": 1.71,
+      "grad_norm": 1.7942742109298706,
+      "learning_rate": 3.043739869856768e-05,
+      "loss": 1.5249,
+      "step": 210
+    },
+    {
+      "epoch": 1.79,
+      "grad_norm": 1.4377387762069702,
+      "learning_rate": 2.8855999311742328e-05,
+      "loss": 1.5295,
+      "step": 220
+    },
+    {
+      "epoch": 1.87,
+      "grad_norm": 1.591834306716919,
+      "learning_rate": 2.7258618150367328e-05,
+      "loss": 1.5792,
+      "step": 230
+    },
+    {
+      "epoch": 1.96,
+      "grad_norm": 2.633655071258545,
+      "learning_rate": 2.5651875803173912e-05,
+      "loss": 1.4859,
+      "step": 240
+    },
+    {
+      "epoch": 2.04,
+      "grad_norm": 1.6626724004745483,
+      "learning_rate": 2.4042431657749117e-05,
+      "loss": 1.5071,
+      "step": 250
+    },
+    {
+      "epoch": 2.12,
+      "grad_norm": 1.819585919380188,
+      "learning_rate": 2.2436956299692906e-05,
+      "loss": 1.3746,
+      "step": 260
+    },
+    {
+      "epoch": 2.2,
+      "grad_norm": 1.9247617721557617,
+      "learning_rate": 2.084210386536349e-05,
+      "loss": 1.5165,
+      "step": 270
+    },
+    {
+      "epoch": 2.28,
+      "grad_norm": 2.381666898727417,
+      "learning_rate": 1.926448446279894e-05,
+      "loss": 1.4035,
+      "step": 280
+    },
+    {
+      "epoch": 2.36,
+      "grad_norm": 2.1338634490966797,
+      "learning_rate": 1.7710636775120946e-05,
+      "loss": 1.4952,
+      "step": 290
+    },
+    {
+      "epoch": 2.44,
+      "grad_norm": 1.8547377586364746,
+      "learning_rate": 1.6187000959969926e-05,
+      "loss": 1.3679,
+      "step": 300
+    },
+    {
+      "epoch": 2.53,
+      "grad_norm": 1.9622243642807007,
+      "learning_rate": 1.469989195729396e-05,
+      "loss": 1.348,
+      "step": 310
+    },
+    {
+      "epoch": 2.61,
+      "grad_norm": 2.2169859409332275,
+      "learning_rate": 1.3255473316121486e-05,
+      "loss": 1.4076,
+      "step": 320
+    },
+    {
+      "epoch": 2.69,
+      "grad_norm": 1.745296835899353,
+      "learning_rate": 1.1859731648796588e-05,
+      "loss": 1.37,
+      "step": 330
+    },
+    {
+      "epoch": 2.77,
+      "grad_norm": 2.050562858581543,
+      "learning_rate": 1.0518451818555322e-05,
+      "loss": 1.351,
+      "step": 340
+    },
+    {
+      "epoch": 2.85,
+      "grad_norm": 2.3423192501068115,
+      "learning_rate": 9.237192963281768e-06,
+      "loss": 1.3333,
+      "step": 350
+    },
+    {
+      "epoch": 2.93,
+      "grad_norm": 2.36187744140625,
+      "learning_rate": 8.021265454817112e-06,
+      "loss": 1.3649,
+      "step": 360
+    },
+    {
+      "epoch": 3.01,
+      "grad_norm": 2.3094940185546875,
+      "learning_rate": 6.875708889317353e-06,
+      "loss": 1.3476,
+      "step": 370
+    },
+    {
+      "epoch": 3.1,
+      "grad_norm": 2.6048502922058105,
+      "learning_rate": 5.8052711998819395e-06,
+      "loss": 1.277,
+      "step": 380
+    },
+    {
+      "epoch": 3.18,
+      "grad_norm": 2.370173215866089,
+      "learning_rate": 4.814388978024237e-06,
+      "loss": 1.3065,
+      "step": 390
+    },
+    {
+      "epoch": 3.26,
+      "grad_norm": 2.1737473011016846,
+      "learning_rate": 3.907169085544424e-06,
+      "loss": 1.2941,
+      "step": 400
+    },
+    {
+      "epoch": 3.34,
+      "grad_norm": 2.18640398979187,
+      "learning_rate": 3.0873716330173356e-06,
+      "loss": 1.33,
+      "step": 410
+    },
+    {
+      "epoch": 3.42,
+      "grad_norm": 3.3506879806518555,
+      "learning_rate": 2.3583943954432725e-06,
+      "loss": 1.2729,
+      "step": 420
+    },
+    {
+      "epoch": 3.5,
+      "grad_norm": 1.9210536479949951,
+      "learning_rate": 1.7232587296537233e-06,
+      "loss": 1.3031,
+      "step": 430
+    },
+    {
+      "epoch": 3.58,
+      "grad_norm": 1.9734101295471191,
+      "learning_rate": 1.1845970518392591e-06,
+      "loss": 1.2636,
+      "step": 440
+    },
+    {
+      "epoch": 3.67,
+      "grad_norm": 1.9752649068832397,
+      "learning_rate": 7.446419271010113e-07,
+      "loss": 1.2348,
+      "step": 450
+    },
+    {
+      "epoch": 3.75,
+      "grad_norm": 1.8863799571990967,
+      "learning_rate": 4.0521681624565434e-07,
+      "loss": 1.3258,
+      "step": 460
+    },
+    {
+      "epoch": 3.83,
+      "grad_norm": 2.084764242172241,
+      "learning_rate": 1.6772851817526414e-07,
+      "loss": 1.3038,
+      "step": 470
+    },
+    {
+      "epoch": 3.91,
+      "grad_norm": 2.2681760787963867,
+      "learning_rate": 3.3161339195697526e-08,
+      "loss": 1.342,
+      "step": 480
+    },
+    {
+      "epoch": 3.98,
+      "step": 488,
+      "total_flos": 1.368665285492736e+16,
+      "train_loss": 1.5705121149782275,
+      "train_runtime": 3078.3762,
+      "train_samples_per_second": 1.276,
+      "train_steps_per_second": 0.159
+    }
+  ],
+  "logging_steps": 10,
+  "max_steps": 488,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 4,
+  "save_steps": 500,
+  "total_flos": 1.368665285492736e+16,
+  "train_batch_size": 2,
+  "trial_name": null,
+  "trial_params": null
+}

chatglm3-6b/lora/sft-ruozhiba/training_args.bin

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