Add instruction data from belle (#5718)

wjx-sudo · web-flow · commit 8fb58ebd6f8c · 2023-04-24T16:11:58.000+08:00
* Add instruction data from belle

* add databuilder

* resolve some question

* fix oom &amp; belle url

* fix prediction_loss_only
diff --git a/examples/language_model/glm/data.py b/examples/language_model/glm/data.py
@@ -15,6 +15,55 @@
 import numpy as np
 
 
+def custom_instruction_convert_example(example, tokenizer, data_args, is_test=True, is_do_generation=False):
+    instruction = ""
+    input = ""
+    output = ""
+    if "instruction" in example and "output" in example:
+        instruction = example["instruction"]
+        output = example["output"]
+    else:
+        assert False, "instruction and output are not in the input dictionary."
+    if "input" in example["input"]:
+        input = example["input"]
+
+    if "chat" in data_args.task_name:
+        example["text_a"] = instruction + input
+    else:
+        example["text_a"] = "Human: " + instruction + input + "\n Assistant: "
+    example["text_b"] = output
+    inputs = tokenizer.encode(example["text_a"], max_length=data_args.src_length - 1, truncation=True)
+    inputs["input_ids"] = inputs["input_ids"][:-1] + [tokenizer.gmask_token_id] + inputs["input_ids"][-1:]
+    pad_length = data_args.src_length - len(inputs["input_ids"])
+    inputs["input_ids"] = np.array([inputs["input_ids"] + [tokenizer.pad_token_id] * pad_length])
+    inputs["attention_mask"] = np.array([inputs["attention_mask"] + [1] + [0] * pad_length])
+    sep = inputs["input_ids"].shape[1]
+
+    inputs = tokenizer.build_inputs_for_generation(
+        inputs,
+        max_gen_length=data_args.tgt_length,
+        targets=" " + example["text_b"] if not is_test or not is_do_generation else None,
+        padding="max_length",
+    )
+    for input_name in inputs.keys():
+        inputs[input_name] = inputs[input_name].squeeze(0)
+    if is_test:
+        inputs["position_ids"] = inputs["position_ids"][:, : inputs["input_ids"].shape[-1]]
+        labels = tokenizer.encode(
+            " " + example["text_b"], add_special_tokens=False, max_length=data_args.tgt_length - 1
+        )["input_ids"]
+        loss_mask = [0] * sep + [1] * len(labels) + [0] * (data_args.tgt_length - len(labels))
+        labels = (
+            [0] * sep
+            + labels
+            + [tokenizer.eop_token_id]
+            + [tokenizer.pad_token_id] * (data_args.tgt_length - len(labels) - 1)
+        )
+        inputs["label_ids"] = labels
+        inputs["loss_mask"] = loss_mask
+    return inputs
+
+
 def custom_convert_example(example, tokenizer, data_args, is_test=True):
     source = None
     title = None
diff --git a/examples/language_model/glm/finetune_instruction_generation.py b/examples/language_model/glm/finetune_instruction_generation.py
@@ -0,0 +1,162 @@
+# Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from dataclasses import dataclass, field
+from functools import partial
+
+import paddle
+from data import custom_instruction_convert_example
+from utils import GLMTrainer
+
+from paddlenlp.data import DefaultDataCollator
+from paddlenlp.datasets import load_dataset
+from paddlenlp.layers import LoRAConfig, LoRAModel
+from paddlenlp.trainer import PdArgumentParser, TrainingArguments, get_last_checkpoint
+from paddlenlp.transformers import AutoModelForConditionalGeneration, AutoTokenizer
+from paddlenlp.utils.log import logger
+
+
+@dataclass
+class DataArgument:
+    task_name: str = field(default="school_math_0.25M", metadata={"help": "The name of task."})
+    data_name: str = field(default="bellegroup", metadata={"help": "The name of data."})
+    src_length: int = field(default=608, metadata={"help": "The max length of source text."})
+    tgt_length: int = field(default=160, metadata={"help": "The max length of target text."})
+    min_tgt_length: int = field(default=55, metadata={"help": "The min length of target text."})
+    length_penalty: float = field(default=0.7, metadata={"help": "The length penalty."})
+    no_repeat_ngram_size: int = field(default=3, metadata={"help": "The no repeat ngram size."})
+    num_beams: int = field(default=5, metadata={"help": "The number of beams."})
+    select_topk: bool = field(default=True, metadata={"help": "Whether to select top k tokens for generation."})
+    top_p: float = field(
+        default=0.0, metadata={"help": "The cumulative probability for top-p-filtering in the 'sampling' strategy."}
+    )
+    top_k: int = field(
+        default=0,
+        metadata={
+            "help": "The number of highest probability tokens to keep for top-k-filtering in the 'sampling' strategy."
+        },
+    )
+    no_block_position: bool = field(default=False)
+
+
+@dataclass
+class ModelArgument:
+    model_name_or_path: str = field(
+        default="THUDM/glm-2b", metadata={"help": "Build-in pretrained model name or the path to local model."}
+    )
+    label_smoothing: float = field(default=0.1, metadata={"help": "The label smoothing parameter."})
+    lr_decay_ratio: float = field(default=0.1, metadata={"help": "The ratio for learning rate decrease"})
+    lora: bool = field(default=False, metadata={"help": "Whether to use LoRA technique"})
+
+
+def main():
+    parser = PdArgumentParser((ModelArgument, DataArgument, TrainingArguments))
+    model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    training_args.print_config(model_args, "Model")
+    training_args.print_config(data_args, "Data")
+    setattr(training_args, "label_smoothing", model_args.label_smoothing)
+    setattr(training_args, "lr_decay_ratio", model_args.lr_decay_ratio)
+
+    paddle.set_device(training_args.device)
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, world_size: {training_args.world_size}, "
+        + f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16 or training_args.bf16}"
+    )
+
+    # Detecting last checkpoint.
+    last_checkpoint = None
+    if os.path.isdir(training_args.output_dir) and training_args.do_train and not training_args.overwrite_output_dir:
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 1:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif last_checkpoint is not None and training_args.resume_from_checkpoint is None:
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    dtype = None
+    if training_args.fp16_opt_level == "O2":
+        if training_args.fp16:
+            dtype = "float16"
+        if training_args.bf16:
+            dtype = "bfloat16"
+
+    # Load the pretrained language model.
+    model = AutoModelForConditionalGeneration.from_pretrained(
+        model_args.model_name_or_path,
+        output_predict=True,
+        parallel_output=True,
+        load_state_as_np=True,
+        dtype=dtype,  # todo enable set dtype to avoid additional mem usage
+        tensor_parallel_degree=training_args.tensor_parallel_degree,
+        tensor_parallel_rank=training_args.tensor_parallel_rank,
+    )
+    if model_args.lora:
+        # TODO: hardcode parameters for now. Change after MergedLoRA is introduced
+        lora_config = LoRAConfig(
+            target_modules=[".*query_key_value.*"],
+            r=4,
+            lora_alpha=8,
+            merge_weights=True,
+            enable_lora_list=[[True, False, True]],
+            tensor_parallel_degree=training_args.tensor_parallel_degree,
+        )
+        model = LoRAModel(model, lora_config)
+        model.mark_only_lora_as_trainable()
+        model.print_trainable_parameters()
+
+    tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path)
+
+    # Load the dataset.
+    train_ds, dev_ds = load_dataset(data_args.data_name, data_args.task_name, splits=["train", "dev"])
+
+    trans_func = partial(custom_instruction_convert_example, tokenizer=tokenizer, data_args=data_args)
+    train_ds = train_ds.map(partial(trans_func, is_test=False, is_do_generation=False))
+    test_ds = dev_ds.map(partial(trans_func, is_do_generation=False))
+    collate_fn = DefaultDataCollator()
+
+    trainer = GLMTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_ds,
+        eval_dataset=dev_ds,
+        tokenizer=tokenizer,
+        do_generation=False,
+        data_collator=collate_fn,
+    )
+    if training_args.fp16_opt_level == "O2":
+        trainer.disable_autocast_context_manager()
+
+    if training_args.do_train:
+        train_result = trainer.train(resume_from_checkpoint=last_checkpoint)
+        trainer.save_model(merge_tensor_parallel=training_args.tensor_parallel_degree > 1)
+        trainer.log_metrics("train", train_result.metrics)
+        trainer.save_metrics("train", train_result.metrics)
+        trainer.save_state()
+
+    if training_args.do_eval:
+        eval_result = trainer.evaluate(test_ds)
+        trainer.log_metrics("test", eval_result)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/language_model/glm/utils.py b/examples/language_model/glm/utils.py
@@ -11,10 +11,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 from collections import UserDict
 from typing import Any, Dict, List, Optional, Tuple, Union
 
+import numpy as np
 import paddle
 import paddle.nn as nn
 from paddle import Tensor
@@ -91,6 +91,17 @@ def lr_lambda(current_step: int):
             self.lr_scheduler = LambdaDecay(self.args.learning_rate, lr_lambda, last_epoch=-1)
         return self.lr_scheduler
 
+    def log(self, logs: Dict[str, float], **kwargs) -> None:
+
+        if self.state.epoch is not None:
+            logs["epoch"] = round(self.state.epoch, 4)
+
+        if "eval_loss" in logs:
+            logs["eval_ppl"] = np.exp(logs["eval_loss"])
+        output = {**logs, **{"step": self.state.global_step}}
+        self.state.log_history.append(output)
+        self.control = self.callback_handler.on_log(self.args, self.state, self.control, logs, **kwargs)
+
 
 @paddle.no_grad()
 def generate(
diff --git a/paddlenlp/datasets/__init__.py b/paddlenlp/datasets/__init__.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from .bellegroup import *
 from .cail2018_small import *
 from .cblue import *
 from .chnsenticorp import *
diff --git a/paddlenlp/datasets/bellegroup.py b/paddlenlp/datasets/bellegroup.py
@@ -0,0 +1,108 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+
+from paddle.dataset.common import md5file
+from paddle.utils.download import get_path_from_url
+
+from ..utils.env import DATA_HOME
+from .dataset import DatasetBuilder
+
+__all__ = ["BelleGroup"]
+
+
+class BelleGroup(DatasetBuilder):
+    """
+    From https://github.com/LianjiaTech/BELLE/tree/main
+
+    """
+
+    BUILDER_CONFIGS = {
+        "generated_chat_0.4M": {
+            "url": "https://paddlenlp.bj.bcebos.com/datasets/BelleGroup/generated_chat_0.4M.zip",
+            "md5": "9bb71d4f2aa99acede2a0c3a8e761905",
+            "splits": {
+                "train": [os.path.join("generated_chat_0.4M", "train.json"), "47ea511025fbda9ffd6e5178677bb027"],
+                "dev": [os.path.join("generated_chat_0.4M", "dev.json"), "d7bd4b71cdb006b9de90ebb634ca1179"],
+            },
+        },
+        "school_math_0.25M": {
+            "url": "https://paddlenlp.bj.bcebos.com/datasets/BelleGroup/school_math_0.25M.zip",
+            "md5": "10076cbdc0a7436d55481f0234db8609",
+            "splits": {
+                "train": [os.path.join("school_math_0.25M", "train.json"), "e5a36fc9deb015254686c51e21528683"],
+                "dev": [os.path.join("school_math_0.25M", "dev.json"), "99e967c38e39ed919327c011d9f6288f"],
+            },
+        },
+        "train_2M_CN": {
+            "url": "https://paddlenlp.bj.bcebos.com/datasets/BelleGroup/train_2M_CN.zip",
+            "md5": "da88aca71eb9f454fab39db6a7e851e6",
+            "splits": {
+                "train": [os.path.join("train_2M_CN", "train.json"), "83e2917701a31ecf5152e4e9f234fcd0"],
+                "dev": [os.path.join("train_2M_CN", "dev.json"), "74f67f04e30896aeccc10930a7dc1f40"],
+            },
+        },
+        "train_1M_CN": {
+            "url": "https://paddlenlp.bj.bcebos.com/datasets/BelleGroup/train_1M_CN.zip",
+            "md5": "65380b542e8ddb4db8f8d2be0f28795c",
+            "splits": {
+                "train": [os.path.join("train_1M_CN.zip", "train.json"), "489886aba320c74a1fdfad43c652635b"],
+                "dev": [os.path.join("train_1M_CN.zip", "dev.json"), "7bbf382aeab89f4398b2beca984e20e8"],
+            },
+        },
+        "train_0.5M_CN": {
+            "url": "https://paddlenlp.bj.bcebos.com/datasets/BelleGroup/train_0.5M_CN.zip",
+            "md5": "45be55109ca9595efa36eaaed7c475d3",
+            "splits": {
+                "train": [os.path.join("train_0.5M_CN.zip", "train.json"), "61dc155956622c8389265de33b439757"],
+                "dev": [os.path.join("train_0.5M_CN.zip", "dev.json"), "72617388fbc4897cb2952df3e5303c2b"],
+            },
+        },
+        "multiturn_chat_0.8M": {
+            "url": "https://paddlenlp.bj.bcebos.com/datasets/BelleGroup/multiturn_chat_0.8M.zip",
+            "md5": "974bc42c5920e5722146a89dce2b10cc",
+            "splits": {
+                "train": [os.path.join("multiturn_chat_0.8M", "train.json"), "27e3a7ecff0f4a199f6e7119909988e9"],
+                "dev": [os.path.join("multiturn_chat_0.8M", "dev.json"), "8fec175ea5e71cc78498d8ca3c1d5e66"],
+            },
+        },
+    }
+
+    def _get_data(self, mode, **kwargs):
+        builder_config = self.BUILDER_CONFIGS[self.name]
+
+        default_root = os.path.join(DATA_HOME, self.__class__.__name__)
+        filename, data_hash = builder_config["splits"][mode]
+        fullname = os.path.join(default_root, filename)
+        if not os.path.exists(fullname) or (data_hash and not md5file(fullname) == data_hash):
+            get_path_from_url(builder_config["url"], default_root, builder_config["md5"])
+
+        return fullname
+
+    def _read(self, filename, *args):
+        with open(filename, "r", encoding="utf8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+
+                json_data = json.loads(line)
+
+                yield {
+                    "instruction": json_data["instruction"],
+                    "input": json_data["input"],
+                    "output": json_data["output"],
+                }
