Initial commit

LLaMA-Factory/src/llamafactory/train/test_utils.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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.
+
+from typing import TYPE_CHECKING, Dict, Optional, Sequence, Set, Tuple, Union
+
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM
+from trl import AutoModelForCausalLMWithValueHead
+
+from ..data import get_dataset, get_template_and_fix_tokenizer
+from ..extras.misc import get_current_device
+from ..hparams import get_infer_args, get_train_args
+from ..model import load_model, load_tokenizer
+
+
+if TYPE_CHECKING:
+    from datasets import Dataset
+    from peft import LoraModel
+    from transformers import PreTrainedModel
+
+
+def compare_model(model_a: "torch.nn.Module", model_b: "torch.nn.Module", diff_keys: Sequence[str] = []) -> None:
+    state_dict_a = model_a.state_dict()
+    state_dict_b = model_b.state_dict()
+    assert set(state_dict_a.keys()) == set(state_dict_b.keys())
+    for name in state_dict_a.keys():
+        if any(key in name for key in diff_keys):
+            assert torch.allclose(state_dict_a[name], state_dict_b[name], rtol=1e-4, atol=1e-5) is False
+        else:
+            assert torch.allclose(state_dict_a[name], state_dict_b[name], rtol=1e-4, atol=1e-5) is True
+
+
+def check_lora_model(model: "LoraModel") -> Tuple[Set[str], Set[str]]:
+    linear_modules, extra_modules = set(), set()
+    for name, param in model.named_parameters():
+        if any(module in name for module in ["lora_A", "lora_B"]):
+            linear_modules.add(name.split(".lora_", maxsplit=1)[0].split(".")[-1])
+            assert param.requires_grad is True
+            assert param.dtype == torch.float32
+        elif "modules_to_save" in name:
+            extra_modules.add(name.split(".modules_to_save", maxsplit=1)[0].split(".")[-1])
+            assert param.requires_grad is True
+            assert param.dtype == torch.float32
+        else:
+            assert param.requires_grad is False
+            assert param.dtype == torch.float16
+
+    return linear_modules, extra_modules
+
+
+def load_train_model(add_valuehead: bool = False, **kwargs) -> "PreTrainedModel":
+    model_args, _, _, finetuning_args, _ = get_train_args(kwargs)
+    tokenizer = load_tokenizer(model_args)["tokenizer"]
+    return load_model(tokenizer, model_args, finetuning_args, is_trainable=True, add_valuehead=add_valuehead)
+
+
+def load_infer_model(add_valuehead: bool = False, **kwargs) -> "PreTrainedModel":
+    model_args, _, finetuning_args, _ = get_infer_args(kwargs)
+    tokenizer = load_tokenizer(model_args)["tokenizer"]
+    return load_model(tokenizer, model_args, finetuning_args, is_trainable=False, add_valuehead=add_valuehead)
+
+
+def load_reference_model(
+    model_path: str,
+    lora_path: Optional[str] = None,
+    use_lora: bool = False,
+    use_pissa: bool = False,
+    is_trainable: bool = False,
+    add_valuehead: bool = False,
+) -> Union["PreTrainedModel", "LoraModel"]:
+    current_device = get_current_device()
+    if add_valuehead:
+        model: "AutoModelForCausalLMWithValueHead" = AutoModelForCausalLMWithValueHead.from_pretrained(
+            model_path, torch_dtype=torch.float16, device_map=current_device
+        )
+        if not is_trainable:
+            model.v_head = model.v_head.to(torch.float16)
+
+        return model
+
+    model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.float16, device_map=current_device)
+    if use_lora or use_pissa:
+        model = PeftModel.from_pretrained(
+            model, lora_path, subfolder="pissa_init" if use_pissa else None, is_trainable=is_trainable
+        )
+        for param in filter(lambda p: p.requires_grad, model.parameters()):
+            param.data = param.data.to(torch.float32)
+
+    return model
+
+
+def load_train_dataset(**kwargs) -> "Dataset":
+    model_args, data_args, training_args, _, _ = get_train_args(kwargs)
+    tokenizer_module = load_tokenizer(model_args)
+    template = get_template_and_fix_tokenizer(tokenizer_module["tokenizer"], data_args)
+    dataset_module = get_dataset(template, model_args, data_args, training_args, kwargs["stage"], **tokenizer_module)
+    return dataset_module["train_dataset"]
+
+
+def patch_valuehead_model() -> None:
+    def post_init(self: "AutoModelForCausalLMWithValueHead", state_dict: Dict[str, "torch.Tensor"]) -> None:
+        state_dict = {k[7:]: state_dict[k] for k in state_dict.keys() if k.startswith("v_head.")}
+        self.v_head.load_state_dict(state_dict, strict=False)
+        del state_dict
+
+    AutoModelForCausalLMWithValueHead.post_init = post_init

LLaMA-Factory/src/llamafactory/train/trainer_utils.py

+# Copyright 2024 HuggingFace Inc. and the LlamaFactory team.
+#
+# This code is inspired by the original GaLore's implementation: https://github.com/jiaweizzhao/GaLore
+# and the original LoRA+'s implementation: https://github.com/nikhil-ghosh-berkeley/loraplus
+# and the original BAdam's implementation: https://github.com/Ledzy/BAdam
+# and the HuggingFace's TRL library: https://github.com/huggingface/trl
+#
+# 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.
+
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Tuple, Union
+
+import torch
+from transformers import Trainer
+from transformers.integrations import is_deepspeed_zero3_enabled
+from transformers.modeling_utils import is_fsdp_enabled
+from transformers.optimization import get_scheduler
+from transformers.pytorch_utils import ALL_LAYERNORM_LAYERS
+from transformers.trainer_pt_utils import get_parameter_names
+from typing_extensions import override
+
+from ..extras import logging
+from ..extras.constants import IGNORE_INDEX
+from ..extras.packages import is_galore_available
+from ..hparams import FinetuningArguments, ModelArguments
+from ..model import find_all_linear_modules, load_model, load_tokenizer, load_valuehead_params
+
+
+if is_galore_available():
+    from galore_torch import GaLoreAdafactor, GaLoreAdamW, GaLoreAdamW8bit
+
+
+if TYPE_CHECKING:
+    from transformers import PreTrainedModel, Seq2SeqTrainingArguments, TrainerCallback
+    from trl import AutoModelForCausalLMWithValueHead
+
+    from ..hparams import DataArguments
+
+
+logger = logging.get_logger(__name__)
+
+
+class DummyOptimizer(torch.optim.Optimizer):
+    r"""
+    A dummy optimizer used for the GaLore algorithm.
+    """
+
+    def __init__(
+        self, lr: float = 1e-3, optimizer_dict: Optional[Dict["torch.nn.Parameter", "torch.optim.Optimizer"]] = None
+    ) -> None:
+        dummy_tensor = torch.randn(1, 1)
+        self.optimizer_dict = optimizer_dict
+        super().__init__([dummy_tensor], {"lr": lr})
+
+    @override
+    def zero_grad(self, set_to_none: bool = True) -> None:
+        pass
+
+    @override
+    def step(self, closure: Optional[Callable[[], float]] = None) -> Optional[float]:
+        pass
+
+
+def create_modelcard_and_push(
+    trainer: "Trainer",
+    model_args: "ModelArguments",
+    data_args: "DataArguments",
+    training_args: "Seq2SeqTrainingArguments",
+    finetuning_args: "FinetuningArguments",
+) -> None:
+    kwargs = {
+        "tasks": "text-generation",
+        "finetuned_from": model_args.model_name_or_path,
+        "tags": ["llama-factory", finetuning_args.finetuning_type],
+    }
+    if data_args.dataset is not None:
+        kwargs["dataset"] = data_args.dataset
+
+    if model_args.use_unsloth:
+        kwargs["tags"] = kwargs["tags"] + ["unsloth"]
+
+    if not training_args.do_train:
+        pass
+    elif training_args.push_to_hub:
+        trainer.push_to_hub(**kwargs)
+    else:
+        trainer.create_model_card(license="other", **kwargs)  # prevent from connecting to hub
+
+
+def create_ref_model(
+    model_args: "ModelArguments", finetuning_args: "FinetuningArguments", add_valuehead: bool = False
+) -> Optional[Union["PreTrainedModel", "AutoModelForCausalLMWithValueHead"]]:
+    r"""
+    Creates reference model for PPO/DPO training. Evaluation mode is not supported.
+
+    The valuehead parameter is randomly initialized since it is useless for PPO training.
+    """
+    if finetuning_args.ref_model is not None:
+        ref_model_args = ModelArguments.copyfrom(
+            model_args,
+            model_name_or_path=finetuning_args.ref_model,
+            adapter_name_or_path=finetuning_args.ref_model_adapters,
+            quantization_bit=finetuning_args.ref_model_quantization_bit,
+        )
+        ref_finetuning_args = FinetuningArguments()
+        tokenizer = load_tokenizer(ref_model_args)["tokenizer"]
+        ref_model = load_model(
+            tokenizer, ref_model_args, ref_finetuning_args, is_trainable=False, add_valuehead=add_valuehead
+        )
+        logger.info_rank0(f"Created reference model from {finetuning_args.ref_model}")
+    else:
+        if finetuning_args.finetuning_type == "lora":
+            ref_model = None
+        else:
+            ref_model_args = ModelArguments.copyfrom(model_args)
+            ref_finetuning_args = FinetuningArguments()
+            tokenizer = load_tokenizer(ref_model_args)["tokenizer"]
+            ref_model = load_model(
+                tokenizer, ref_model_args, ref_finetuning_args, is_trainable=False, add_valuehead=add_valuehead
+            )
+            logger.info_rank0("Created reference model from the model itself.")
+
+    return ref_model
+
+
+def create_reward_model(
+    model: "AutoModelForCausalLMWithValueHead", model_args: "ModelArguments", finetuning_args: "FinetuningArguments"
+) -> Optional["AutoModelForCausalLMWithValueHead"]:
+    r"""
+    Creates reward model for PPO training.
+    """
+    if finetuning_args.reward_model_type == "api":
+        assert finetuning_args.reward_model.startswith("http"), "Please provide full url."
+        logger.info_rank0(f"Use reward server {finetuning_args.reward_model}")
+        return finetuning_args.reward_model
+    elif finetuning_args.reward_model_type == "lora":
+        model.pretrained_model.load_adapter(finetuning_args.reward_model, "reward")
+        for name, param in model.named_parameters():  # https://github.com/huggingface/peft/issues/1090
+            if "default" in name:
+                param.data = param.data.to(torch.float32)  # trainable params should in fp32
+        vhead_params = load_valuehead_params(finetuning_args.reward_model, model_args)
+        assert vhead_params is not None, "Reward model is not correctly loaded."
+        model.register_buffer("reward_head_weight", vhead_params["v_head.summary.weight"], persistent=False)
+        model.register_buffer("reward_head_bias", vhead_params["v_head.summary.bias"], persistent=False)
+        model.register_buffer(
+            "default_head_weight", torch.zeros_like(vhead_params["v_head.summary.weight"]), persistent=False
+        )
+        model.register_buffer(
+            "default_head_bias", torch.zeros_like(vhead_params["v_head.summary.bias"]), persistent=False
+        )
+        logger.info_rank0(f"Loaded adapter weights of reward model from {finetuning_args.reward_model}")
+        return None
+    else:
+        reward_model_args = ModelArguments.copyfrom(
+            model_args,
+            model_name_or_path=finetuning_args.reward_model,
+            adapter_name_or_path=finetuning_args.reward_model_adapters,
+            quantization_bit=finetuning_args.reward_model_quantization_bit,
+        )
+        reward_finetuning_args = FinetuningArguments()
+        tokenizer = load_tokenizer(reward_model_args)["tokenizer"]
+        reward_model = load_model(
+            tokenizer, reward_model_args, reward_finetuning_args, is_trainable=False, add_valuehead=True
+        )
+        logger.info_rank0(f"Loaded full weights of reward model from {finetuning_args.reward_model}")
+        logger.warning_rank0("Please ensure the ppo model and reward model share SAME tokenizer and vocabulary.")
+        return reward_model
+
+
+def _get_decay_parameter_names(model: "PreTrainedModel") -> List[str]:
+    r"""
+    Returns a list of names of parameters with weight decay. (weights in non-layernorm layers)
+    """
+    decay_parameters = get_parameter_names(model, ALL_LAYERNORM_LAYERS)
+    decay_parameters = [name for name in decay_parameters if "bias" not in name]
+    return decay_parameters
+
+
+def _create_galore_optimizer(
+    model: "PreTrainedModel",
+    training_args: "Seq2SeqTrainingArguments",
+    finetuning_args: "FinetuningArguments",
+) -> "torch.optim.Optimizer":
+    if len(finetuning_args.galore_target) == 1 and finetuning_args.galore_target[0] == "all":
+        galore_targets = find_all_linear_modules(model, finetuning_args.freeze_vision_tower)
+    else:
+        galore_targets = finetuning_args.galore_target
+
+    galore_params: List["torch.nn.Parameter"] = []
+    for name, module in model.named_modules():
+        if isinstance(module, torch.nn.Linear) and any(target in name for target in galore_targets):
+            for param in module.parameters():
+                if param.requires_grad and len(param.shape) > 1:
+                    galore_params.append(param)
+
+    galore_kwargs = {
+        "rank": finetuning_args.galore_rank,
+        "update_proj_gap": finetuning_args.galore_update_interval,
+        "scale": finetuning_args.galore_scale,
+        "proj_type": finetuning_args.galore_proj_type,
+    }
+
+    id_galore_params = {id(param) for param in galore_params}
+    decay_params, nodecay_params = [], []  # they are non-galore parameters
+    trainable_params: List["torch.nn.Parameter"] = []  # galore_params + decay_params + nodecay_params
+    decay_param_names = _get_decay_parameter_names(model)
+    for name, param in model.named_parameters():
+        if param.requires_grad:
+            trainable_params.append(param)
+            if id(param) not in id_galore_params:
+                if name in decay_param_names:
+                    decay_params.append(param)
+                else:
+                    nodecay_params.append(param)
+
+    _, optim_kwargs = Trainer.get_optimizer_cls_and_kwargs(training_args)
+
+    if training_args.optim == "adamw_torch":
+        optim_class = GaLoreAdamW
+    elif training_args.optim in ["adamw_bnb_8bit", "adamw_8bit", "paged_adamw_8bit"]:
+        optim_class = GaLoreAdamW8bit
+    elif training_args.optim == "adafactor":
+        optim_class = GaLoreAdafactor
+    else:
+        raise NotImplementedError(f"Unknow optim: {training_args.optim}")
+
+    if finetuning_args.galore_layerwise:
+        if training_args.gradient_accumulation_steps != 1:
+            raise ValueError("Per-layer GaLore does not support gradient accumulation.")
+
+        optimizer_dict: Dict["torch.Tensor", "torch.optim.Optimizer"] = {}
+        for param in nodecay_params:
+            param_groups = [dict(params=[param], weight_decay=0.0)]
+            optimizer_dict[param] = optim_class(param_groups, **optim_kwargs)
+        for param in decay_params:
+            param_groups = [dict(params=[param], weight_decay=training_args.weight_decay)]
+            optimizer_dict[param] = optim_class(param_groups, **optim_kwargs)
+        for param in galore_params:  # galore params have weight decay
+            param_groups = [dict(params=[param], weight_decay=training_args.weight_decay, **galore_kwargs)]
+            optimizer_dict[param] = optim_class(param_groups, **optim_kwargs)
+
+        def optimizer_hook(param: "torch.nn.Parameter"):
+            if param.grad is not None:
+                optimizer_dict[param].step()
+                optimizer_dict[param].zero_grad()
+
+        for param in trainable_params:
+            param.register_post_accumulate_grad_hook(optimizer_hook)
+
+        optimizer = DummyOptimizer(lr=training_args.learning_rate, optimizer_dict=optimizer_dict)
+    else:
+        param_groups = [
+            dict(params=nodecay_params, weight_decay=0.0),
+            dict(params=decay_params, weight_decay=training_args.weight_decay),
+            dict(params=galore_params, weight_decay=training_args.weight_decay, **galore_kwargs),
+        ]
+        optimizer = optim_class(param_groups, **optim_kwargs)
+
+    logger.info_rank0("Using GaLore optimizer, may cause hanging at the start of training, wait patiently.")
+    return optimizer
+
+
+def _create_loraplus_optimizer(
+    model: "PreTrainedModel",
+    training_args: "Seq2SeqTrainingArguments",
+    finetuning_args: "FinetuningArguments",
+) -> "torch.optim.Optimizer":
+    default_lr = training_args.learning_rate
+    loraplus_lr = training_args.learning_rate * finetuning_args.loraplus_lr_ratio
+    embedding_lr = finetuning_args.loraplus_lr_embedding
+
+    decay_param_names = _get_decay_parameter_names(model)
+    param_dict: Dict[str, List["torch.nn.Parameter"]] = {
+        "lora_a": [],
+        "lora_b": [],
+        "lora_b_nodecay": [],
+        "embedding": [],
+    }
+    for name, param in model.named_parameters():
+        if param.requires_grad:
+            if "lora_embedding_B" in name:
+                param_dict["embedding"].append(param)
+            elif "lora_B" in name or param.ndim == 1:
+                if name in decay_param_names:
+                    param_dict["lora_b"].append(param)
+                else:
+                    param_dict["lora_b_nodecay"].append(param)
+            else:
+                param_dict["lora_a"].append(param)
+
+    optim_class, optim_kwargs = Trainer.get_optimizer_cls_and_kwargs(training_args)
+    param_groups = [
+        dict(params=param_dict["lora_a"], lr=default_lr, weight_decay=training_args.weight_decay),
+        dict(params=param_dict["lora_b"], lr=loraplus_lr, weight_decay=training_args.weight_decay),
+        dict(params=param_dict["lora_b_nodecay"], lr=loraplus_lr, weight_decay=0.0),
+        dict(params=param_dict["embedding"], lr=embedding_lr, weight_decay=training_args.weight_decay),
+    ]
+    optimizer = optim_class(param_groups, **optim_kwargs)
+    logger.info_rank0(f"Using LoRA+ optimizer with loraplus lr ratio {finetuning_args.loraplus_lr_ratio:.2f}.")
+    return optimizer
+
+
+def _create_badam_optimizer(
+    model: "PreTrainedModel",
+    training_args: "Seq2SeqTrainingArguments",
+    finetuning_args: "FinetuningArguments",
+) -> "torch.optim.Optimizer":
+    decay_params, nodecay_params = [], []
+    decay_param_names = _get_decay_parameter_names(model)
+    for name, param in model.named_parameters():
+        if param.requires_grad:
+            if name in decay_param_names:
+                decay_params.append(param)
+            else:
+                nodecay_params.append(param)
+
+    optim_class, optim_kwargs = Trainer.get_optimizer_cls_and_kwargs(training_args)
+    param_groups = [
+        dict(params=nodecay_params, weight_decay=0.0),
+        dict(params=decay_params, weight_decay=training_args.weight_decay),
+    ]
+
+    if finetuning_args.badam_mode == "layer":
+        from badam import BlockOptimizer
+
+        base_optimizer = optim_class(param_groups, **optim_kwargs)
+        optimizer = BlockOptimizer(
+            base_optimizer=base_optimizer,
+            named_parameters_list=list(model.named_parameters()),
+            block_prefix_list=None,
+            switch_block_every=finetuning_args.badam_switch_interval,
+            start_block=finetuning_args.badam_start_block,
+            switch_mode=finetuning_args.badam_switch_mode,
+            verbose=finetuning_args.badam_verbose,
+            ds_zero3_enabled=is_deepspeed_zero3_enabled(),
+        )
+        logger.info_rank0(
+            f"Using BAdam optimizer with layer-wise update, switch mode is {finetuning_args.badam_switch_mode}, "
+            f"switch block every {finetuning_args.badam_switch_interval} steps, "
+            f"default start block is {finetuning_args.badam_start_block}"
+        )
+
+    elif finetuning_args.badam_mode == "ratio":
+        from badam import BlockOptimizerRatio
+
+        assert finetuning_args.badam_update_ratio > 1e-6
+        optimizer = BlockOptimizerRatio(
+            param_groups=param_groups,
+            named_parameters_list=list(model.named_parameters()),
+            update_ratio=finetuning_args.badam_update_ratio,
+            mask_mode=finetuning_args.badam_mask_mode,
+            verbose=finetuning_args.badam_verbose,
+            include_embedding=False,
+            **optim_kwargs,
+        )
+        logger.info_rank0(
+            f"Using BAdam optimizer with ratio-based update, update ratio is {finetuning_args.badam_update_ratio}, "
+            f"mask mode is {finetuning_args.badam_mask_mode}"
+        )
+
+    return optimizer
+
+
+def _create_adam_mini_optimizer(
+    model: "PreTrainedModel",
+    training_args: "Seq2SeqTrainingArguments",
+) -> "torch.optim.Optimizer":
+    from adam_mini import Adam_mini
+
+    hidden_size = getattr(model.config, "hidden_size", None)
+    num_q_head = getattr(model.config, "num_attention_heads", None)
+    num_kv_head = getattr(model.config, "num_key_value_heads", None)
+
+    optimizer = Adam_mini(
+        named_parameters=model.named_parameters(),
+        lr=training_args.learning_rate,
+        betas=(training_args.adam_beta1, training_args.adam_beta2),
+        eps=training_args.adam_epsilon,
+        weight_decay=training_args.weight_decay,
+        model_sharding=is_fsdp_enabled() or is_deepspeed_zero3_enabled(),
+        dim=hidden_size,
+        n_heads=num_q_head,
+        n_kv_heads=num_kv_head,
+    )
+    logger.info_rank0("Using Adam-mini optimizer.")
+    return optimizer
+
+
+def create_custom_optimizer(
+    model: "PreTrainedModel",
+    training_args: "Seq2SeqTrainingArguments",
+    finetuning_args: "FinetuningArguments",
+) -> Optional["torch.optim.Optimizer"]:
+    if finetuning_args.use_galore:
+        return _create_galore_optimizer(model, training_args, finetuning_args)
+
+    if finetuning_args.loraplus_lr_ratio is not None:
+        return _create_loraplus_optimizer(model, training_args, finetuning_args)
+
+    if finetuning_args.use_badam:
+        return _create_badam_optimizer(model, training_args, finetuning_args)
+
+    if finetuning_args.use_adam_mini:
+        return _create_adam_mini_optimizer(model, training_args)
+
+
+def create_custom_scheduler(
+    training_args: "Seq2SeqTrainingArguments",
+    num_training_steps: int,
+    optimizer: Optional["torch.optim.Optimizer"] = None,
+) -> None:
+    if optimizer is not None and isinstance(optimizer, DummyOptimizer):
+        optimizer_dict = optimizer.optimizer_dict
+        scheduler_dict: Dict["torch.nn.Parameter", "torch.optim.lr_scheduler.LRScheduler"] = {}
+
+        for param in optimizer_dict.keys():
+            scheduler_dict[param] = get_scheduler(
+                training_args.lr_scheduler_type,
+                optimizer=optimizer_dict[param],
+                num_warmup_steps=training_args.get_warmup_steps(num_training_steps),
+                num_training_steps=num_training_steps,
+                scheduler_specific_kwargs=training_args.lr_scheduler_kwargs,
+            )
+
+        def scheduler_hook(param: "torch.nn.Parameter"):
+            scheduler_dict[param].step()
+
+        for param in optimizer_dict.keys():
+            param.register_post_accumulate_grad_hook(scheduler_hook)
+
+
+def get_batch_logps(
+    logits: "torch.Tensor", labels: "torch.Tensor", label_pad_token_id: int = IGNORE_INDEX
+) -> Tuple["torch.Tensor", "torch.Tensor"]:
+    r"""
+    Computes the log probabilities of the given labels under the given logits.
+
+    Returns:
+        logps: A tensor of shape (batch_size,) containing the sum of log probabilities.
+        valid_length: A tensor of shape (batch_size,) containing the number of non-masked tokens.
+    """
+    if logits.shape[:-1] != labels.shape:
+        raise ValueError("Logits (batchsize x seqlen) and labels must have the same shape.")
+
+    labels = labels[:, 1:].clone()
+    logits = logits[:, :-1, :]
+    loss_mask = labels != label_pad_token_id
+    labels[labels == label_pad_token_id] = 0  # dummy token
+    per_token_logps = torch.gather(logits.log_softmax(-1), dim=2, index=labels.unsqueeze(2)).squeeze(2)
+    return (per_token_logps * loss_mask).sum(-1), loss_mask.sum(-1)
+
+
+def get_swanlab_callback(finetuning_args: "FinetuningArguments") -> "TrainerCallback":
+    r"""
+    Gets the callback for logging to SwanLab.
+    """
+    import swanlab
+    from swanlab.integration.transformers import SwanLabCallback
+
+    if finetuning_args.swanlab_api_key is not None:
+        swanlab.login(api_key=finetuning_args.swanlab_api_key)
+
+    swanlab_callback = SwanLabCallback(
+        project=finetuning_args.swanlab_project,
+        workspace=finetuning_args.swanlab_workspace,
+        experiment_name=finetuning_args.swanlab_run_name,
+        mode=finetuning_args.swanlab_mode,
+        config={"Framework": "🦙LlamaFactory"},
+    )
+    return swanlab_callback

LLaMA-Factory/src/llamafactory/train/tuner.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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
+import shutil
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+import torch
+from transformers import PreTrainedModel
+
+from ..data import get_template_and_fix_tokenizer
+from ..extras import logging
+from ..extras.constants import V_HEAD_SAFE_WEIGHTS_NAME, V_HEAD_WEIGHTS_NAME
+from ..hparams import get_infer_args, get_train_args
+from ..model import load_model, load_tokenizer
+from .callbacks import LogCallback, PissaConvertCallback, ReporterCallback
+from .dpo import run_dpo
+from .kto import run_kto
+from .ppo import run_ppo
+from .pt import run_pt
+from .rm import run_rm
+from .sft import run_sft
+from .trainer_utils import get_swanlab_callback
+
+
+if TYPE_CHECKING:
+    from transformers import TrainerCallback
+
+
+logger = logging.get_logger(__name__)
+
+
+def run_exp(args: Optional[Dict[str, Any]] = None, callbacks: List["TrainerCallback"] = []) -> None:
+    callbacks.append(LogCallback())
+    model_args, data_args, training_args, finetuning_args, generating_args = get_train_args(args)
+
+    if finetuning_args.pissa_convert:
+        callbacks.append(PissaConvertCallback())
+
+    if finetuning_args.use_swanlab:
+        callbacks.append(get_swanlab_callback(finetuning_args))
+
+    callbacks.append(ReporterCallback(model_args, data_args, finetuning_args, generating_args))  # add to last
+
+    if finetuning_args.stage == "pt":
+        run_pt(model_args, data_args, training_args, finetuning_args, callbacks)
+    elif finetuning_args.stage == "sft":
+        run_sft(model_args, data_args, training_args, finetuning_args, generating_args, callbacks)
+    elif finetuning_args.stage == "rm":
+        run_rm(model_args, data_args, training_args, finetuning_args, callbacks)
+    elif finetuning_args.stage == "ppo":
+        run_ppo(model_args, data_args, training_args, finetuning_args, generating_args, callbacks)
+    elif finetuning_args.stage == "dpo":
+        run_dpo(model_args, data_args, training_args, finetuning_args, callbacks)
+    elif finetuning_args.stage == "kto":
+        run_kto(model_args, data_args, training_args, finetuning_args, callbacks)
+    else:
+        raise ValueError(f"Unknown task: {finetuning_args.stage}.")
+
+
+def export_model(args: Optional[Dict[str, Any]] = None) -> None:
+    model_args, data_args, finetuning_args, _ = get_infer_args(args)
+
+    if model_args.export_dir is None:
+        raise ValueError("Please specify `export_dir` to save model.")
+
+    if model_args.adapter_name_or_path is not None and model_args.export_quantization_bit is not None:
+        raise ValueError("Please merge adapters before quantizing the model.")
+
+    tokenizer_module = load_tokenizer(model_args)
+    tokenizer = tokenizer_module["tokenizer"]
+    processor = tokenizer_module["processor"]
+    get_template_and_fix_tokenizer(tokenizer, data_args)
+    model = load_model(tokenizer, model_args, finetuning_args)  # must after fixing tokenizer to resize vocab
+
+    if getattr(model, "quantization_method", None) is not None and model_args.adapter_name_or_path is not None:
+        raise ValueError("Cannot merge adapters to a quantized model.")
+
+    if not isinstance(model, PreTrainedModel):
+        raise ValueError("The model is not a `PreTrainedModel`, export aborted.")
+
+    if getattr(model, "quantization_method", None) is not None:  # quantized model adopts float16 type
+        setattr(model.config, "torch_dtype", torch.float16)
+    else:
+        if model_args.infer_dtype == "auto":
+            output_dtype = getattr(model.config, "torch_dtype", torch.float16)
+        else:
+            output_dtype = getattr(torch, model_args.infer_dtype)
+
+        setattr(model.config, "torch_dtype", output_dtype)
+        model = model.to(output_dtype)
+        logger.info_rank0(f"Convert model dtype to: {output_dtype}.")
+
+    model.save_pretrained(
+        save_directory=model_args.export_dir,
+        max_shard_size=f"{model_args.export_size}GB",
+        safe_serialization=(not model_args.export_legacy_format),
+    )
+    if model_args.export_hub_model_id is not None:
+        model.push_to_hub(
+            model_args.export_hub_model_id,
+            token=model_args.hf_hub_token,
+            max_shard_size=f"{model_args.export_size}GB",
+            safe_serialization=(not model_args.export_legacy_format),
+        )
+
+    if finetuning_args.stage == "rm":
+        if model_args.adapter_name_or_path is not None:
+            vhead_path = model_args.adapter_name_or_path[-1]
+        else:
+            vhead_path = model_args.model_name_or_path
+
+        if os.path.exists(os.path.join(vhead_path, V_HEAD_SAFE_WEIGHTS_NAME)):
+            shutil.copy(
+                os.path.join(vhead_path, V_HEAD_SAFE_WEIGHTS_NAME),
+                os.path.join(model_args.export_dir, V_HEAD_SAFE_WEIGHTS_NAME),
+            )
+            logger.info_rank0(f"Copied valuehead to {model_args.export_dir}.")
+        elif os.path.exists(os.path.join(vhead_path, V_HEAD_WEIGHTS_NAME)):
+            shutil.copy(
+                os.path.join(vhead_path, V_HEAD_WEIGHTS_NAME),
+                os.path.join(model_args.export_dir, V_HEAD_WEIGHTS_NAME),
+            )
+            logger.info_rank0(f"Copied valuehead to {model_args.export_dir}.")
+
+    try:
+        tokenizer.padding_side = "left"  # restore padding side
+        tokenizer.init_kwargs["padding_side"] = "left"
+        tokenizer.save_pretrained(model_args.export_dir)
+        if model_args.export_hub_model_id is not None:
+            tokenizer.push_to_hub(model_args.export_hub_model_id, token=model_args.hf_hub_token)
+
+        if processor is not None:
+            processor.save_pretrained(model_args.export_dir)
+            if model_args.export_hub_model_id is not None:
+                processor.push_to_hub(model_args.export_hub_model_id, token=model_args.hf_hub_token)
+
+    except Exception as e:
+        logger.warning_rank0(f"Cannot save tokenizer, please copy the files manually: {e}.")

LLaMA-Factory/src/llamafactory/webui/chatter.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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 typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional, Sequence, Tuple
+
+from ..chat import ChatModel
+from ..data import Role
+from ..extras.constants import PEFT_METHODS
+from ..extras.misc import torch_gc
+from ..extras.packages import is_gradio_available
+from .common import QUANTIZATION_BITS, get_save_dir
+from .locales import ALERTS
+
+
+if TYPE_CHECKING:
+    from ..chat import BaseEngine
+    from .manager import Manager
+
+
+if is_gradio_available():
+    import gradio as gr
+
+
+class WebChatModel(ChatModel):
+    def __init__(self, manager: "Manager", demo_mode: bool = False, lazy_init: bool = True) -> None:
+        self.manager = manager
+        self.demo_mode = demo_mode
+        self.engine: Optional["BaseEngine"] = None
+
+        if not lazy_init:  # read arguments from command line
+            super().__init__()
+
+        if demo_mode and os.environ.get("DEMO_MODEL") and os.environ.get("DEMO_TEMPLATE"):  # load demo model
+            model_name_or_path = os.environ.get("DEMO_MODEL")
+            template = os.environ.get("DEMO_TEMPLATE")
+            infer_backend = os.environ.get("DEMO_BACKEND", "huggingface")
+            super().__init__(
+                dict(model_name_or_path=model_name_or_path, template=template, infer_backend=infer_backend)
+            )
+
+    @property
+    def loaded(self) -> bool:
+        return self.engine is not None
+
+    def load_model(self, data) -> Generator[str, None, None]:
+        get = lambda elem_id: data[self.manager.get_elem_by_id(elem_id)]
+        lang, model_name, model_path = get("top.lang"), get("top.model_name"), get("top.model_path")
+        finetuning_type, checkpoint_path = get("top.finetuning_type"), get("top.checkpoint_path")
+        error = ""
+        if self.loaded:
+            error = ALERTS["err_exists"][lang]
+        elif not model_name:
+            error = ALERTS["err_no_model"][lang]
+        elif not model_path:
+            error = ALERTS["err_no_path"][lang]
+        elif self.demo_mode:
+            error = ALERTS["err_demo"][lang]
+
+        if error:
+            gr.Warning(error)
+            yield error
+            return
+
+        if get("top.quantization_bit") in QUANTIZATION_BITS:
+            quantization_bit = int(get("top.quantization_bit"))
+        else:
+            quantization_bit = None
+
+        yield ALERTS["info_loading"][lang]
+        args = dict(
+            model_name_or_path=model_path,
+            finetuning_type=finetuning_type,
+            quantization_bit=quantization_bit,
+            quantization_method=get("top.quantization_method"),
+            template=get("top.template"),
+            flash_attn="fa2" if get("top.booster") == "flashattn2" else "auto",
+            use_unsloth=(get("top.booster") == "unsloth"),
+            rope_scaling=get("top.rope_scaling") if get("top.rope_scaling") in ["linear", "dynamic"] else None,
+            infer_backend=get("infer.infer_backend"),
+            infer_dtype=get("infer.infer_dtype"),
+            trust_remote_code=True,
+        )
+
+        if checkpoint_path:
+            if finetuning_type in PEFT_METHODS:  # list
+                args["adapter_name_or_path"] = ",".join(
+                    [get_save_dir(model_name, finetuning_type, adapter) for adapter in checkpoint_path]
+                )
+            else:  # str
+                args["model_name_or_path"] = get_save_dir(model_name, finetuning_type, checkpoint_path)
+
+        super().__init__(args)
+        yield ALERTS["info_loaded"][lang]
+
+    def unload_model(self, data) -> Generator[str, None, None]:
+        lang = data[self.manager.get_elem_by_id("top.lang")]
+
+        if self.demo_mode:
+            gr.Warning(ALERTS["err_demo"][lang])
+            yield ALERTS["err_demo"][lang]
+            return
+
+        yield ALERTS["info_unloading"][lang]
+        self.engine = None
+        torch_gc()
+        yield ALERTS["info_unloaded"][lang]
+
+    def append(
+        self,
+        chatbot: List[List[Optional[str]]],
+        messages: Sequence[Dict[str, str]],
+        role: str,
+        query: str,
+    ) -> Tuple[List[List[Optional[str]]], List[Dict[str, str]], str]:
+        return chatbot + [[query, None]], messages + [{"role": role, "content": query}], ""
+
+    def stream(
+        self,
+        chatbot: List[List[Optional[str]]],
+        messages: Sequence[Dict[str, str]],
+        system: str,
+        tools: str,
+        image: Optional[Any],
+        video: Optional[Any],
+        max_new_tokens: int,
+        top_p: float,
+        temperature: float,
+    ) -> Generator[Tuple[List[List[Optional[str]]], List[Dict[str, str]]], None, None]:
+        chatbot[-1][1] = ""
+        response = ""
+        for new_text in self.stream_chat(
+            messages,
+            system,
+            tools,
+            images=[image] if image else None,
+            videos=[video] if video else None,
+            max_new_tokens=max_new_tokens,
+            top_p=top_p,
+            temperature=temperature,
+        ):
+            response += new_text
+            if tools:
+                result = self.engine.template.extract_tool(response)
+            else:
+                result = response
+
+            if isinstance(result, list):
+                tool_calls = [{"name": tool.name, "arguments": json.loads(tool.arguments)} for tool in result]
+                tool_calls = json.dumps(tool_calls, indent=4, ensure_ascii=False)
+                output_messages = messages + [{"role": Role.FUNCTION.value, "content": tool_calls}]
+                bot_text = "```json\n" + tool_calls + "\n```"
+            else:
+                output_messages = messages + [{"role": Role.ASSISTANT.value, "content": result}]
+                bot_text = result
+
+            chatbot[-1][1] = bot_text
+            yield chatbot, output_messages

LLaMA-Factory/src/llamafactory/webui/common.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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 collections import defaultdict
+from typing import Any, Dict, Optional, Tuple
+
+from yaml import safe_dump, safe_load
+
+from ..extras import logging
+from ..extras.constants import (
+    CHECKPOINT_NAMES,
+    DATA_CONFIG,
+    DEFAULT_TEMPLATE,
+    PEFT_METHODS,
+    STAGES_USE_PAIR_DATA,
+    SUPPORTED_MODELS,
+    TRAINING_STAGES,
+    VISION_MODELS,
+    DownloadSource,
+)
+from ..extras.misc import use_modelscope, use_openmind
+from ..extras.packages import is_gradio_available
+
+
+if is_gradio_available():
+    import gradio as gr
+
+
+logger = logging.get_logger(__name__)
+
+
+DEFAULT_CACHE_DIR = "cache"
+DEFAULT_CONFIG_DIR = "config"
+DEFAULT_DATA_DIR = "data"
+DEFAULT_SAVE_DIR = "saves"
+USER_CONFIG = "user_config.yaml"
+QUANTIZATION_BITS = ["8", "6", "5", "4", "3", "2", "1"]
+GPTQ_BITS = ["8", "4", "3", "2"]
+
+
+def get_save_dir(*paths: str) -> os.PathLike:
+    r"""
+    Gets the path to saved model checkpoints.
+    """
+    if os.path.sep in paths[-1]:
+        logger.warning_rank0("Found complex path, some features may be not available.")
+        return paths[-1]
+
+    paths = (path.replace(" ", "").strip() for path in paths)
+    return os.path.join(DEFAULT_SAVE_DIR, *paths)
+
+
+def get_config_path() -> os.PathLike:
+    r"""
+    Gets the path to user config.
+    """
+    return os.path.join(DEFAULT_CACHE_DIR, USER_CONFIG)
+
+
+def load_config() -> Dict[str, Any]:
+    r"""
+    Loads user config if exists.
+    """
+    try:
+        with open(get_config_path(), encoding="utf-8") as f:
+            return safe_load(f)
+    except Exception:
+        return {"lang": None, "last_model": None, "path_dict": {}, "cache_dir": None}
+
+
+def save_config(lang: str, model_name: Optional[str] = None, model_path: Optional[str] = None) -> None:
+    r"""
+    Saves user config.
+    """
+    os.makedirs(DEFAULT_CACHE_DIR, exist_ok=True)
+    user_config = load_config()
+    user_config["lang"] = lang or user_config["lang"]
+    if model_name:
+        user_config["last_model"] = model_name
+
+    if model_name and model_path:
+        user_config["path_dict"][model_name] = model_path
+
+    with open(get_config_path(), "w", encoding="utf-8") as f:
+        safe_dump(user_config, f)
+
+
+def get_model_path(model_name: str) -> str:
+    r"""
+    Gets the model path according to the model name.
+    """
+    user_config = load_config()
+    path_dict: Dict["DownloadSource", str] = SUPPORTED_MODELS.get(model_name, defaultdict(str))
+    model_path = user_config["path_dict"].get(model_name, "") or path_dict.get(DownloadSource.DEFAULT, "")
+    if (
+        use_modelscope()
+        and path_dict.get(DownloadSource.MODELSCOPE)
+        and model_path == path_dict.get(DownloadSource.DEFAULT)
+    ):  # replace hf path with ms path
+        model_path = path_dict.get(DownloadSource.MODELSCOPE)
+
+    if (
+        use_openmind()
+        and path_dict.get(DownloadSource.OPENMIND)
+        and model_path == path_dict.get(DownloadSource.DEFAULT)
+    ):  # replace hf path with om path
+        model_path = path_dict.get(DownloadSource.OPENMIND)
+
+    return model_path
+
+
+def get_model_info(model_name: str) -> Tuple[str, str]:
+    r"""
+    Gets the necessary information of this model.
+
+    Returns:
+        model_path (str)
+        template (str)
+    """
+    return get_model_path(model_name), get_template(model_name)
+
+
+def get_template(model_name: str) -> str:
+    r"""
+    Gets the template name if the model is a chat model.
+    """
+    return DEFAULT_TEMPLATE.get(model_name, "default")
+
+
+def get_visual(model_name: str) -> bool:
+    r"""
+    Judges if the model is a vision language model.
+    """
+    return model_name in VISION_MODELS
+
+
+def list_checkpoints(model_name: str, finetuning_type: str) -> "gr.Dropdown":
+    r"""
+    Lists all available checkpoints.
+    """
+    checkpoints = []
+    if model_name:
+        save_dir = get_save_dir(model_name, finetuning_type)
+        if save_dir and os.path.isdir(save_dir):
+            for checkpoint in os.listdir(save_dir):
+                if os.path.isdir(os.path.join(save_dir, checkpoint)) and any(
+                    os.path.isfile(os.path.join(save_dir, checkpoint, name)) for name in CHECKPOINT_NAMES
+                ):
+                    checkpoints.append(checkpoint)
+
+    if finetuning_type in PEFT_METHODS:
+        return gr.Dropdown(value=[], choices=checkpoints, multiselect=True)
+    else:
+        return gr.Dropdown(value=None, choices=checkpoints, multiselect=False)
+
+
+def load_dataset_info(dataset_dir: str) -> Dict[str, Dict[str, Any]]:
+    r"""
+    Loads dataset_info.json.
+    """
+    if dataset_dir == "ONLINE" or dataset_dir.startswith("REMOTE:"):
+        logger.info_rank0(f"dataset_dir is {dataset_dir}, using online dataset.")
+        return {}
+
+    try:
+        with open(os.path.join(dataset_dir, DATA_CONFIG), encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as err:
+        logger.warning_rank0(f"Cannot open {os.path.join(dataset_dir, DATA_CONFIG)} due to {str(err)}.")
+        return {}
+
+
+def list_datasets(dataset_dir: str = None, training_stage: str = list(TRAINING_STAGES.keys())[0]) -> "gr.Dropdown":
+    r"""
+    Lists all available datasets in the dataset dir for the training stage.
+    """
+    dataset_info = load_dataset_info(dataset_dir if dataset_dir is not None else DEFAULT_DATA_DIR)
+    ranking = TRAINING_STAGES[training_stage] in STAGES_USE_PAIR_DATA
+    datasets = [k for k, v in dataset_info.items() if v.get("ranking", False) == ranking]
+    return gr.Dropdown(choices=datasets)

LLaMA-Factory/src/llamafactory/webui/components/__init__.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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.
+
+from .chatbot import create_chat_box
+from .eval import create_eval_tab
+from .export import create_export_tab
+from .infer import create_infer_tab
+from .top import create_top
+from .train import create_train_tab
+
+
+__all__ = [
+    "create_chat_box",
+    "create_eval_tab",
+    "create_export_tab",
+    "create_infer_tab",
+    "create_top",
+    "create_train_tab",
+]

LLaMA-Factory/src/llamafactory/webui/components/chatbot.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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.
+
+from typing import TYPE_CHECKING, Dict, Tuple
+
+from ...data import Role
+from ...extras.packages import is_gradio_available
+from ..utils import check_json_schema
+
+
+if is_gradio_available():
+    import gradio as gr
+
+
+if TYPE_CHECKING:
+    from gradio.components import Component
+
+    from ..engine import Engine
+
+
+def create_chat_box(
+    engine: "Engine", visible: bool = False
+) -> Tuple["Component", "Component", Dict[str, "Component"]]:
+    with gr.Column(visible=visible) as chat_box:
+        chatbot = gr.Chatbot(show_copy_button=True)
+        messages = gr.State([])
+        with gr.Row():
+            with gr.Column(scale=4):
+                with gr.Row():
+                    with gr.Column():
+                        role = gr.Dropdown(choices=[Role.USER.value, Role.OBSERVATION.value], value=Role.USER.value)
+                        system = gr.Textbox(show_label=False)
+                        tools = gr.Textbox(show_label=False, lines=3)
+
+                    with gr.Column() as mm_box:
+                        with gr.Tab("Image"):
+                            image = gr.Image(sources=["upload"], type="pil")
+
+                        with gr.Tab("Video"):
+                            video = gr.Video(sources=["upload"])
+
+                query = gr.Textbox(show_label=False, lines=8)
+                submit_btn = gr.Button(variant="primary")
+
+            with gr.Column(scale=1):
+                max_new_tokens = gr.Slider(minimum=8, maximum=4096, value=512, step=1)
+                top_p = gr.Slider(minimum=0.01, maximum=1.0, value=0.7, step=0.01)
+                temperature = gr.Slider(minimum=0.01, maximum=1.5, value=0.95, step=0.01)
+                clear_btn = gr.Button()
+
+    tools.input(check_json_schema, inputs=[tools, engine.manager.get_elem_by_id("top.lang")])
+
+    submit_btn.click(
+        engine.chatter.append,
+        [chatbot, messages, role, query],
+        [chatbot, messages, query],
+    ).then(
+        engine.chatter.stream,
+        [chatbot, messages, system, tools, image, video, max_new_tokens, top_p, temperature],
+        [chatbot, messages],
+    )
+    clear_btn.click(lambda: ([], []), outputs=[chatbot, messages])
+
+    return (
+        chatbot,
+        messages,
+        dict(
+            chat_box=chat_box,
+            role=role,
+            system=system,
+            tools=tools,
+            mm_box=mm_box,
+            image=image,
+            video=video,
+            query=query,
+            submit_btn=submit_btn,
+            max_new_tokens=max_new_tokens,
+            top_p=top_p,
+            temperature=temperature,
+            clear_btn=clear_btn,
+        ),
+    )

LLaMA-Factory/src/llamafactory/webui/components/data.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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 typing import TYPE_CHECKING, Any, Dict, List, Tuple
+
+from ...extras.constants import DATA_CONFIG
+from ...extras.packages import is_gradio_available
+
+
+if is_gradio_available():
+    import gradio as gr
+
+
+if TYPE_CHECKING:
+    from gradio.components import Component
+
+
+PAGE_SIZE = 2
+
+
+def prev_page(page_index: int) -> int:
+    return page_index - 1 if page_index > 0 else page_index
+
+
+def next_page(page_index: int, total_num: int) -> int:
+    return page_index + 1 if (page_index + 1) * PAGE_SIZE < total_num else page_index
+
+
+def can_preview(dataset_dir: str, dataset: list) -> "gr.Button":
+    try:
+        with open(os.path.join(dataset_dir, DATA_CONFIG), encoding="utf-8") as f:
+            dataset_info = json.load(f)
+    except Exception:
+        return gr.Button(interactive=False)
+
+    if len(dataset) == 0 or "file_name" not in dataset_info[dataset[0]]:
+        return gr.Button(interactive=False)
+
+    data_path = os.path.join(dataset_dir, dataset_info[dataset[0]]["file_name"])
+    if os.path.isfile(data_path) or (os.path.isdir(data_path) and os.listdir(data_path)):
+        return gr.Button(interactive=True)
+    else:
+        return gr.Button(interactive=False)
+
+
+def _load_data_file(file_path: str) -> List[Any]:
+    with open(file_path, encoding="utf-8") as f:
+        if file_path.endswith(".json"):
+            return json.load(f)
+        elif file_path.endswith(".jsonl"):
+            return [json.loads(line) for line in f]
+        else:
+            return list(f)
+
+
+def get_preview(dataset_dir: str, dataset: list, page_index: int) -> Tuple[int, list, "gr.Column"]:
+    with open(os.path.join(dataset_dir, DATA_CONFIG), encoding="utf-8") as f:
+        dataset_info = json.load(f)
+
+    data_path = os.path.join(dataset_dir, dataset_info[dataset[0]]["file_name"])
+    if os.path.isfile(data_path):
+        data = _load_data_file(data_path)
+    else:
+        data = []
+        for file_name in os.listdir(data_path):
+            data.extend(_load_data_file(os.path.join(data_path, file_name)))
+
+    return len(data), data[PAGE_SIZE * page_index : PAGE_SIZE * (page_index + 1)], gr.Column(visible=True)
+
+
+def create_preview_box(dataset_dir: "gr.Textbox", dataset: "gr.Dropdown") -> Dict[str, "Component"]:
+    data_preview_btn = gr.Button(interactive=False, scale=1)
+    with gr.Column(visible=False, elem_classes="modal-box") as preview_box:
+        with gr.Row():
+            preview_count = gr.Number(value=0, interactive=False, precision=0)
+            page_index = gr.Number(value=0, interactive=False, precision=0)
+
+        with gr.Row():
+            prev_btn = gr.Button()
+            next_btn = gr.Button()
+            close_btn = gr.Button()
+
+        with gr.Row():
+            preview_samples = gr.JSON()
+
+    dataset.change(can_preview, [dataset_dir, dataset], [data_preview_btn], queue=False).then(
+        lambda: 0, outputs=[page_index], queue=False
+    )
+    data_preview_btn.click(
+        get_preview, [dataset_dir, dataset, page_index], [preview_count, preview_samples, preview_box], queue=False
+    )
+    prev_btn.click(prev_page, [page_index], [page_index], queue=False).then(
+        get_preview, [dataset_dir, dataset, page_index], [preview_count, preview_samples, preview_box], queue=False
+    )
+    next_btn.click(next_page, [page_index, preview_count], [page_index], queue=False).then(
+        get_preview, [dataset_dir, dataset, page_index], [preview_count, preview_samples, preview_box], queue=False
+    )
+    close_btn.click(lambda: gr.Column(visible=False), outputs=[preview_box], queue=False)
+    return dict(
+        data_preview_btn=data_preview_btn,
+        preview_count=preview_count,
+        page_index=page_index,
+        prev_btn=prev_btn,
+        next_btn=next_btn,
+        close_btn=close_btn,
+        preview_samples=preview_samples,
+    )

LLaMA-Factory/src/llamafactory/webui/components/eval.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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.
+
+from typing import TYPE_CHECKING, Dict
+
+from ...extras.packages import is_gradio_available
+from ..common import DEFAULT_DATA_DIR, list_datasets
+from .data import create_preview_box
+
+
+if is_gradio_available():
+    import gradio as gr
+
+
+if TYPE_CHECKING:
+    from gradio.components import Component
+
+    from ..engine import Engine
+
+
+def create_eval_tab(engine: "Engine") -> Dict[str, "Component"]:
+    input_elems = engine.manager.get_base_elems()
+    elem_dict = dict()
+
+    with gr.Row():
+        dataset_dir = gr.Textbox(value=DEFAULT_DATA_DIR, scale=2)
+        dataset = gr.Dropdown(multiselect=True, allow_custom_value=True, scale=4)
+        preview_elems = create_preview_box(dataset_dir, dataset)
+
+    input_elems.update({dataset_dir, dataset})
+    elem_dict.update(dict(dataset_dir=dataset_dir, dataset=dataset, **preview_elems))
+
+    with gr.Row():
+        cutoff_len = gr.Slider(minimum=4, maximum=131072, value=1024, step=1)
+        max_samples = gr.Textbox(value="100000")
+        batch_size = gr.Slider(minimum=1, maximum=1024, value=2, step=1)
+        predict = gr.Checkbox(value=True)
+
+    input_elems.update({cutoff_len, max_samples, batch_size, predict})
+    elem_dict.update(dict(cutoff_len=cutoff_len, max_samples=max_samples, batch_size=batch_size, predict=predict))
+
+    with gr.Row():
+        max_new_tokens = gr.Slider(minimum=8, maximum=4096, value=512, step=1)
+        top_p = gr.Slider(minimum=0.01, maximum=1, value=0.7, step=0.01)
+        temperature = gr.Slider(minimum=0.01, maximum=1.5, value=0.95, step=0.01)
+        output_dir = gr.Textbox()
+
+    input_elems.update({max_new_tokens, top_p, temperature, output_dir})
+    elem_dict.update(dict(max_new_tokens=max_new_tokens, top_p=top_p, temperature=temperature, output_dir=output_dir))
+
+    with gr.Row():
+        cmd_preview_btn = gr.Button()
+        start_btn = gr.Button(variant="primary")
+        stop_btn = gr.Button(variant="stop")
+
+    with gr.Row():
+        resume_btn = gr.Checkbox(visible=False, interactive=False)
+        progress_bar = gr.Slider(visible=False, interactive=False)
+
+    with gr.Row():
+        output_box = gr.Markdown()
+
+    elem_dict.update(
+        dict(
+            cmd_preview_btn=cmd_preview_btn,
+            start_btn=start_btn,
+            stop_btn=stop_btn,
+            resume_btn=resume_btn,
+            progress_bar=progress_bar,
+            output_box=output_box,
+        )
+    )
+    output_elems = [output_box, progress_bar]
+
+    cmd_preview_btn.click(engine.runner.preview_eval, input_elems, output_elems, concurrency_limit=None)
+    start_btn.click(engine.runner.run_eval, input_elems, output_elems)
+    stop_btn.click(engine.runner.set_abort)
+    resume_btn.change(engine.runner.monitor, outputs=output_elems, concurrency_limit=None)
+
+    dataset.focus(list_datasets, [dataset_dir], [dataset], queue=False)
+
+    return elem_dict

LLaMA-Factory/src/llamafactory/webui/components/export.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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.
+
+from typing import TYPE_CHECKING, Dict, Generator, List, Union
+
+from ...extras.constants import PEFT_METHODS
+from ...extras.misc import torch_gc
+from ...extras.packages import is_gradio_available
+from ...train.tuner import export_model
+from ..common import GPTQ_BITS, get_save_dir
+from ..locales import ALERTS
+
+
+if is_gradio_available():
+    import gradio as gr
+
+
+if TYPE_CHECKING:
+    from gradio.components import Component
+
+    from ..engine import Engine
+
+
+def can_quantize(checkpoint_path: Union[str, List[str]]) -> "gr.Dropdown":
+    if isinstance(checkpoint_path, list) and len(checkpoint_path) != 0:
+        return gr.Dropdown(value="none", interactive=False)
+    else:
+        return gr.Dropdown(interactive=True)
+
+
+def save_model(
+    lang: str,
+    model_name: str,
+    model_path: str,
+    finetuning_type: str,
+    checkpoint_path: Union[str, List[str]],
+    template: str,
+    export_size: int,
+    export_quantization_bit: str,
+    export_quantization_dataset: str,
+    export_device: str,
+    export_legacy_format: bool,
+    export_dir: str,
+    export_hub_model_id: str,
+) -> Generator[str, None, None]:
+    error = ""
+    if not model_name:
+        error = ALERTS["err_no_model"][lang]
+    elif not model_path:
+        error = ALERTS["err_no_path"][lang]
+    elif not export_dir:
+        error = ALERTS["err_no_export_dir"][lang]
+    elif export_quantization_bit in GPTQ_BITS and not export_quantization_dataset:
+        error = ALERTS["err_no_dataset"][lang]
+    elif export_quantization_bit not in GPTQ_BITS and not checkpoint_path:
+        error = ALERTS["err_no_adapter"][lang]
+    elif export_quantization_bit in GPTQ_BITS and checkpoint_path and isinstance(checkpoint_path, list):
+        error = ALERTS["err_gptq_lora"][lang]
+
+    if error:
+        gr.Warning(error)
+        yield error
+        return
+
+    args = dict(
+        model_name_or_path=model_path,
+        finetuning_type=finetuning_type,
+        template=template,
+        export_dir=export_dir,
+        export_hub_model_id=export_hub_model_id or None,
+        export_size=export_size,
+        export_quantization_bit=int(export_quantization_bit) if export_quantization_bit in GPTQ_BITS else None,
+        export_quantization_dataset=export_quantization_dataset,
+        export_device=export_device,
+        export_legacy_format=export_legacy_format,
+        trust_remote_code=True,
+    )
+
+    if checkpoint_path:
+        if finetuning_type in PEFT_METHODS:  # list
+            args["adapter_name_or_path"] = ",".join(
+                [get_save_dir(model_name, finetuning_type, adapter) for adapter in checkpoint_path]
+            )
+        else:  # str
+            args["model_name_or_path"] = get_save_dir(model_name, finetuning_type, checkpoint_path)
+
+    yield ALERTS["info_exporting"][lang]
+    export_model(args)
+    torch_gc()
+    yield ALERTS["info_exported"][lang]
+
+
+def create_export_tab(engine: "Engine") -> Dict[str, "Component"]:
+    with gr.Row():
+        export_size = gr.Slider(minimum=1, maximum=100, value=5, step=1)
+        export_quantization_bit = gr.Dropdown(choices=["none"] + GPTQ_BITS, value="none")
+        export_quantization_dataset = gr.Textbox(value="data/c4_demo.json")
+        export_device = gr.Radio(choices=["cpu", "auto"], value="cpu")
+        export_legacy_format = gr.Checkbox()
+
+    with gr.Row():
+        export_dir = gr.Textbox()
+        export_hub_model_id = gr.Textbox()
+
+    checkpoint_path: gr.Dropdown = engine.manager.get_elem_by_id("top.checkpoint_path")
+    checkpoint_path.change(can_quantize, [checkpoint_path], [export_quantization_bit], queue=False)
+
+    export_btn = gr.Button()
+    info_box = gr.Textbox(show_label=False, interactive=False)
+
+    export_btn.click(
+        save_model,
+        [
+            engine.manager.get_elem_by_id("top.lang"),
+            engine.manager.get_elem_by_id("top.model_name"),
+            engine.manager.get_elem_by_id("top.model_path"),
+            engine.manager.get_elem_by_id("top.finetuning_type"),
+            engine.manager.get_elem_by_id("top.checkpoint_path"),
+            engine.manager.get_elem_by_id("top.template"),
+            export_size,
+            export_quantization_bit,
+            export_quantization_dataset,
+            export_device,
+            export_legacy_format,
+            export_dir,
+            export_hub_model_id,
+        ],
+        [info_box],
+    )
+
+    return dict(
+        export_size=export_size,
+        export_quantization_bit=export_quantization_bit,
+        export_quantization_dataset=export_quantization_dataset,
+        export_device=export_device,
+        export_legacy_format=export_legacy_format,
+        export_dir=export_dir,
+        export_hub_model_id=export_hub_model_id,
+        export_btn=export_btn,
+        info_box=info_box,
+    )

LLaMA-Factory/src/llamafactory/webui/components/infer.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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.
+
+from typing import TYPE_CHECKING, Dict
+
+from ...extras.packages import is_gradio_available
+from ..common import get_visual
+from .chatbot import create_chat_box
+
+
+if is_gradio_available():
+    import gradio as gr
+
+
+if TYPE_CHECKING:
+    from gradio.components import Component
+
+    from ..engine import Engine
+
+
+def create_infer_tab(engine: "Engine") -> Dict[str, "Component"]:
+    input_elems = engine.manager.get_base_elems()
+    elem_dict = dict()
+
+    with gr.Row():
+        infer_backend = gr.Dropdown(choices=["huggingface", "vllm"], value="huggingface")
+        infer_dtype = gr.Dropdown(choices=["auto", "float16", "bfloat16", "float32"], value="auto")
+
+    with gr.Row():
+        load_btn = gr.Button()
+        unload_btn = gr.Button()
+
+    info_box = gr.Textbox(show_label=False, interactive=False)
+
+    input_elems.update({infer_backend, infer_dtype})
+    elem_dict.update(
+        dict(
+            infer_backend=infer_backend,
+            infer_dtype=infer_dtype,
+            load_btn=load_btn,
+            unload_btn=unload_btn,
+            info_box=info_box,
+        )
+    )
+
+    chatbot, messages, chat_elems = create_chat_box(engine, visible=False)
+    elem_dict.update(chat_elems)
+
+    load_btn.click(engine.chatter.load_model, input_elems, [info_box]).then(
+        lambda: gr.Column(visible=engine.chatter.loaded), outputs=[chat_elems["chat_box"]]
+    )
+
+    unload_btn.click(engine.chatter.unload_model, input_elems, [info_box]).then(
+        lambda: ([], []), outputs=[chatbot, messages]
+    ).then(lambda: gr.Column(visible=engine.chatter.loaded), outputs=[chat_elems["chat_box"]])
+
+    engine.manager.get_elem_by_id("top.model_name").change(
+        lambda model_name: gr.Column(visible=get_visual(model_name)),
+        [engine.manager.get_elem_by_id("top.model_name")],
+        [chat_elems["mm_box"]],
+    )
+
+    return elem_dict

LLaMA-Factory/src/llamafactory/webui/components/top.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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.
+
+from typing import TYPE_CHECKING, Dict
+
+from ...data import TEMPLATES
+from ...extras.constants import METHODS, SUPPORTED_MODELS
+from ...extras.packages import is_gradio_available
+from ..common import get_model_info, list_checkpoints, save_config
+from ..utils import can_quantize, can_quantize_to
+
+
+if is_gradio_available():
+    import gradio as gr
+
+
+if TYPE_CHECKING:
+    from gradio.components import Component
+
+
+def create_top() -> Dict[str, "Component"]:
+    available_models = list(SUPPORTED_MODELS.keys()) + ["Custom"]
+
+    with gr.Row():
+        lang = gr.Dropdown(choices=["en", "ru", "zh", "ko"], scale=1)
+        model_name = gr.Dropdown(choices=available_models, scale=3)
+        model_path = gr.Textbox(scale=3)
+
+    with gr.Row():
+        finetuning_type = gr.Dropdown(choices=METHODS, value="lora", scale=1)
+        checkpoint_path = gr.Dropdown(multiselect=True, allow_custom_value=True, scale=6)
+
+    with gr.Row():
+        quantization_bit = gr.Dropdown(choices=["none", "8", "4"], value="none", allow_custom_value=True, scale=2)
+        quantization_method = gr.Dropdown(choices=["bitsandbytes", "hqq", "eetq"], value="bitsandbytes", scale=2)
+        template = gr.Dropdown(choices=list(TEMPLATES.keys()), value="default", scale=2)
+        rope_scaling = gr.Radio(choices=["none", "linear", "dynamic"], value="none", scale=3)
+        booster = gr.Radio(choices=["auto", "flashattn2", "unsloth", "liger_kernel"], value="auto", scale=5)
+
+    model_name.change(get_model_info, [model_name], [model_path, template], queue=False).then(
+        list_checkpoints, [model_name, finetuning_type], [checkpoint_path], queue=False
+    )
+    model_name.input(save_config, inputs=[lang, model_name], queue=False)
+    model_path.input(save_config, inputs=[lang, model_name, model_path], queue=False)
+    finetuning_type.change(can_quantize, [finetuning_type], [quantization_bit], queue=False).then(
+        list_checkpoints, [model_name, finetuning_type], [checkpoint_path], queue=False
+    )
+    checkpoint_path.focus(list_checkpoints, [model_name, finetuning_type], [checkpoint_path], queue=False)
+    quantization_method.change(can_quantize_to, [quantization_method], [quantization_bit], queue=False)
+
+    return dict(
+        lang=lang,
+        model_name=model_name,
+        model_path=model_path,
+        finetuning_type=finetuning_type,
+        checkpoint_path=checkpoint_path,
+        quantization_bit=quantization_bit,
+        quantization_method=quantization_method,
+        template=template,
+        rope_scaling=rope_scaling,
+        booster=booster,
+    )

LLaMA-Factory/src/llamafactory/webui/components/train.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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.
+
+from typing import TYPE_CHECKING, Dict
+
+from transformers.trainer_utils import SchedulerType
+
+from ...extras.constants import TRAINING_STAGES
+from ...extras.misc import get_device_count
+from ...extras.packages import is_gradio_available
+from ..common import DEFAULT_DATA_DIR, list_checkpoints, list_datasets
+from ..utils import change_stage, list_config_paths, list_output_dirs
+from .data import create_preview_box
+
+
+if is_gradio_available():
+    import gradio as gr
+
+
+if TYPE_CHECKING:
+    from gradio.components import Component
+
+    from ..engine import Engine
+
+
+def create_train_tab(engine: "Engine") -> Dict[str, "Component"]:
+    input_elems = engine.manager.get_base_elems()
+    elem_dict = dict()
+
+    with gr.Row():
+        training_stage = gr.Dropdown(
+            choices=list(TRAINING_STAGES.keys()), value=list(TRAINING_STAGES.keys())[0], scale=1
+        )
+        dataset_dir = gr.Textbox(value=DEFAULT_DATA_DIR, scale=1)
+        dataset = gr.Dropdown(multiselect=True, allow_custom_value=True, scale=4)
+        preview_elems = create_preview_box(dataset_dir, dataset)
+
+    input_elems.update({training_stage, dataset_dir, dataset})
+    elem_dict.update(dict(training_stage=training_stage, dataset_dir=dataset_dir, dataset=dataset, **preview_elems))
+
+    with gr.Row():
+        learning_rate = gr.Textbox(value="5e-5")
+        num_train_epochs = gr.Textbox(value="3.0")
+        max_grad_norm = gr.Textbox(value="1.0")
+        max_samples = gr.Textbox(value="100000")
+        compute_type = gr.Dropdown(choices=["bf16", "fp16", "fp32", "pure_bf16"], value="bf16")
+
+    input_elems.update({learning_rate, num_train_epochs, max_grad_norm, max_samples, compute_type})
+    elem_dict.update(
+        dict(
+            learning_rate=learning_rate,
+            num_train_epochs=num_train_epochs,
+            max_grad_norm=max_grad_norm,
+            max_samples=max_samples,
+            compute_type=compute_type,
+        )
+    )
+
+    with gr.Row():
+        cutoff_len = gr.Slider(minimum=4, maximum=131072, value=2048, step=1)
+        batch_size = gr.Slider(minimum=1, maximum=1024, value=2, step=1)
+        gradient_accumulation_steps = gr.Slider(minimum=1, maximum=1024, value=8, step=1)
+        val_size = gr.Slider(minimum=0, maximum=1, value=0, step=0.001)
+        lr_scheduler_type = gr.Dropdown(choices=[scheduler.value for scheduler in SchedulerType], value="cosine")
+
+    input_elems.update({cutoff_len, batch_size, gradient_accumulation_steps, val_size, lr_scheduler_type})
+    elem_dict.update(
+        dict(
+            cutoff_len=cutoff_len,
+            batch_size=batch_size,
+            gradient_accumulation_steps=gradient_accumulation_steps,
+            val_size=val_size,
+            lr_scheduler_type=lr_scheduler_type,
+        )
+    )
+
+    with gr.Accordion(open=False) as extra_tab:
+        with gr.Row():
+            logging_steps = gr.Slider(minimum=1, maximum=1000, value=5, step=5)
+            save_steps = gr.Slider(minimum=10, maximum=5000, value=100, step=10)
+            warmup_steps = gr.Slider(minimum=0, maximum=5000, value=0, step=1)
+            neftune_alpha = gr.Slider(minimum=0, maximum=10, value=0, step=0.1)
+            extra_args = gr.Textbox(value='{"optim": "adamw_torch"}')
+
+        with gr.Row():
+            with gr.Column():
+                packing = gr.Checkbox()
+                neat_packing = gr.Checkbox()
+
+            with gr.Column():
+                train_on_prompt = gr.Checkbox()
+                mask_history = gr.Checkbox()
+
+            with gr.Column():
+                resize_vocab = gr.Checkbox()
+                use_llama_pro = gr.Checkbox()
+
+            with gr.Column():
+                shift_attn = gr.Checkbox()
+                report_to = gr.Checkbox()
+
+    input_elems.update(
+        {
+            logging_steps,
+            save_steps,
+            warmup_steps,
+            neftune_alpha,
+            extra_args,
+            packing,
+            neat_packing,
+            train_on_prompt,
+            mask_history,
+            resize_vocab,
+            use_llama_pro,
+            shift_attn,
+            report_to,
+        }
+    )
+    elem_dict.update(
+        dict(
+            extra_tab=extra_tab,
+            logging_steps=logging_steps,
+            save_steps=save_steps,
+            warmup_steps=warmup_steps,
+            neftune_alpha=neftune_alpha,
+            extra_args=extra_args,
+            packing=packing,
+            neat_packing=neat_packing,
+            train_on_prompt=train_on_prompt,
+            mask_history=mask_history,
+            resize_vocab=resize_vocab,
+            use_llama_pro=use_llama_pro,
+            shift_attn=shift_attn,
+            report_to=report_to,
+        )
+    )
+
+    with gr.Accordion(open=False) as freeze_tab:
+        with gr.Row():
+            freeze_trainable_layers = gr.Slider(minimum=-128, maximum=128, value=2, step=1)
+            freeze_trainable_modules = gr.Textbox(value="all")
+            freeze_extra_modules = gr.Textbox()
+
+    input_elems.update({freeze_trainable_layers, freeze_trainable_modules, freeze_extra_modules})
+    elem_dict.update(
+        dict(
+            freeze_tab=freeze_tab,
+            freeze_trainable_layers=freeze_trainable_layers,
+            freeze_trainable_modules=freeze_trainable_modules,
+            freeze_extra_modules=freeze_extra_modules,
+        )
+    )
+
+    with gr.Accordion(open=False) as lora_tab:
+        with gr.Row():
+            lora_rank = gr.Slider(minimum=1, maximum=1024, value=8, step=1)
+            lora_alpha = gr.Slider(minimum=1, maximum=2048, value=16, step=1)
+            lora_dropout = gr.Slider(minimum=0, maximum=1, value=0, step=0.01)
+            loraplus_lr_ratio = gr.Slider(minimum=0, maximum=64, value=0, step=0.01)
+            create_new_adapter = gr.Checkbox()
+
+        with gr.Row():
+            use_rslora = gr.Checkbox()
+            use_dora = gr.Checkbox()
+            use_pissa = gr.Checkbox()
+            lora_target = gr.Textbox(scale=2)
+            additional_target = gr.Textbox(scale=2)
+
+    input_elems.update(
+        {
+            lora_rank,
+            lora_alpha,
+            lora_dropout,
+            loraplus_lr_ratio,
+            create_new_adapter,
+            use_rslora,
+            use_dora,
+            use_pissa,
+            lora_target,
+            additional_target,
+        }
+    )
+    elem_dict.update(
+        dict(
+            lora_tab=lora_tab,
+            lora_rank=lora_rank,
+            lora_alpha=lora_alpha,
+            lora_dropout=lora_dropout,
+            loraplus_lr_ratio=loraplus_lr_ratio,
+            create_new_adapter=create_new_adapter,
+            use_rslora=use_rslora,
+            use_dora=use_dora,
+            use_pissa=use_pissa,
+            lora_target=lora_target,
+            additional_target=additional_target,
+        )
+    )
+
+    with gr.Accordion(open=False) as rlhf_tab:
+        with gr.Row():
+            pref_beta = gr.Slider(minimum=0, maximum=1, value=0.1, step=0.01)
+            pref_ftx = gr.Slider(minimum=0, maximum=10, value=0, step=0.01)
+            pref_loss = gr.Dropdown(choices=["sigmoid", "hinge", "ipo", "kto_pair", "orpo", "simpo"], value="sigmoid")
+            reward_model = gr.Dropdown(multiselect=True, allow_custom_value=True)
+            with gr.Column():
+                ppo_score_norm = gr.Checkbox()
+                ppo_whiten_rewards = gr.Checkbox()
+
+    input_elems.update({pref_beta, pref_ftx, pref_loss, reward_model, ppo_score_norm, ppo_whiten_rewards})
+    elem_dict.update(
+        dict(
+            rlhf_tab=rlhf_tab,
+            pref_beta=pref_beta,
+            pref_ftx=pref_ftx,
+            pref_loss=pref_loss,
+            reward_model=reward_model,
+            ppo_score_norm=ppo_score_norm,
+            ppo_whiten_rewards=ppo_whiten_rewards,
+        )
+    )
+
+    with gr.Accordion(open=False) as galore_tab:
+        with gr.Row():
+            use_galore = gr.Checkbox()
+            galore_rank = gr.Slider(minimum=1, maximum=1024, value=16, step=1)
+            galore_update_interval = gr.Slider(minimum=1, maximum=1024, value=200, step=1)
+            galore_scale = gr.Slider(minimum=0, maximum=1, value=0.25, step=0.01)
+            galore_target = gr.Textbox(value="all")
+
+    input_elems.update({use_galore, galore_rank, galore_update_interval, galore_scale, galore_target})
+    elem_dict.update(
+        dict(
+            galore_tab=galore_tab,
+            use_galore=use_galore,
+            galore_rank=galore_rank,
+            galore_update_interval=galore_update_interval,
+            galore_scale=galore_scale,
+            galore_target=galore_target,
+        )
+    )
+
+    with gr.Accordion(open=False) as badam_tab:
+        with gr.Row():
+            use_badam = gr.Checkbox()
+            badam_mode = gr.Dropdown(choices=["layer", "ratio"], value="layer")
+            badam_switch_mode = gr.Dropdown(choices=["ascending", "descending", "random", "fixed"], value="ascending")
+            badam_switch_interval = gr.Slider(minimum=1, maximum=1024, value=50, step=1)
+            badam_update_ratio = gr.Slider(minimum=0, maximum=1, value=0.05, step=0.01)
+
+    input_elems.update({use_badam, badam_mode, badam_switch_mode, badam_switch_interval, badam_update_ratio})
+    elem_dict.update(
+        dict(
+            badam_tab=badam_tab,
+            use_badam=use_badam,
+            badam_mode=badam_mode,
+            badam_switch_mode=badam_switch_mode,
+            badam_switch_interval=badam_switch_interval,
+            badam_update_ratio=badam_update_ratio,
+        )
+    )
+
+    with gr.Accordion(open=False) as swanlab_tab:
+        with gr.Row():
+            use_swanlab = gr.Checkbox()
+            swanlab_project = gr.Textbox(value="llamafactory")
+            swanlab_run_name = gr.Textbox()
+            swanlab_workspace = gr.Textbox()
+            swanlab_api_key = gr.Textbox()
+            swanlab_mode = gr.Dropdown(choices=["cloud", "local"], value="cloud")
+
+    input_elems.update(
+        {use_swanlab, swanlab_project, swanlab_run_name, swanlab_workspace, swanlab_api_key, swanlab_mode}
+    )
+    elem_dict.update(
+        dict(
+            swanlab_tab=swanlab_tab,
+            use_swanlab=use_swanlab,
+            swanlab_project=swanlab_project,
+            swanlab_run_name=swanlab_run_name,
+            swanlab_workspace=swanlab_workspace,
+            swanlab_api_key=swanlab_api_key,
+            swanlab_mode=swanlab_mode,
+        )
+    )
+
+    with gr.Row():
+        cmd_preview_btn = gr.Button()
+        arg_save_btn = gr.Button()
+        arg_load_btn = gr.Button()
+        start_btn = gr.Button(variant="primary")
+        stop_btn = gr.Button(variant="stop")
+
+    with gr.Row():
+        with gr.Column(scale=3):
+            with gr.Row():
+                current_time = gr.Textbox(visible=False, interactive=False)
+                output_dir = gr.Dropdown(allow_custom_value=True)
+                config_path = gr.Dropdown(allow_custom_value=True)
+
+            with gr.Row():
+                device_count = gr.Textbox(value=str(get_device_count() or 1), interactive=False)
+                ds_stage = gr.Dropdown(choices=["none", "2", "3"], value="none")
+                ds_offload = gr.Checkbox()
+
+            with gr.Row():
+                resume_btn = gr.Checkbox(visible=False, interactive=False)
+                progress_bar = gr.Slider(visible=False, interactive=False)
+
+            with gr.Row():
+                output_box = gr.Markdown()
+
+        with gr.Column(scale=1):
+            loss_viewer = gr.Plot()
+
+    input_elems.update({output_dir, config_path, ds_stage, ds_offload})
+    elem_dict.update(
+        dict(
+            cmd_preview_btn=cmd_preview_btn,
+            arg_save_btn=arg_save_btn,
+            arg_load_btn=arg_load_btn,
+            start_btn=start_btn,
+            stop_btn=stop_btn,
+            current_time=current_time,
+            output_dir=output_dir,
+            config_path=config_path,
+            device_count=device_count,
+            ds_stage=ds_stage,
+            ds_offload=ds_offload,
+            resume_btn=resume_btn,
+            progress_bar=progress_bar,
+            output_box=output_box,
+            loss_viewer=loss_viewer,
+        )
+    )
+    output_elems = [output_box, progress_bar, loss_viewer]
+
+    cmd_preview_btn.click(engine.runner.preview_train, input_elems, output_elems, concurrency_limit=None)
+    start_btn.click(engine.runner.run_train, input_elems, output_elems)
+    stop_btn.click(engine.runner.set_abort)
+    resume_btn.change(engine.runner.monitor, outputs=output_elems, concurrency_limit=None)
+
+    lang = engine.manager.get_elem_by_id("top.lang")
+    model_name: "gr.Dropdown" = engine.manager.get_elem_by_id("top.model_name")
+    finetuning_type: "gr.Dropdown" = engine.manager.get_elem_by_id("top.finetuning_type")
+
+    arg_save_btn.click(engine.runner.save_args, input_elems, output_elems, concurrency_limit=None)
+    arg_load_btn.click(
+        engine.runner.load_args, [lang, config_path], list(input_elems) + [output_box], concurrency_limit=None
+    )
+
+    dataset.focus(list_datasets, [dataset_dir, training_stage], [dataset], queue=False)
+    training_stage.change(change_stage, [training_stage], [dataset, packing], queue=False)
+    reward_model.focus(list_checkpoints, [model_name, finetuning_type], [reward_model], queue=False)
+    model_name.change(list_output_dirs, [model_name, finetuning_type, current_time], [output_dir], queue=False)
+    finetuning_type.change(list_output_dirs, [model_name, finetuning_type, current_time], [output_dir], queue=False)
+    output_dir.change(
+        list_output_dirs, [model_name, finetuning_type, current_time], [output_dir], concurrency_limit=None
+    )
+    output_dir.input(
+        engine.runner.check_output_dir,
+        [lang, model_name, finetuning_type, output_dir],
+        list(input_elems) + [output_box],
+        concurrency_limit=None,
+    )
+    config_path.change(list_config_paths, [current_time], [config_path], queue=False)
+
+    return elem_dict

LLaMA-Factory/src/llamafactory/webui/css.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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.
+
+CSS = r"""
+.duplicate-button {
+  margin: auto !important;
+  color: white !important;
+  background: black !important;
+  border-radius: 100vh !important;
+}
+
+.modal-box {
+  position: fixed !important;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%); /* center horizontally */
+  max-width: 1000px;
+  max-height: 750px;
+  overflow-y: auto;
+  background-color: var(--input-background-fill);
+  flex-wrap: nowrap !important;
+  border: 2px solid black !important;
+  z-index: 1000;
+  padding: 10px;
+}
+
+.dark .modal-box {
+  border: 2px solid white !important;
+}
+"""

LLaMA-Factory/src/llamafactory/webui/engine.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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.
+
+from typing import TYPE_CHECKING, Any, Dict
+
+from .chatter import WebChatModel
+from .common import load_config
+from .locales import LOCALES
+from .manager import Manager
+from .runner import Runner
+from .utils import create_ds_config, get_time
+
+
+if TYPE_CHECKING:
+    from gradio.components import Component
+
+
+class Engine:
+    def __init__(self, demo_mode: bool = False, pure_chat: bool = False) -> None:
+        self.demo_mode = demo_mode
+        self.pure_chat = pure_chat
+        self.manager = Manager()
+        self.runner = Runner(self.manager, demo_mode)
+        self.chatter = WebChatModel(self.manager, demo_mode, lazy_init=(not pure_chat))
+        if not demo_mode:
+            create_ds_config()
+
+    def _update_component(self, input_dict: Dict[str, Dict[str, Any]]) -> Dict["Component", "Component"]:
+        r"""
+        Gets the dict to update the components.
+        """
+        output_dict: Dict["Component", "Component"] = {}
+        for elem_id, elem_attr in input_dict.items():
+            elem = self.manager.get_elem_by_id(elem_id)
+            output_dict[elem] = elem.__class__(**elem_attr)
+
+        return output_dict
+
+    def resume(self):
+        user_config = load_config() if not self.demo_mode else {}
+        lang = user_config.get("lang", None) or "en"
+
+        init_dict = {"top.lang": {"value": lang}, "infer.chat_box": {"visible": self.chatter.loaded}}
+
+        if not self.pure_chat:
+            current_time = get_time()
+            init_dict["train.current_time"] = {"value": current_time}
+            init_dict["train.output_dir"] = {"value": f"train_{current_time}"}
+            init_dict["train.config_path"] = {"value": f"{current_time}.yaml"}
+            init_dict["eval.output_dir"] = {"value": f"eval_{current_time}"}
+            init_dict["infer.mm_box"] = {"visible": False}
+
+            if user_config.get("last_model", None):
+                init_dict["top.model_name"] = {"value": user_config["last_model"]}
+
+        yield self._update_component(init_dict)
+
+        if self.runner.running and not self.demo_mode and not self.pure_chat:
+            yield {elem: elem.__class__(value=value) for elem, value in self.runner.running_data.items()}
+            if self.runner.do_train:
+                yield self._update_component({"train.resume_btn": {"value": True}})
+            else:
+                yield self._update_component({"eval.resume_btn": {"value": True}})
+
+    def change_lang(self, lang: str):
+        return {
+            elem: elem.__class__(**LOCALES[elem_name][lang])
+            for elem_name, elem in self.manager.get_elem_iter()
+            if elem_name in LOCALES
+        }

LLaMA-Factory/src/llamafactory/webui/interface.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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
+import platform
+
+from ..extras.packages import is_gradio_available
+from .common import save_config
+from .components import (
+    create_chat_box,
+    create_eval_tab,
+    create_export_tab,
+    create_infer_tab,
+    create_top,
+    create_train_tab,
+)
+from .css import CSS
+from .engine import Engine
+
+
+if is_gradio_available():
+    import gradio as gr
+
+
+def create_ui(demo_mode: bool = False) -> "gr.Blocks":
+    engine = Engine(demo_mode=demo_mode, pure_chat=False)
+    hostname = os.getenv("HOSTNAME", os.getenv("COMPUTERNAME", platform.node())).split(".")[0]
+
+    with gr.Blocks(title=f"LLaMA Board ({hostname})", css=CSS) as demo:
+        if demo_mode:
+            gr.HTML("<h1><center>LLaMA Board: A One-stop Web UI for Getting Started with LLaMA Factory</center></h1>")
+            gr.HTML(
+                '<h3><center>Visit <a href="https://github.com/hiyouga/LLaMA-Factory" target="_blank">'
+                "LLaMA Factory</a> for details.</center></h3>"
+            )
+            gr.DuplicateButton(value="Duplicate Space for private use", elem_classes="duplicate-button")
+
+        engine.manager.add_elems("top", create_top())
+        lang: "gr.Dropdown" = engine.manager.get_elem_by_id("top.lang")
+
+        with gr.Tab("Train"):
+            engine.manager.add_elems("train", create_train_tab(engine))
+
+        with gr.Tab("Evaluate & Predict"):
+            engine.manager.add_elems("eval", create_eval_tab(engine))
+
+        with gr.Tab("Chat"):
+            engine.manager.add_elems("infer", create_infer_tab(engine))
+
+        if not demo_mode:
+            with gr.Tab("Export"):
+                engine.manager.add_elems("export", create_export_tab(engine))
+
+        demo.load(engine.resume, outputs=engine.manager.get_elem_list(), concurrency_limit=None)
+        lang.change(engine.change_lang, [lang], engine.manager.get_elem_list(), queue=False)
+        lang.input(save_config, inputs=[lang], queue=False)
+
+    return demo
+
+
+def create_web_demo() -> "gr.Blocks":
+    engine = Engine(pure_chat=True)
+
+    with gr.Blocks(title="Web Demo", css=CSS) as demo:
+        lang = gr.Dropdown(choices=["en", "ru", "zh", "ko"], scale=1)
+        engine.manager.add_elems("top", dict(lang=lang))
+
+        _, _, chat_elems = create_chat_box(engine, visible=True)
+        engine.manager.add_elems("infer", chat_elems)
+
+        demo.load(engine.resume, outputs=engine.manager.get_elem_list(), concurrency_limit=None)
+        lang.change(engine.change_lang, [lang], engine.manager.get_elem_list(), queue=False)
+        lang.input(save_config, inputs=[lang], queue=False)
+
+    return demo
+
+
+def run_web_ui() -> None:
+    gradio_ipv6 = os.getenv("GRADIO_IPV6", "0").lower() in ["true", "1"]
+    gradio_share = os.getenv("GRADIO_SHARE", "0").lower() in ["true", "1"]
+    server_name = os.getenv("GRADIO_SERVER_NAME", "[::]" if gradio_ipv6 else "0.0.0.0")
+    create_ui().queue().launch(share=gradio_share, server_name=server_name, inbrowser=True)
+
+
+def run_web_demo() -> None:
+    gradio_ipv6 = os.getenv("GRADIO_IPV6", "0").lower() in ["true", "1"]
+    gradio_share = os.getenv("GRADIO_SHARE", "0").lower() in ["true", "1"]
+    server_name = os.getenv("GRADIO_SERVER_NAME", "[::]" if gradio_ipv6 else "0.0.0.0")
+    create_web_demo().queue().launch(share=gradio_share, server_name=server_name, inbrowser=True)

LLaMA-Factory/src/llamafactory/webui/locales.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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.
+
+LOCALES = {
+    "lang": {
+        "en": {
+            "label": "Lang",
+        },
+        "ru": {
+            "label": "язык",
+        },
+        "zh": {
+            "label": "语言",
+        },
+        "ko": {
+            "label": "언어",
+        },
+    },
+    "model_name": {
+        "en": {
+            "label": "Model name",
+            "info": "Input the name prefix to search for the model.",
+        },
+        "ru": {
+            "label": "Название модели",
+            "info": "Введите префикс имени для поиска модели.",
+        },
+        "zh": {
+            "label": "模型名称",
+            "info": "输入首单词以检索模型。",
+        },
+        "ko": {
+            "label": "모델 이름",
+            "info": "모델을 검색하기 위해 이름 접두어를 입력하세요.",
+        },
+    },
+    "model_path": {
+        "en": {
+            "label": "Model path",
+            "info": "Path to pretrained model or model identifier from Hugging Face.",
+        },
+        "ru": {
+            "label": "Путь к модели",
+            "info": "Путь к предварительно обученной модели или идентификатор модели от Hugging Face.",
+        },
+        "zh": {
+            "label": "模型路径",
+            "info": "本地模型的文件路径或 Hugging Face 的模型标识符。",
+        },
+        "ko": {
+            "label": "모델 경로",
+            "info": "사전 훈련된 모델의 경로 또는 Hugging Face의 모델 식별자.",
+        },
+    },
+    "finetuning_type": {
+        "en": {
+            "label": "Finetuning method",
+        },
+        "ru": {
+            "label": "Метод дообучения",
+        },
+        "zh": {
+            "label": "微调方法",
+        },
+        "ko": {
+            "label": "파인튜닝 방법",
+        },
+    },
+    "checkpoint_path": {
+        "en": {
+            "label": "Checkpoint path",
+        },
+        "ru": {
+            "label": "Путь контрольной точки",
+        },
+        "zh": {
+            "label": "检查点路径",
+        },
+        "ko": {
+            "label": "체크포인트 경로",
+        },
+    },
+    "quantization_bit": {
+        "en": {
+            "label": "Quantization bit",
+            "info": "Enable quantization (QLoRA).",
+        },
+        "ru": {
+            "label": "Уровень квантования",
+            "info": "Включить квантование (QLoRA).",
+        },
+        "zh": {
+            "label": "量化等级",
+            "info": "启用量化（QLoRA）。",
+        },
+        "ko": {
+            "label": "양자화 비트",
+            "info": "양자화 활성화 (QLoRA).",
+        },
+    },
+    "quantization_method": {
+        "en": {
+            "label": "Quantization method",
+            "info": "Quantization algorithm to use.",
+        },
+        "ru": {
+            "label": "Метод квантования",
+            "info": "Алгоритм квантования, который следует использовать.",
+        },
+        "zh": {
+            "label": "量化方法",
+            "info": "使用的量化算法。",
+        },
+        "ko": {
+            "label": "양자화 방법",
+            "info": "사용할 양자화 알고리즘.",
+        },
+    },
+    "template": {
+        "en": {
+            "label": "Prompt template",
+            "info": "The template used in constructing prompts.",
+        },
+        "ru": {
+            "label": "Шаблон запроса",
+            "info": "Шаблон, используемый при формировании запросов.",
+        },
+        "zh": {
+            "label": "提示模板",
+            "info": "构建提示词时使用的模板。",
+        },
+        "ko": {
+            "label": "프롬프트 템플릿",
+            "info": "프롬프트 구성에 사용될 템플릿.",
+        },
+    },
+    "rope_scaling": {
+        "en": {
+            "label": "RoPE scaling",
+        },
+        "ru": {
+            "label": "Масштабирование RoPE",
+        },
+        "zh": {
+            "label": "RoPE 插值方法",
+        },
+        "ko": {
+            "label": "RoPE 스케일링",
+        },
+    },
+    "booster": {
+        "en": {
+            "label": "Booster",
+        },
+        "ru": {
+            "label": "Ускоритель",
+        },
+        "zh": {
+            "label": "加速方式",
+        },
+        "ko": {
+            "label": "부스터",
+        },
+    },
+    "training_stage": {
+        "en": {
+            "label": "Stage",
+            "info": "The stage to perform in training.",
+        },
+        "ru": {
+            "label": "Этап",
+            "info": "Этап выполнения обучения.",
+        },
+        "zh": {
+            "label": "训练阶段",
+            "info": "目前采用的训练方式。",
+        },
+        "ko": {
+            "label": "학습 단계",
+            "info": "수행할 학습 방법.",
+        },
+    },
+    "dataset_dir": {
+        "en": {
+            "label": "Data dir",
+            "info": "Path to the data directory.",
+        },
+        "ru": {
+            "label": "Директория данных",
+            "info": "Путь к директории данных.",
+        },
+        "zh": {
+            "label": "数据路径",
+            "info": "数据文件夹的路径。",
+        },
+        "ko": {
+            "label": "데이터 디렉토리",
+            "info": "데이터 디렉토리의 경로.",
+        },
+    },
+    "dataset": {
+        "en": {
+            "label": "Dataset",
+        },
+        "ru": {
+            "label": "Набор данных",
+        },
+        "zh": {
+            "label": "数据集",
+        },
+        "ko": {
+            "label": "데이터셋",
+        },
+    },
+    "data_preview_btn": {
+        "en": {
+            "value": "Preview dataset",
+        },
+        "ru": {
+            "value": "Просмотреть набор данных",
+        },
+        "zh": {
+            "value": "预览数据集",
+        },
+        "ko": {
+            "value": "데이터셋 미리보기",
+        },
+    },
+    "preview_count": {
+        "en": {
+            "label": "Count",
+        },
+        "ru": {
+            "label": "Количество",
+        },
+        "zh": {
+            "label": "数量",
+        },
+        "ko": {
+            "label": "개수",
+        },
+    },
+    "page_index": {
+        "en": {
+            "label": "Page",
+        },
+        "ru": {
+            "label": "Страница",
+        },
+        "zh": {
+            "label": "页数",
+        },
+        "ko": {
+            "label": "페이지",
+        },
+    },
+    "prev_btn": {
+        "en": {
+            "value": "Prev",
+        },
+        "ru": {
+            "value": "Предыдущая",
+        },
+        "zh": {
+            "value": "上一页",
+        },
+        "ko": {
+            "value": "이전",
+        },
+    },
+    "next_btn": {
+        "en": {
+            "value": "Next",
+        },
+        "ru": {
+            "value": "Следующая",
+        },
+        "zh": {
+            "value": "下一页",
+        },
+        "ko": {
+            "value": "다음",
+        },
+    },
+    "close_btn": {
+        "en": {
+            "value": "Close",
+        },
+        "ru": {
+            "value": "Закрыть",
+        },
+        "zh": {
+            "value": "关闭",
+        },
+        "ko": {
+            "value": "닫기",
+        },
+    },
+    "preview_samples": {
+        "en": {
+            "label": "Samples",
+        },
+        "ru": {
+            "label": "Примеры",
+        },
+        "zh": {
+            "label": "样例",
+        },
+        "ko": {
+            "label": "샘플",
+        },
+    },
+    "learning_rate": {
+        "en": {
+            "label": "Learning rate",
+            "info": "Initial learning rate for AdamW.",
+        },
+        "ru": {
+            "label": "Скорость обучения",
+            "info": "Начальная скорость обучения для AdamW.",
+        },
+        "zh": {
+            "label": "学习率",
+            "info": "AdamW 优化器的初始学习率。",
+        },
+        "ko": {
+            "label": "학습률",
+            "info": "AdamW의 초기 학습률.",
+        },
+    },
+    "num_train_epochs": {
+        "en": {
+            "label": "Epochs",
+            "info": "Total number of training epochs to perform.",
+        },
+        "ru": {
+            "label": "Эпохи",
+            "info": "Общее количество эпох обучения.",
+        },
+        "zh": {
+            "label": "训练轮数",
+            "info": "需要执行的训练总轮数。",
+        },
+        "ko": {
+            "label": "에포크",
+            "info": "수행할 총 학습 에포크 수.",
+        },
+    },
+    "max_grad_norm": {
+        "en": {
+            "label": "Maximum gradient norm",
+            "info": "Norm for gradient clipping.",
+        },
+        "ru": {
+            "label": "Максимальная норма градиента",
+            "info": "Норма для обрезки градиента.",
+        },
+        "zh": {
+            "label": "最大梯度范数",
+            "info": "用于梯度裁剪的范数。",
+        },
+        "ko": {
+            "label": "최대 그레디언트 노름(norm)",
+            "info": "그레디언트 클리핑을 위한 노름(norm).",
+        },
+    },
+    "max_samples": {
+        "en": {
+            "label": "Max samples",
+            "info": "Maximum samples per dataset.",
+        },
+        "ru": {
+            "label": "Максимальное количество образцов",
+            "info": "Максимальное количество образцов на набор данных.",
+        },
+        "zh": {
+            "label": "最大样本数",
+            "info": "每个数据集的最大样本数。",
+        },
+        "ko": {
+            "label": "최대 샘플 수",
+            "info": "데이터셋 당 최대 샘플 수.",
+        },
+    },
+    "compute_type": {
+        "en": {
+            "label": "Compute type",
+            "info": "Whether to use mixed precision training.",
+        },
+        "ru": {
+            "label": "Тип вычислений",
+            "info": "Использовать ли обучение смешанной точности.",
+        },
+        "zh": {
+            "label": "计算类型",
+            "info": "是否使用混合精度训练。",
+        },
+        "ko": {
+            "label": "연산 유형",
+            "info": "혼합 정밀도 훈련을 사용할지 여부.",
+        },
+    },
+    "cutoff_len": {
+        "en": {
+            "label": "Cutoff length",
+            "info": "Max tokens in input sequence.",
+        },
+        "ru": {
+            "label": "Длина обрезки",
+            "info": "Максимальное количество токенов во входной последовательности.",
+        },
+        "zh": {
+            "label": "截断长度",
+            "info": "输入序列分词后的最大长度。",
+        },
+        "ko": {
+            "label": "컷오프 길이",
+            "info": "입력 시퀀스의 최대 토큰 수.",
+        },
+    },
+    "batch_size": {
+        "en": {
+            "label": "Batch size",
+            "info": "Number of samples processed on each GPU.",
+        },
+        "ru": {
+            "label": "Размер пакета",
+            "info": "Количество образцов для обработки на каждом GPU.",
+        },
+        "zh": {
+            "label": "批处理大小",
+            "info": "每个 GPU 处理的样本数量。",
+        },
+        "ko": {
+            "label": "배치 크기",
+            "info": "각 GPU에서 처리되는 샘플 수.",
+        },
+    },
+    "gradient_accumulation_steps": {
+        "en": {
+            "label": "Gradient accumulation",
+            "info": "Number of steps for gradient accumulation.",
+        },
+        "ru": {
+            "label": "Накопление градиента",
+            "info": "Количество шагов накопления градиента.",
+        },
+        "zh": {
+            "label": "梯度累积",
+            "info": "梯度累积的步数。",
+        },
+        "ko": {
+            "label": "그레디언트 누적",
+            "info": "그레디언트 누적 단계 수.",
+        },
+    },
+    "val_size": {
+        "en": {
+            "label": "Val size",
+            "info": "Proportion of data in the dev set.",
+        },
+        "ru": {
+            "label": "Размер валидации",
+            "info": "Пропорция данных в наборе для разработки.",
+        },
+        "zh": {
+            "label": "验证集比例",
+            "info": "验证集占全部样本的百分比。",
+        },
+        "ko": {
+            "label": "검증 데이터셋 크기",
+            "info": "개발 데이터셋에서 검증 데이터의 비율.",
+        },
+    },
+    "lr_scheduler_type": {
+        "en": {
+            "label": "LR scheduler",
+            "info": "Name of the learning rate scheduler.",
+        },
+        "ru": {
+            "label": "Планировщик скорости обучения",
+            "info": "Название планировщика скорости обучения.",
+        },
+        "zh": {
+            "label": "学习率调节器",
+            "info": "学习率调度器的名称。",
+        },
+        "ko": {
+            "label": "LR 스케줄러",
+            "info": "학습률 스케줄러의 이름.",
+        },
+    },
+    "extra_tab": {
+        "en": {
+            "label": "Extra configurations",
+        },
+        "ru": {
+            "label": "Дополнительные конфигурации",
+        },
+        "zh": {
+            "label": "其它参数设置",
+        },
+        "ko": {
+            "label": "추가 구성(configuration)",
+        },
+    },
+    "logging_steps": {
+        "en": {
+            "label": "Logging steps",
+            "info": "Number of steps between two logs.",
+        },
+        "ru": {
+            "label": "Шаги логирования",
+            "info": "Количество шагов между двумя записями в журнале.",
+        },
+        "zh": {
+            "label": "日志间隔",
+            "info": "每两次日志输出间的更新步数。",
+        },
+        "ko": {
+            "label": "로깅 스텝",
+            "info": "이전 로깅과 다음 로깅 간 스텝 수.",
+        },
+    },
+    "save_steps": {
+        "en": {
+            "label": "Save steps",
+            "info": "Number of steps between two checkpoints.",
+        },
+        "ru": {
+            "label": "Шаги сохранения",
+            "info": "Количество шагов между двумя контрольными точками.",
+        },
+        "zh": {
+            "label": "保存间隔",
+            "info": "每两次断点保存间的更新步数。",
+        },
+        "ko": {
+            "label": "저장 스텝",
+            "info": "이전 체크포인트와 다음 체크포인트 사이의 스텝 수.",
+        },
+    },
+    "warmup_steps": {
+        "en": {
+            "label": "Warmup steps",
+            "info": "Number of steps used for warmup.",
+        },
+        "ru": {
+            "label": "Шаги прогрева",
+            "info": "Количество шагов, используемых для прогрева.",
+        },
+        "zh": {
+            "label": "预热步数",
+            "info": "学习率预热采用的步数。",
+        },
+        "ko": {
+            "label": "Warmup 스텝",
+            "info": "Warmup에 사용되는 스텝 수.",
+        },
+    },
+    "neftune_alpha": {
+        "en": {
+            "label": "NEFTune alpha",
+            "info": "Magnitude of noise adding to embedding vectors.",
+        },
+        "ru": {
+            "label": "NEFTune alpha",
+            "info": "Величина шума, добавляемого к векторам вложений.",
+        },
+        "zh": {
+            "label": "NEFTune 噪声参数",
+            "info": "嵌入向量所添加的噪声大小。",
+        },
+        "ko": {
+            "label": "NEFTune 알파",
+            "info": "임베딩 벡터에 추가되는 노이즈의 크기.",
+        },
+    },
+    "extra_args": {
+        "en": {
+            "label": "Extra arguments",
+            "info": "Extra arguments passed to the trainer in JSON format.",
+        },
+        "ru": {
+            "label": "Дополнительные аргументы",
+            "info": "Дополнительные аргументы, которые передаются тренеру в формате JSON.",
+        },
+        "zh": {
+            "label": "额外参数",
+            "info": "以 JSON 格式传递给训练器的额外参数。",
+        },
+        "ko": {
+            "label": "추가 인수",
+            "info": "JSON 형식으로 트레이너에게 전달할 추가 인수입니다.",
+        },
+    },
+    "packing": {
+        "en": {
+            "label": "Pack sequences",
+            "info": "Pack sequences into samples of fixed length.",
+        },
+        "ru": {
+            "label": "Упаковка последовательностей",
+            "info": "Упаковка последовательностей в образцы фиксированной длины.",
+        },
+        "zh": {
+            "label": "序列打包",
+            "info": "将序列打包为等长样本。",
+        },
+        "ko": {
+            "label": "시퀀스 패킹",
+            "info": "고정된 길이의 샘플로 시퀀스를 패킹합니다.",
+        },
+    },
+    "neat_packing": {
+        "en": {
+            "label": "Use neat packing",
+            "info": "Avoid cross-attention between packed sequences.",
+        },
+        "ru": {
+            "label": "Используйте аккуратную упаковку",
+            "info": "избегайте перекрестного внимания между упакованными последовательностями.",
+        },
+        "zh": {
+            "label": "使用无污染打包",
+            "info": "避免打包后的序列产生交叉注意力。",
+        },
+        "ko": {
+            "label": "니트 패킹 사용",
+            "info": "패킹된 시퀀스 간의 크로스 어텐션을 피합니다.",
+        },
+    },
+    "train_on_prompt": {
+        "en": {
+            "label": "Train on prompt",
+            "info": "Disable the label mask on the prompt (only for SFT).",
+        },
+        "ru": {
+            "label": "Тренировка на подсказке",
+            "info": "Отключить маску меток на подсказке (только для SFT).",
+        },
+        "zh": {
+            "label": "学习提示词",
+            "info": "不在提示词的部分添加掩码（仅适用于 SFT）。",
+        },
+        "ko": {
+            "label": "프롬프트도 학습",
+            "info": "프롬프트에서 라벨 마스킹을 비활성화합니다 (SFT에만 해당).",
+        },
+    },
+    "mask_history": {
+        "en": {
+            "label": "Mask history",
+            "info": "Train on the last turn only (only for SFT).",
+        },
+        "ru": {
+            "label": "История масок",
+            "info": "Тренироваться только на последнем шаге (только для SFT).",
+        },
+        "zh": {
+            "label": "不学习历史对话",
+            "info": "仅学习最后一轮对话（仅适用于 SFT）。",
+        },
+        "ko": {
+            "label": "히스토리 마스킹",
+            "info": "대화 데이터의 마지막 턴만 학습합니다 (SFT에만 해당).",
+        },
+    },
+    "resize_vocab": {
+        "en": {
+            "label": "Resize token embeddings",
+            "info": "Resize the tokenizer vocab and the embedding layers.",
+        },
+        "ru": {
+            "label": "Изменение размера токенных эмбеддингов",
+            "info": "Изменить размер словаря токенизатора и слоев эмбеддинга.",
+        },
+        "zh": {
+            "label": "更改词表大小",
+            "info": "更改分词器词表和嵌入层的大小。",
+        },
+        "ko": {
+            "label": "토큰 임베딩의 사이즈 조정",
+            "info": "토크나이저 어휘와 임베딩 레이어의 크기를 조정합니다.",
+        },
+    },
+    "use_llama_pro": {
+        "en": {
+            "label": "Enable LLaMA Pro",
+            "info": "Make the parameters in the expanded blocks trainable.",
+        },
+        "ru": {
+            "label": "Включить LLaMA Pro",
+            "info": "Сделать параметры в расширенных блоках обучаемыми.",
+        },
+        "zh": {
+            "label": "使用 LLaMA Pro",
+            "info": "仅训练块扩展后的参数。",
+        },
+        "ko": {
+            "label": "LLaMA Pro 사용",
+            "info": "확장된 블록의 매개변수를 학습 가능하게 만듭니다.",
+        },
+    },
+    "shift_attn": {
+        "en": {
+            "label": "Enable S^2 Attention",
+            "info": "Use shift short attention proposed by LongLoRA.",
+        },
+        "ru": {
+            "label": "Включить S^2 внимание",
+            "info": "Использовать сдвиг внимания на короткие дистанции предложенный LongLoRA.",
+        },
+        "zh": {
+            "label": "使用 S^2 Attention",
+            "info": "使用 LongLoRA 提出的 shift short attention。",
+        },
+        "ko": {
+            "label": "S^2 Attention 사용",
+            "info": "LongLoRA에서 제안한 shift short attention을 사용합니다.",
+        },
+    },
+    "report_to": {
+        "en": {
+            "label": "Enable external logger",
+            "info": "Use TensorBoard or wandb to log experiment.",
+        },
+        "ru": {
+            "label": "Включить внешний регистратор",
+            "info": "Использовать TensorBoard или wandb для ведения журнала экспериментов.",
+        },
+        "zh": {
+            "label": "启用外部记录面板",
+            "info": "使用 TensorBoard 或 wandb 记录实验。",
+        },
+        "ko": {
+            "label": "외부 logger 활성화",
+            "info": "TensorBoard 또는 wandb를 사용하여 실험을 기록합니다.",
+        },
+    },
+    "freeze_tab": {
+        "en": {
+            "label": "Freeze tuning configurations",
+        },
+        "ru": {
+            "label": "конфигурации для настройки заморозки",
+        },
+        "zh": {
+            "label": "部分参数微调设置",
+        },
+        "ko": {
+            "label": "Freeze tuning 설정",
+        },
+    },
+    "freeze_trainable_layers": {
+        "en": {
+            "label": "Trainable layers",
+            "info": "Number of the last(+)/first(-) hidden layers to be set as trainable.",
+        },
+        "ru": {
+            "label": "Обучаемые слои",
+            "info": "Количество последних (+)/первых (-) скрытых слоев, которые будут установлены как обучаемые.",
+        },
+        "zh": {
+            "label": "可训练层数",
+            "info": "最末尾（+）/最前端（-）可训练隐藏层的数量。",
+        },
+        "ko": {
+            "label": "학습 가능한 레이어",
+            "info": "학습 가능하게 설정할 마지막(+)/처음(-) 히든 레이어의 수.",
+        },
+    },
+    "freeze_trainable_modules": {
+        "en": {
+            "label": "Trainable modules",
+            "info": "Name(s) of trainable modules. Use commas to separate multiple modules.",
+        },
+        "ru": {
+            "label": "Обучаемые модули",
+            "info": "Название обучаемых модулей. Используйте запятые для разделения нескольких модулей.",
+        },
+        "zh": {
+            "label": "可训练模块",
+            "info": "可训练模块的名称。使用英文逗号分隔多个名称。",
+        },
+        "ko": {
+            "label": "학습 가능한 모듈",
+            "info": "학습 가능한 모듈의 이름. 여러 모듈을 구분하려면 쉼표(,)를 사용하세요.",
+        },
+    },
+    "freeze_extra_modules": {
+        "en": {
+            "label": "Extra modules (optional)",
+            "info": (
+                "Name(s) of modules apart from hidden layers to be set as trainable. "
+                "Use commas to separate multiple modules."
+            ),
+        },
+        "ru": {
+            "label": "Дополнительные модули (опционально)",
+            "info": (
+                "Имена модулей, кроме скрытых слоев, которые следует установить в качестве обучаемых. "
+                "Используйте запятые для разделения нескольких модулей."
+            ),
+        },
+        "zh": {
+            "label": "额外模块（非必填）",
+            "info": "除隐藏层以外的可训练模块名称。使用英文逗号分隔多个名称。",
+        },
+        "ko": {
+            "label": "추가 모듈 (선택 사항)",
+            "info": "학습 가능한 모듈의 이름(히든 레이어 제외). 모듈 간에는 쉼표(,)로 구분하십시오.",
+        },
+    },
+    "lora_tab": {
+        "en": {
+            "label": "LoRA configurations",
+        },
+        "ru": {
+            "label": "Конфигурации LoRA",
+        },
+        "zh": {
+            "label": "LoRA 参数设置",
+        },
+        "ko": {
+            "label": "LoRA 구성",
+        },
+    },
+    "lora_rank": {
+        "en": {
+            "label": "LoRA rank",
+            "info": "The rank of LoRA matrices.",
+        },
+        "ru": {
+            "label": "Ранг матриц LoRA",
+            "info": "Ранг матриц LoRA.",
+        },
+        "zh": {
+            "label": "LoRA 秩",
+            "info": "LoRA 矩阵的秩大小。",
+        },
+        "ko": {
+            "label": "LoRA 랭크",
+            "info": "LoRA 행렬의 랭크.",
+        },
+    },
+    "lora_alpha": {
+        "en": {
+            "label": "LoRA alpha",
+            "info": "Lora scaling coefficient.",
+        },
+        "ru": {
+            "label": "LoRA alpha",
+            "info": "Коэффициент масштабирования LoRA.",
+        },
+        "zh": {
+            "label": "LoRA 缩放系数",
+            "info": "LoRA 缩放系数大小。",
+        },
+        "ko": {
+            "label": "LoRA 알파",
+            "info": "LoRA 스케일링 계수.",
+        },
+    },
+    "lora_dropout": {
+        "en": {
+            "label": "LoRA dropout",
+            "info": "Dropout ratio of LoRA weights.",
+        },
+        "ru": {
+            "label": "Вероятность отсева LoRA",
+            "info": "Вероятность отсева весов LoRA.",
+        },
+        "zh": {
+            "label": "LoRA 随机丢弃",
+            "info": "LoRA 权重随机丢弃的概率。",
+        },
+        "ko": {
+            "label": "LoRA 드롭아웃",
+            "info": "LoRA 가중치의 드롭아웃 비율.",
+        },
+    },
+    "loraplus_lr_ratio": {
+        "en": {
+            "label": "LoRA+ LR ratio",
+            "info": "The LR ratio of the B matrices in LoRA.",
+        },
+        "ru": {
+            "label": "LoRA+ LR коэффициент",
+            "info": "Коэффициент LR матриц B в LoRA.",
+        },
+        "zh": {
+            "label": "LoRA+ 学习率比例",
+            "info": "LoRA+ 中 B 矩阵的学习率倍数。",
+        },
+        "ko": {
+            "label": "LoRA+ LR 비율",
+            "info": "LoRA에서 B 행렬의 LR 비율.",
+        },
+    },
+    "create_new_adapter": {
+        "en": {
+            "label": "Create new adapter",
+            "info": "Create a new adapter with randomly initialized weight upon the existing one.",
+        },
+        "ru": {
+            "label": "Создать новый адаптер",
+            "info": "Создать новый адаптер с случайной инициализацией веса на основе существующего.",
+        },
+        "zh": {
+            "label": "新建适配器",
+            "info": "在现有的适配器上创建一个随机初始化后的新适配器。",
+        },
+        "ko": {
+            "label": "새 어댑터 생성",
+            "info": "기존 어댑터 위에 무작위로 초기화된 가중치를 가진 새 어댑터를 생성합니다.",
+        },
+    },
+    "use_rslora": {
+        "en": {
+            "label": "Use rslora",
+            "info": "Use the rank stabilization scaling factor for LoRA layer.",
+        },
+        "ru": {
+            "label": "Использовать rslora",
+            "info": "Использовать коэффициент масштабирования стабилизации ранга для слоя LoRA.",
+        },
+        "zh": {
+            "label": "使用 rslora",
+            "info": "对 LoRA 层使用秩稳定缩放方法。",
+        },
+        "ko": {
+            "label": "rslora 사용",
+            "info": "LoRA 레이어에 랭크 안정화 스케일링 계수를 사용합니다.",
+        },
+    },
+    "use_dora": {
+        "en": {
+            "label": "Use DoRA",
+            "info": "Use weight-decomposed LoRA.",
+        },
+        "ru": {
+            "label": "Используйте DoRA",
+            "info": "Используйте LoRA с декомпозицией весов.",
+        },
+        "zh": {
+            "label": "使用 DoRA",
+            "info": "使用权重分解的 LoRA。",
+        },
+        "ko": {
+            "label": "DoRA 사용",
+            "info": "가중치-분해 LoRA를 사용합니다.",
+        },
+    },
+    "use_pissa": {
+        "en": {
+            "label": "Use PiSSA",
+            "info": "Use PiSSA method.",
+        },
+        "ru": {
+            "label": "используйте PiSSA",
+            "info": "Используйте метод PiSSA.",
+        },
+        "zh": {
+            "label": "使用 PiSSA",
+            "info": "使用 PiSSA 方法。",
+        },
+        "ko": {
+            "label": "PiSSA 사용",
+            "info": "PiSSA 방법을 사용합니다.",
+        },
+    },
+    "lora_target": {
+        "en": {
+            "label": "LoRA modules (optional)",
+            "info": "Name(s) of modules to apply LoRA. Use commas to separate multiple modules.",
+        },
+        "ru": {
+            "label": "Модули LoRA (опционально)",
+            "info": "Имена модулей для применения LoRA. Используйте запятые для разделения нескольких модулей.",
+        },
+        "zh": {
+            "label": "LoRA 作用模块（非必填）",
+            "info": "应用 LoRA 的模块名称。使用英文逗号分隔多个名称。",
+        },
+        "ko": {
+            "label": "LoRA 모듈 (선택 사항)",
+            "info": "LoRA를 적용할 모듈의 이름. 모듈 간에는 쉼표(,)로 구분하십시오.",
+        },
+    },
+    "additional_target": {
+        "en": {
+            "label": "Additional modules (optional)",
+            "info": (
+                "Name(s) of modules apart from LoRA layers to be set as trainable. "
+                "Use commas to separate multiple modules."
+            ),
+        },
+        "ru": {
+            "label": "Дополнительные модули (опционально)",
+            "info": (
+                "Имена модулей, кроме слоев LoRA, которые следует установить в качестве обучаемых. "
+                "Используйте запятые для разделения нескольких модулей."
+            ),
+        },
+        "zh": {
+            "label": "附加模块（非必填）",
+            "info": "除 LoRA 层以外的可训练模块名称。使用英文逗号分隔多个名称。",
+        },
+        "ko": {
+            "label": "추가 모듈 (선택 사항)",
+            "info": "LoRA 레이어 외에 학습 가능하게 설정할 모듈의 이름. 모듈 간에는 쉼표(,)로 구분하십시오.",
+        },
+    },
+    "rlhf_tab": {
+        "en": {
+            "label": "RLHF configurations",
+        },
+        "ru": {
+            "label": "Конфигурации RLHF",
+        },
+        "zh": {
+            "label": "RLHF 参数设置",
+        },
+        "ko": {
+            "label": "RLHF 구성",
+        },
+    },
+    "pref_beta": {
+        "en": {
+            "label": "Beta value",
+            "info": "Value of the beta parameter in the loss.",
+        },
+        "ru": {
+            "label": "Бета значение",
+            "info": "Значение параметра бета в функции потерь.",
+        },
+        "zh": {
+            "label": "Beta 参数",
+            "info": "损失函数中 beta 超参数大小。",
+        },
+        "ko": {
+            "label": "베타 값",
+            "info": "손실 함수에서 베타 매개 변수의 값.",
+        },
+    },
+    "pref_ftx": {
+        "en": {
+            "label": "Ftx gamma",
+            "info": "The weight of SFT loss in the final loss.",
+        },
+        "ru": {
+            "label": "Ftx гамма",
+            "info": "Вес потери SFT в итоговой потере.",
+        },
+        "zh": {
+            "label": "Ftx gamma",
+            "info": "损失函数中 SFT 损失的权重大小。",
+        },
+        "ko": {
+            "label": "Ftx 감마",
+            "info": "최종 로스 함수에서 SFT 로스의 가중치.",
+        },
+    },
+    "pref_loss": {
+        "en": {
+            "label": "Loss type",
+            "info": "The type of the loss function.",
+        },
+        "ru": {
+            "label": "Тип потерь",
+            "info": "Тип функции потерь.",
+        },
+        "zh": {
+            "label": "损失类型",
+            "info": "损失函数的类型。",
+        },
+        "ko": {
+            "label": "로스 유형",
+            "info": "로스 함수의 유형.",
+        },
+    },
+    "reward_model": {
+        "en": {
+            "label": "Reward model",
+            "info": "Adapter of the reward model in PPO training.",
+        },
+        "ru": {
+            "label": "Модель вознаграждения",
+            "info": "Адаптер модели вознаграждения для обучения PPO.",
+        },
+        "zh": {
+            "label": "奖励模型",
+            "info": "PPO 训练中奖励模型的适配器路径。",
+        },
+        "ko": {
+            "label": "리워드 모델",
+            "info": "PPO 학습에서 사용할 리워드 모델의 어댑터.",
+        },
+    },
+    "ppo_score_norm": {
+        "en": {
+            "label": "Score norm",
+            "info": "Normalizing scores in PPO training.",
+        },
+        "ru": {
+            "label": "Норма оценок",
+            "info": "Нормализация оценок в тренировке PPO.",
+        },
+        "zh": {
+            "label": "归一化分数",
+            "info": "PPO 训练中归一化奖励分数。",
+        },
+        "ko": {
+            "label": "스코어 정규화",
+            "info": "PPO 학습에서 스코어를 정규화합니다.",
+        },
+    },
+    "ppo_whiten_rewards": {
+        "en": {
+            "label": "Whiten rewards",
+            "info": "Whiten the rewards in PPO training.",
+        },
+        "ru": {
+            "label": "Белые вознаграждения",
+            "info": "Осветлите вознаграждения в обучении PPO.",
+        },
+        "zh": {
+            "label": "白化奖励",
+            "info": "PPO 训练中将奖励分数做白化处理。",
+        },
+        "ko": {
+            "label": "보상 백화",
+            "info": "PPO 훈련에서 보상을 백화(Whiten)합니다.",
+        },
+    },
+    "galore_tab": {
+        "en": {
+            "label": "GaLore configurations",
+        },
+        "ru": {
+            "label": "Конфигурации GaLore",
+        },
+        "zh": {
+            "label": "GaLore 参数设置",
+        },
+        "ko": {
+            "label": "GaLore 구성",
+        },
+    },
+    "use_galore": {
+        "en": {
+            "label": "Use GaLore",
+            "info": "Enable gradient low-Rank projection.",
+        },
+        "ru": {
+            "label": "Использовать GaLore",
+            "info": "Включить проекцию градиента на низкоранговое пространство.",
+        },
+        "zh": {
+            "label": "使用 GaLore",
+            "info": "使用梯度低秩投影。",
+        },
+        "ko": {
+            "label": "GaLore 사용",
+            "info": "그레디언트 로우 랭크 프로젝션을 활성화합니다.",
+        },
+    },
+    "galore_rank": {
+        "en": {
+            "label": "GaLore rank",
+            "info": "The rank of GaLore gradients.",
+        },
+        "ru": {
+            "label": "Ранг GaLore",
+            "info": "Ранг градиентов GaLore.",
+        },
+        "zh": {
+            "label": "GaLore 秩",
+            "info": "GaLore 梯度的秩大小。",
+        },
+        "ko": {
+            "label": "GaLore 랭크",
+            "info": "GaLore 그레디언트의 랭크.",
+        },
+    },
+    "galore_update_interval": {
+        "en": {
+            "label": "Update interval",
+            "info": "Number of steps to update the GaLore projection.",
+        },
+        "ru": {
+            "label": "Интервал обновления",
+            "info": "Количество шагов для обновления проекции GaLore.",
+        },
+        "zh": {
+            "label": "更新间隔",
+            "info": "相邻两次投影更新的步数。",
+        },
+        "ko": {
+            "label": "업데이트 간격",
+            "info": "GaLore 프로젝션을 업데이트할 간격의 스텝 수.",
+        },
+    },
+    "galore_scale": {
+        "en": {
+            "label": "GaLore scale",
+            "info": "GaLore scaling coefficient.",
+        },
+        "ru": {
+            "label": "LoRA Alpha",
+            "info": "Коэффициент масштабирования GaLore.",
+        },
+        "zh": {
+            "label": "GaLore 缩放系数",
+            "info": "GaLore 缩放系数大小。",
+        },
+        "ko": {
+            "label": "GaLore 스케일",
+            "info": "GaLore 스케일링 계수.",
+        },
+    },
+    "galore_target": {
+        "en": {
+            "label": "GaLore modules",
+            "info": "Name(s) of modules to apply GaLore. Use commas to separate multiple modules.",
+        },
+        "ru": {
+            "label": "Модули GaLore",
+            "info": "Имена модулей для применения GaLore. Используйте запятые для разделения нескольких модулей.",
+        },
+        "zh": {
+            "label": "GaLore 作用模块",
+            "info": "应用 GaLore 的模块名称。使用英文逗号分隔多个名称。",
+        },
+        "ko": {
+            "label": "GaLore 모듈",
+            "info": "GaLore를 적용할 모듈의 이름. 모듈 간에는 쉼표(,)로 구분하십시오.",
+        },
+    },
+    "badam_tab": {
+        "en": {
+            "label": "BAdam configurations",
+        },
+        "ru": {
+            "label": "Конфигурации BAdam",
+        },
+        "zh": {
+            "label": "BAdam 参数设置",
+        },
+        "ko": {
+            "label": "BAdam 설정",
+        },
+    },
+    "use_badam": {
+        "en": {
+            "label": "Use BAdam",
+            "info": "Enable the BAdam optimizer.",
+        },
+        "ru": {
+            "label": "Использовать BAdam",
+            "info": "Включите оптимизатор BAdam.",
+        },
+        "zh": {
+            "label": "使用 BAdam",
+            "info": "使用 BAdam 优化器。",
+        },
+        "ko": {
+            "label": "BAdam 사용",
+            "info": "BAdam 옵티마이저를 사용합니다.",
+        },
+    },
+    "badam_mode": {
+        "en": {
+            "label": "BAdam mode",
+            "info": "Whether to use layer-wise or ratio-wise BAdam optimizer.",
+        },
+        "ru": {
+            "label": "Режим BAdam",
+            "info": "Использовать ли оптимизатор BAdam с послоевой или пропорциональной настройкой.",
+        },
+        "zh": {
+            "label": "BAdam 模式",
+            "info": "使用 layer-wise 或 ratio-wise BAdam 优化器。",
+        },
+        "ko": {
+            "label": "BAdam 모드",
+            "info": "레이어-BAdam 옵티마이저인지 비율-BAdam 옵티마이저인지.",
+        },
+    },
+    "badam_switch_mode": {
+        "en": {
+            "label": "Switch mode",
+            "info": "The strategy of picking block to update for layer-wise BAdam.",
+        },
+        "ru": {
+            "label": "Режим переключения",
+            "info": "Стратегия выбора блока для обновления для послойного BAdam.",
+        },
+        "zh": {
+            "label": "切换策略",
+            "info": "Layer-wise BAdam 优化器的块切换策略。",
+        },
+        "ko": {
+            "label": "스위치 모드",
+            "info": "레이어-BAdam을 위한 블록 선택 전략.",
+        },
+    },
+    "badam_switch_interval": {
+        "en": {
+            "label": "Switch interval",
+            "info": "Number of steps to update the block for layer-wise BAdam.",
+        },
+        "ru": {
+            "label": "Интервал переключения",
+            "info": "количество шагов для обновления блока для пошагового BAdam.",
+        },
+        "zh": {
+            "label": "切换频率",
+            "info": "Layer-wise BAdam 优化器的块切换频率。",
+        },
+        "ko": {
+            "label": "전환 간격",
+            "info": "레이어-BAdam을 위한 블록 업데이트 간 스텝 수.",
+        },
+    },
+    "badam_update_ratio": {
+        "en": {
+            "label": "Update ratio",
+            "info": "The ratio of the update for ratio-wise BAdam.",
+        },
+        "ru": {
+            "label": "Коэффициент обновления",
+            "info": "Коэффициент обновления для BAdam с учётом соотношений.",
+        },
+        "zh": {
+            "label": "Block 更新比例",
+            "info": "Ratio-wise BAdam 优化器的更新比例。",
+        },
+        "ko": {
+            "label": "업데이트 비율",
+            "info": "비율-BAdam의 업데이트 비율.",
+        },
+    },
+    "swanlab_tab": {
+        "en": {
+            "label": "SwanLab configurations",
+        },
+        "ru": {
+            "label": "Конфигурации SwanLab",
+        },
+        "zh": {
+            "label": "SwanLab 参数设置",
+        },
+        "ko": {
+            "label": "SwanLab 설정",
+        },
+    },
+    "use_swanlab": {
+        "en": {
+            "label": "Use SwanLab",
+            "info": "Enable SwanLab for experiment tracking and visualization.",
+        },
+        "ru": {
+            "label": "Использовать SwanLab",
+            "info": "Включить SwanLab для отслеживания и визуализации экспериментов.",
+        },
+        "zh": {
+            "label": "使用 SwanLab",
+            "info": "启用 SwanLab 进行实验跟踪和可视化。",
+        },
+        "ko": {
+            "label": "SwanLab 사용",
+            "info": "SwanLab를 사용하여 실험을 추적하고 시각화합니다.",
+        },
+    },
+    "swanlab_project": {
+        "en": {
+            "label": "SwanLab project",
+        },
+        "ru": {
+            "label": "SwanLab Проект",
+        },
+        "zh": {
+            "label": "SwanLab 项目名",
+        },
+        "ko": {
+            "label": "SwanLab 프로젝트",
+        },
+    },
+    "swanlab_run_name": {
+        "en": {
+            "label": "SwanLab experiment name (optional)",
+        },
+        "ru": {
+            "label": "SwanLab Имя эксперимента (опционально)",
+        },
+        "zh": {
+            "label": "SwanLab 实验名（非必填）",
+        },
+        "ko": {
+            "label": "SwanLab 실험 이름 (선택 사항)",
+        },
+    },
+    "swanlab_workspace": {
+        "en": {
+            "label": "SwanLab workspace (optional)",
+            "info": "Workspace for SwanLab. Defaults to the personal workspace.",
+        },
+        "ru": {
+            "label": "SwanLab Рабочая область (опционально)",
+            "info": "Рабочая область SwanLab, если не заполнено, то по умолчанию в личной рабочей области.",
+        },
+        "zh": {
+            "label": "SwanLab 工作区（非必填）",
+            "info": "SwanLab 的工作区，默认在个人工作区下。",
+        },
+        "ko": {
+            "label": "SwanLab 작업 영역 (선택 사항)",
+            "info": "SwanLab 조직의 작업 영역, 비어 있으면 기본적으로 개인 작업 영역에 있습니다.",
+        },
+    },
+    "swanlab_api_key": {
+        "en": {
+            "label": "SwanLab API key (optional)",
+            "info": "API key for SwanLab.",
+        },
+        "ru": {
+            "label": "SwanLab API ключ (опционально)",
+            "info": "API ключ для SwanLab.",
+        },
+        "zh": {
+            "label": "SwanLab API密钥（非必填）",
+            "info": "用于在编程环境登录 SwanLab，已登录则无需填写。",
+        },
+        "ko": {
+            "label": "SwanLab API 키 (선택 사항)",
+            "info": "SwanLab의 API 키.",
+        },
+    },
+    "swanlab_mode": {
+        "en": {
+            "label": "SwanLab mode",
+            "info": "Cloud or offline version.",
+        },
+        "ru": {
+            "label": "SwanLab Режим",
+            "info": "Версия в облаке или локальная версия.",
+        },
+        "zh": {
+            "label": "SwanLab 模式",
+            "info": "使用云端版或离线版 SwanLab。",
+        },
+        "ko": {
+            "label": "SwanLab 모드",
+            "info": "클라우드 버전 또는 오프라인 버전.",
+        },
+    },
+    "cmd_preview_btn": {
+        "en": {
+            "value": "Preview command",
+        },
+        "ru": {
+            "value": "Просмотр команды",
+        },
+        "zh": {
+            "value": "预览命令",
+        },
+        "ko": {
+            "value": "명령어 미리보기",
+        },
+    },
+    "arg_save_btn": {
+        "en": {
+            "value": "Save arguments",
+        },
+        "ru": {
+            "value": "Сохранить аргументы",
+        },
+        "zh": {
+            "value": "保存训练参数",
+        },
+        "ko": {
+            "value": "Argument 저장",
+        },
+    },
+    "arg_load_btn": {
+        "en": {
+            "value": "Load arguments",
+        },
+        "ru": {
+            "value": "Загрузить аргументы",
+        },
+        "zh": {
+            "value": "载入训练参数",
+        },
+        "ko": {
+            "value": "Argument 불러오기",
+        },
+    },
+    "start_btn": {
+        "en": {
+            "value": "Start",
+        },
+        "ru": {
+            "value": "Начать",
+        },
+        "zh": {
+            "value": "开始",
+        },
+        "ko": {
+            "value": "시작",
+        },
+    },
+    "stop_btn": {
+        "en": {
+            "value": "Abort",
+        },
+        "ru": {
+            "value": "Прервать",
+        },
+        "zh": {
+            "value": "中断",
+        },
+        "ko": {
+            "value": "중단",
+        },
+    },
+    "output_dir": {
+        "en": {
+            "label": "Output dir",
+            "info": "Directory for saving results.",
+        },
+        "ru": {
+            "label": "Выходной каталог",
+            "info": "Каталог для сохранения результатов.",
+        },
+        "zh": {
+            "label": "输出目录",
+            "info": "保存结果的路径。",
+        },
+        "ko": {
+            "label": "출력 디렉토리",
+            "info": "결과를 저장할 디렉토리.",
+        },
+    },
+    "config_path": {
+        "en": {
+            "label": "Config path",
+            "info": "Path to config saving arguments.",
+        },
+        "ru": {
+            "label": "Путь к конфигурации",
+            "info": "Путь для сохранения аргументов конфигурации.",
+        },
+        "zh": {
+            "label": "配置路径",
+            "info": "保存训练参数的配置文件路径。",
+        },
+        "ko": {
+            "label": "설정 경로",
+            "info": "Arguments 저장 파일 경로.",
+        },
+    },
+    "device_count": {
+        "en": {
+            "label": "Device count",
+            "info": "Number of devices available.",
+        },
+        "ru": {
+            "label": "Количество устройств",
+            "info": "Количество доступных устройств.",
+        },
+        "zh": {
+            "label": "设备数量",
+            "info": "当前可用的运算设备数。",
+        },
+        "ko": {
+            "label": "디바이스 수",
+            "info": "사용 가능한 디바이스 수.",
+        },
+    },
+    "ds_stage": {
+        "en": {
+            "label": "DeepSpeed stage",
+            "info": "DeepSpeed stage for distributed training.",
+        },
+        "ru": {
+            "label": "Этап DeepSpeed",
+            "info": "Этап DeepSpeed для распределенного обучения.",
+        },
+        "zh": {
+            "label": "DeepSpeed stage",
+            "info": "多卡训练的 DeepSpeed stage。",
+        },
+        "ko": {
+            "label": "DeepSpeed 단계",
+            "info": "분산 학습을 위한 DeepSpeed 단계.",
+        },
+    },
+    "ds_offload": {
+        "en": {
+            "label": "Enable offload",
+            "info": "Enable DeepSpeed offload (slow down training).",
+        },
+        "ru": {
+            "label": "Включить выгрузку",
+            "info": "включить выгрузку DeepSpeed (замедлит обучение).",
+        },
+        "zh": {
+            "label": "使用 offload",
+            "info": "使用 DeepSpeed offload（会减慢速度）。",
+        },
+        "ko": {
+            "label": "오프로딩 활성화",
+            "info": "DeepSpeed 오프로딩 활성화 (훈련 속도 느려짐).",
+        },
+    },
+    "output_box": {
+        "en": {
+            "value": "Ready.",
+        },
+        "ru": {
+            "value": "Готово.",
+        },
+        "zh": {
+            "value": "准备就绪。",
+        },
+        "ko": {
+            "value": "준비 완료.",
+        },
+    },
+    "loss_viewer": {
+        "en": {
+            "label": "Loss",
+        },
+        "ru": {
+            "label": "Потери",
+        },
+        "zh": {
+            "label": "损失",
+        },
+        "ko": {
+            "label": "손실",
+        },
+    },
+    "predict": {
+        "en": {
+            "label": "Save predictions",
+        },
+        "ru": {
+            "label": "Сохранить предсказания",
+        },
+        "zh": {
+            "label": "保存预测结果",
+        },
+        "ko": {
+            "label": "예측 결과 저장",
+        },
+    },
+    "infer_backend": {
+        "en": {
+            "label": "Inference engine",
+        },
+        "ru": {
+            "label": "Инференс движок",
+        },
+        "zh": {
+            "label": "推理引擎",
+        },
+        "ko": {
+            "label": "추론 엔진",
+        },
+    },
+    "infer_dtype": {
+        "en": {
+            "label": "Inference data type",
+        },
+        "ru": {
+            "label": "Тип данных для вывода",
+        },
+        "zh": {
+            "label": "推理数据类型",
+        },
+        "ko": {
+            "label": "추론 데이터 유형",
+        },
+    },
+    "load_btn": {
+        "en": {
+            "value": "Load model",
+        },
+        "ru": {
+            "value": "Загрузить модель",
+        },
+        "zh": {
+            "value": "加载模型",
+        },
+        "ko": {
+            "value": "모델 불러오기",
+        },
+    },
+    "unload_btn": {
+        "en": {
+            "value": "Unload model",
+        },
+        "ru": {
+            "value": "Выгрузить модель",
+        },
+        "zh": {
+            "value": "卸载模型",
+        },
+        "ko": {
+            "value": "모델 언로드",
+        },
+    },
+    "info_box": {
+        "en": {
+            "value": "Model unloaded, please load a model first.",
+        },
+        "ru": {
+            "value": "Модель не загружена, загрузите модель сначала.",
+        },
+        "zh": {
+            "value": "模型未加载，请先加载模型。",
+        },
+        "ko": {
+            "value": "모델이 언로드되었습니다. 모델을 먼저 불러오십시오.",
+        },
+    },
+    "role": {
+        "en": {
+            "label": "Role",
+        },
+        "ru": {
+            "label": "Роль",
+        },
+        "zh": {
+            "label": "角色",
+        },
+        "ko": {
+            "label": "역할",
+        },
+    },
+    "system": {
+        "en": {
+            "placeholder": "System prompt (optional)",
+        },
+        "ru": {
+            "placeholder": "Системный запрос (по желанию)",
+        },
+        "zh": {
+            "placeholder": "系统提示词（非必填）",
+        },
+        "ko": {
+            "placeholder": "시스템 프롬프트 (선택 사항)",
+        },
+    },
+    "tools": {
+        "en": {
+            "placeholder": "Tools (optional)",
+        },
+        "ru": {
+            "placeholder": "Инструменты (по желанию)",
+        },
+        "zh": {
+            "placeholder": "工具列表（非必填）",
+        },
+        "ko": {
+            "placeholder": "툴 (선택 사항)",
+        },
+    },
+    "image": {
+        "en": {
+            "label": "Image (optional)",
+        },
+        "ru": {
+            "label": "Изображение (по желанию)",
+        },
+        "zh": {
+            "label": "图像（非必填）",
+        },
+        "ko": {
+            "label": "이미지 (선택 사항)",
+        },
+    },
+    "video": {
+        "en": {
+            "label": "Video (optional)",
+        },
+        "ru": {
+            "label": "Видео (по желанию)",
+        },
+        "zh": {
+            "label": "视频（非必填）",
+        },
+        "ko": {
+            "label": "비디오 (선택 사항)",
+        },
+    },
+    "query": {
+        "en": {
+            "placeholder": "Input...",
+        },
+        "ru": {
+            "placeholder": "Ввод...",
+        },
+        "zh": {
+            "placeholder": "输入...",
+        },
+        "ko": {
+            "placeholder": "입력...",
+        },
+    },
+    "submit_btn": {
+        "en": {
+            "value": "Submit",
+        },
+        "ru": {
+            "value": "Отправить",
+        },
+        "zh": {
+            "value": "提交",
+        },
+        "ko": {
+            "value": "제출",
+        },
+    },
+    "max_length": {
+        "en": {
+            "label": "Maximum length",
+        },
+        "ru": {
+            "label": "Максимальная длина",
+        },
+        "zh": {
+            "label": "最大长度",
+        },
+        "ko": {
+            "label": "최대 길이",
+        },
+    },
+    "max_new_tokens": {
+        "en": {
+            "label": "Maximum new tokens",
+        },
+        "ru": {
+            "label": "Максимальное количество новых токенов",
+        },
+        "zh": {
+            "label": "最大生成长度",
+        },
+        "ko": {
+            "label": "응답의 최대 길이",
+        },
+    },
+    "top_p": {
+        "en": {
+            "label": "Top-p",
+        },
+        "ru": {
+            "label": "Лучшие-p",
+        },
+        "zh": {
+            "label": "Top-p 采样值",
+        },
+        "ko": {
+            "label": "Top-p",
+        },
+    },
+    "temperature": {
+        "en": {
+            "label": "Temperature",
+        },
+        "ru": {
+            "label": "Температура",
+        },
+        "zh": {
+            "label": "温度系数",
+        },
+        "ko": {
+            "label": "온도",
+        },
+    },
+    "clear_btn": {
+        "en": {
+            "value": "Clear history",
+        },
+        "ru": {
+            "value": "Очистить историю",
+        },
+        "zh": {
+            "value": "清空历史",
+        },
+        "ko": {
+            "value": "기록 지우기",
+        },
+    },
+    "export_size": {
+        "en": {
+            "label": "Max shard size (GB)",
+            "info": "The maximum size for a model file.",
+        },
+        "ru": {
+            "label": "Максимальный размер фрагмента (ГБ)",
+            "info": "Максимальный размер файла модели.",
+        },
+        "zh": {
+            "label": "最大分块大小（GB）",
+            "info": "单个模型文件的最大大小。",
+        },
+        "ko": {
+            "label": "최대 샤드 크기 (GB)",
+            "info": "모델 파일의 최대 크기.",
+        },
+    },
+    "export_quantization_bit": {
+        "en": {
+            "label": "Export quantization bit.",
+            "info": "Quantizing the exported model.",
+        },
+        "ru": {
+            "label": "Экспорт бита квантования",
+            "info": "Квантование экспортируемой модели.",
+        },
+        "zh": {
+            "label": "导出量化等级",
+            "info": "量化导出模型。",
+        },
+        "ko": {
+            "label": "양자화 비트 내보내기",
+            "info": "내보낸 모델의 양자화.",
+        },
+    },
+    "export_quantization_dataset": {
+        "en": {
+            "label": "Export quantization dataset",
+            "info": "The calibration dataset used for quantization.",
+        },
+        "ru": {
+            "label": "Экспорт набора данных для квантования",
+            "info": "Набор данных калибровки, используемый для квантования.",
+        },
+        "zh": {
+            "label": "导出量化数据集",
+            "info": "量化过程中使用的校准数据集。",
+        },
+        "ko": {
+            "label": "양자화 데이터셋 내보내기",
+            "info": "양자화에 사용되는 교정 데이터셋.",
+        },
+    },
+    "export_device": {
+        "en": {
+            "label": "Export device",
+            "info": "Which device should be used to export model.",
+        },
+        "ru": {
+            "label": "Экспорт устройство",
+            "info": "Какое устройство следует использовать для экспорта модели.",
+        },
+        "zh": {
+            "label": "导出设备",
+            "info": "导出模型使用的设备类型。",
+        },
+        "ko": {
+            "label": "내보낼 장치",
+            "info": "모델을 내보내는 데 사용할 장치.",
+        },
+    },
+    "export_legacy_format": {
+        "en": {
+            "label": "Export legacy format",
+            "info": "Do not use safetensors to save the model.",
+        },
+        "ru": {
+            "label": "Экспорт в устаревший формат",
+            "info": "Не использовать safetensors для сохранения модели.",
+        },
+        "zh": {
+            "label": "导出旧格式",
+            "info": "不使用 safetensors 格式保存模型。",
+        },
+        "ko": {
+            "label": "레거시 형식 내보내기",
+            "info": "모델을 저장하는 데 safetensors를 사용하지 않습니다.",
+        },
+    },
+    "export_dir": {
+        "en": {
+            "label": "Export dir",
+            "info": "Directory to save exported model.",
+        },
+        "ru": {
+            "label": "Каталог экспорта",
+            "info": "Каталог для сохранения экспортированной модели.",
+        },
+        "zh": {
+            "label": "导出目录",
+            "info": "保存导出模型的文件夹路径。",
+        },
+        "ko": {
+            "label": "내보내기 디렉토리",
+            "info": "내보낸 모델을 저장할 디렉토리.",
+        },
+    },
+    "export_hub_model_id": {
+        "en": {
+            "label": "HF Hub ID (optional)",
+            "info": "Repo ID for uploading model to Hugging Face hub.",
+        },
+        "ru": {
+            "label": "HF Hub ID (опционально)",
+            "info": "Идентификатор репозитория для загрузки модели на Hugging Face hub.",
+        },
+        "zh": {
+            "label": "HF Hub ID（非必填）",
+            "info": "用于将模型上传至 Hugging Face Hub 的仓库 ID。",
+        },
+        "ko": {
+            "label": "HF 허브 ID (선택 사항)",
+            "info": "모델을 Hugging Face 허브에 업로드하기 위한 레포 ID.",
+        },
+    },
+    "export_btn": {
+        "en": {
+            "value": "Export",
+        },
+        "ru": {
+            "value": "Экспорт",
+        },
+        "zh": {
+            "value": "开始导出",
+        },
+        "ko": {
+            "value": "내보내기",
+        },
+    },
+}
+
+
+ALERTS = {
+    "err_conflict": {
+        "en": "A process is in running, please abort it first.",
+        "ru": "Процесс уже запущен, пожалуйста, сначала прервите его.",
+        "zh": "任务已存在，请先中断训练。",
+        "ko": "프로세스가 실행 중입니다. 먼저 중단하십시오.",
+    },
+    "err_exists": {
+        "en": "You have loaded a model, please unload it first.",
+        "ru": "Вы загрузили модель, сначала разгрузите ее.",
+        "zh": "模型已存在，请先卸载模型。",
+        "ko": "모델이 로드되었습니다. 먼저 언로드하십시오.",
+    },
+    "err_no_model": {
+        "en": "Please select a model.",
+        "ru": "Пожалуйста, выберите модель.",
+        "zh": "请选择模型。",
+        "ko": "모델을 선택하십시오.",
+    },
+    "err_no_path": {
+        "en": "Model not found.",
+        "ru": "Модель не найдена.",
+        "zh": "模型未找到。",
+        "ko": "모델을 찾을 수 없습니다.",
+    },
+    "err_no_dataset": {
+        "en": "Please choose a dataset.",
+        "ru": "Пожалуйста, выберите набор данных.",
+        "zh": "请选择数据集。",
+        "ko": "데이터 세트를 선택하십시오.",
+    },
+    "err_no_adapter": {
+        "en": "Please select an adapter.",
+        "ru": "Пожалуйста, выберите адаптер.",
+        "zh": "请选择适配器。",
+        "ko": "어댑터를 선택하십시오.",
+    },
+    "err_no_output_dir": {
+        "en": "Please provide output dir.",
+        "ru": "Пожалуйста, укажите выходную директорию.",
+        "zh": "请填写输出目录。",
+        "ko": "출력 디렉토리를 제공하십시오.",
+    },
+    "err_no_reward_model": {
+        "en": "Please select a reward model.",
+        "ru": "Пожалуйста, выберите модель вознаграждения.",
+        "zh": "请选择奖励模型。",
+        "ko": "리워드 모델을 선택하십시오.",
+    },
+    "err_no_export_dir": {
+        "en": "Please provide export dir.",
+        "ru": "Пожалуйста, укажите каталог для экспорта.",
+        "zh": "请填写导出目录。",
+        "ko": "Export 디렉토리를 제공하십시오.",
+    },
+    "err_gptq_lora": {
+        "en": "Please merge adapters before quantizing the model.",
+        "ru": "Пожалуйста, объедините адаптеры перед квантованием модели.",
+        "zh": "量化模型前请先合并适配器。",
+        "ko": "모델을 양자화하기 전에 어댑터를 병합하십시오.",
+    },
+    "err_failed": {
+        "en": "Failed.",
+        "ru": "Ошибка.",
+        "zh": "训练出错。",
+        "ko": "실패했습니다.",
+    },
+    "err_demo": {
+        "en": "Training is unavailable in demo mode, duplicate the space to a private one first.",
+        "ru": "Обучение недоступно в демонстрационном режиме, сначала скопируйте пространство в частное.",
+        "zh": "展示模式不支持训练，请先复制到私人空间。",
+        "ko": "데모 모드에서는 훈련을 사용할 수 없습니다. 먼저 프라이빗 레포지토리로 작업 공간을 복제하십시오.",
+    },
+    "err_tool_name": {
+        "en": "Tool name not found.",
+        "ru": "Имя инструмента не найдено.",
+        "zh": "工具名称未找到。",
+        "ko": "툴 이름을 찾을 수 없습니다.",
+    },
+    "err_json_schema": {
+        "en": "Invalid JSON schema.",
+        "ru": "Неверная схема JSON.",
+        "zh": "Json 格式错误。",
+        "ko": "잘못된 JSON 스키마입니다.",
+    },
+    "err_config_not_found": {
+        "en": "Config file is not found.",
+        "ru": "Файл конфигурации не найден.",
+        "zh": "未找到配置文件。",
+        "ko": "Config 파일을 찾을 수 없습니다.",
+    },
+    "warn_no_cuda": {
+        "en": "CUDA environment was not detected.",
+        "ru": "Среда CUDA не обнаружена.",
+        "zh": "未检测到 CUDA 环境。",
+        "ko": "CUDA 환경이 감지되지 않았습니다.",
+    },
+    "warn_output_dir_exists": {
+        "en": "Output dir already exists, will resume training from here.",
+        "ru": "Выходной каталог уже существует, обучение будет продолжено отсюда.",
+        "zh": "输出目录已存在，将从该断点恢复训练。",
+        "ko": "출력 디렉토리가 이미 존재합니다. 위 출력 디렉토리에 저장된 학습을 재개합니다.",
+    },
+    "info_aborting": {
+        "en": "Aborted, wait for terminating...",
+        "ru": "Прервано, ожидание завершения...",
+        "zh": "训练中断，正在等待进程结束……",
+        "ko": "중단되었습니다. 종료를 기다리십시오...",
+    },
+    "info_aborted": {
+        "en": "Ready.",
+        "ru": "Готово.",
+        "zh": "准备就绪。",
+        "ko": "준비되었습니다.",
+    },
+    "info_finished": {
+        "en": "Finished.",
+        "ru": "Завершено.",
+        "zh": "训练完毕。",
+        "ko": "완료되었습니다.",
+    },
+    "info_config_saved": {
+        "en": "Arguments have been saved at: ",
+        "ru": "Аргументы были сохранены по адресу: ",
+        "zh": "训练参数已保存至：",
+        "ko": "매개변수가 저장되었습니다: ",
+    },
+    "info_config_loaded": {
+        "en": "Arguments have been restored.",
+        "ru": "Аргументы были восстановлены.",
+        "zh": "训练参数已载入。",
+        "ko": "매개변수가 복원되었습니다.",
+    },
+    "info_loading": {
+        "en": "Loading model...",
+        "ru": "Загрузка модели...",
+        "zh": "加载中……",
+        "ko": "모델 로딩 중...",
+    },
+    "info_unloading": {
+        "en": "Unloading model...",
+        "ru": "Выгрузка модели...",
+        "zh": "卸载中……",
+        "ko": "모델 언로딩 중...",
+    },
+    "info_loaded": {
+        "en": "Model loaded, now you can chat with your model!",
+        "ru": "Модель загружена, теперь вы можете общаться с вашей моделью!",
+        "zh": "模型已加载，可以开始聊天了！",
+        "ko": "모델이 로드되었습니다. 이제 모델과 채팅할 수 있습니다!",
+    },
+    "info_unloaded": {
+        "en": "Model unloaded.",
+        "ru": "Модель выгружена.",
+        "zh": "模型已卸载。",
+        "ko": "모델이 언로드되었습니다.",
+    },
+    "info_exporting": {
+        "en": "Exporting model...",
+        "ru": "Экспорт модели...",
+        "zh": "正在导出模型……",
+        "ko": "모델 내보내기 중...",
+    },
+    "info_exported": {
+        "en": "Model exported.",
+        "ru": "Модель экспортирована.",
+        "zh": "模型导出完成。",
+        "ko": "모델이 내보내졌습니다.",
+    },
+}

LLaMA-Factory/src/llamafactory/webui/manager.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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.
+
+from typing import TYPE_CHECKING, Dict, Generator, List, Set, Tuple
+
+
+if TYPE_CHECKING:
+    from gradio.components import Component
+
+
+class Manager:
+    def __init__(self) -> None:
+        self._id_to_elem: Dict[str, "Component"] = {}
+        self._elem_to_id: Dict["Component", str] = {}
+
+    def add_elems(self, tab_name: str, elem_dict: Dict[str, "Component"]) -> None:
+        r"""
+        Adds elements to manager.
+        """
+        for elem_name, elem in elem_dict.items():
+            elem_id = f"{tab_name}.{elem_name}"
+            self._id_to_elem[elem_id] = elem
+            self._elem_to_id[elem] = elem_id
+
+    def get_elem_list(self) -> List["Component"]:
+        r"""
+        Returns the list of all elements.
+        """
+        return list(self._id_to_elem.values())
+
+    def get_elem_iter(self) -> Generator[Tuple[str, "Component"], None, None]:
+        r"""
+        Returns an iterator over all elements with their names.
+        """
+        for elem_id, elem in self._id_to_elem.items():
+            yield elem_id.split(".")[-1], elem
+
+    def get_elem_by_id(self, elem_id: str) -> "Component":
+        r"""
+        Gets element by id.
+
+        Example: top.lang, train.dataset
+        """
+        return self._id_to_elem[elem_id]
+
+    def get_id_by_elem(self, elem: "Component") -> str:
+        r"""
+        Gets id by element.
+        """
+        return self._elem_to_id[elem]
+
+    def get_base_elems(self) -> Set["Component"]:
+        r"""
+        Gets the base elements that are commonly used.
+        """
+        return {
+            self._id_to_elem["top.lang"],
+            self._id_to_elem["top.model_name"],
+            self._id_to_elem["top.model_path"],
+            self._id_to_elem["top.finetuning_type"],
+            self._id_to_elem["top.checkpoint_path"],
+            self._id_to_elem["top.quantization_bit"],
+            self._id_to_elem["top.quantization_method"],
+            self._id_to_elem["top.template"],
+            self._id_to_elem["top.rope_scaling"],
+            self._id_to_elem["top.booster"],
+        }

LLaMA-Factory/src/llamafactory/webui/runner.py

+# Copyright 2024 the LlamaFactory team.
+#
+# 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 copy import deepcopy
+from subprocess import Popen, TimeoutExpired
+from typing import TYPE_CHECKING, Any, Dict, Generator, Optional
+
+from transformers.trainer import TRAINING_ARGS_NAME
+
+from ..extras.constants import LLAMABOARD_CONFIG, PEFT_METHODS, TRAINING_STAGES
+from ..extras.misc import is_gpu_or_npu_available, torch_gc
+from ..extras.packages import is_gradio_available, is_transformers_version_equal_to_4_46
+from .common import DEFAULT_CACHE_DIR, DEFAULT_CONFIG_DIR, QUANTIZATION_BITS, get_save_dir, load_config
+from .locales import ALERTS, LOCALES
+from .utils import abort_process, gen_cmd, get_eval_results, get_trainer_info, load_args, save_args, save_cmd
+
+
+if is_gradio_available():
+    import gradio as gr
+
+
+if TYPE_CHECKING:
+    from gradio.components import Component
+
+    from .manager import Manager
+
+
+class Runner:
+    def __init__(self, manager: "Manager", demo_mode: bool = False) -> None:
+        self.manager = manager
+        self.demo_mode = demo_mode
+        """ Resume """
+        self.trainer: Optional["Popen"] = None
+        self.do_train = True
+        self.running_data: Dict["Component", Any] = None
+        """ State """
+        self.aborted = False
+        self.running = False
+
+    def set_abort(self) -> None:
+        self.aborted = True
+        if self.trainer is not None:
+            abort_process(self.trainer.pid)
+
+    def _initialize(self, data: Dict["Component", Any], do_train: bool, from_preview: bool) -> str:
+        get = lambda elem_id: data[self.manager.get_elem_by_id(elem_id)]
+        lang, model_name, model_path = get("top.lang"), get("top.model_name"), get("top.model_path")
+        dataset = get("train.dataset") if do_train else get("eval.dataset")
+
+        if self.running:
+            return ALERTS["err_conflict"][lang]
+
+        if not model_name:
+            return ALERTS["err_no_model"][lang]
+
+        if not model_path:
+            return ALERTS["err_no_path"][lang]
+
+        if not dataset:
+            return ALERTS["err_no_dataset"][lang]
+
+        if not from_preview and self.demo_mode:
+            return ALERTS["err_demo"][lang]
+
+        if do_train:
+            if not get("train.output_dir"):
+                return ALERTS["err_no_output_dir"][lang]
+
+            try:
+                json.loads(get("train.extra_args"))
+            except json.JSONDecodeError:
+                return ALERTS["err_json_schema"][lang]
+
+            stage = TRAINING_STAGES[get("train.training_stage")]
+            if stage == "ppo" and not get("train.reward_model"):
+                return ALERTS["err_no_reward_model"][lang]
+        else:
+            if not get("eval.output_dir"):
+                return ALERTS["err_no_output_dir"][lang]
+
+        if not from_preview and not is_gpu_or_npu_available():
+            gr.Warning(ALERTS["warn_no_cuda"][lang])
+
+        return ""
+
+    def _finalize(self, lang: str, finish_info: str) -> str:
+        finish_info = ALERTS["info_aborted"][lang] if self.aborted else finish_info
+        gr.Info(finish_info)
+        self.trainer = None
+        self.aborted = False
+        self.running = False
+        self.running_data = None
+        torch_gc()
+        return finish_info
+
+    def _parse_train_args(self, data: Dict["Component", Any]) -> Dict[str, Any]:
+        get = lambda elem_id: data[self.manager.get_elem_by_id(elem_id)]
+        model_name, finetuning_type = get("top.model_name"), get("top.finetuning_type")
+        user_config = load_config()
+
+        args = dict(
+            stage=TRAINING_STAGES[get("train.training_stage")],
+            do_train=True,
+            model_name_or_path=get("top.model_path"),
+            cache_dir=user_config.get("cache_dir", None),
+            preprocessing_num_workers=16,
+            finetuning_type=finetuning_type,
+            template=get("top.template"),
+            rope_scaling=get("top.rope_scaling") if get("top.rope_scaling") in ["linear", "dynamic"] else None,
+            flash_attn="fa2" if get("top.booster") == "flashattn2" else "auto",
+            use_unsloth=(get("top.booster") == "unsloth"),
+            enable_liger_kernel=(get("top.booster") == "liger_kernel"),
+            dataset_dir=get("train.dataset_dir"),
+            dataset=",".join(get("train.dataset")),
+            cutoff_len=get("train.cutoff_len"),
+            learning_rate=float(get("train.learning_rate")),
+            num_train_epochs=float(get("train.num_train_epochs")),
+            max_samples=int(get("train.max_samples")),
+            per_device_train_batch_size=get("train.batch_size"),
+            gradient_accumulation_steps=get("train.gradient_accumulation_steps"),
+            lr_scheduler_type=get("train.lr_scheduler_type"),
+            max_grad_norm=float(get("train.max_grad_norm")),
+            logging_steps=get("train.logging_steps"),
+            save_steps=get("train.save_steps"),
+            warmup_steps=get("train.warmup_steps"),
+            neftune_noise_alpha=get("train.neftune_alpha") or None,
+            packing=get("train.packing") or get("train.neat_packing"),
+            neat_packing=get("train.neat_packing"),
+            train_on_prompt=get("train.train_on_prompt"),
+            mask_history=get("train.mask_history"),
+            resize_vocab=get("train.resize_vocab"),
+            use_llama_pro=get("train.use_llama_pro"),
+            shift_attn=get("train.shift_attn"),
+            report_to="all" if get("train.report_to") else "none",
+            use_galore=get("train.use_galore"),
+            use_badam=get("train.use_badam"),
+            use_swanlab=get("train.use_swanlab"),
+            output_dir=get_save_dir(model_name, finetuning_type, get("train.output_dir")),
+            fp16=(get("train.compute_type") == "fp16"),
+            bf16=(get("train.compute_type") == "bf16"),
+            pure_bf16=(get("train.compute_type") == "pure_bf16"),
+            plot_loss=True,
+            trust_remote_code=True,
+            ddp_timeout=180000000,
+            include_num_input_tokens_seen=False if is_transformers_version_equal_to_4_46() else True,  # FIXME
+        )
+        args.update(json.loads(get("train.extra_args")))
+
+        # checkpoints
+        if get("top.checkpoint_path"):
+            if finetuning_type in PEFT_METHODS:  # list
+                args["adapter_name_or_path"] = ",".join(
+                    [get_save_dir(model_name, finetuning_type, adapter) for adapter in get("top.checkpoint_path")]
+                )
+            else:  # str
+                args["model_name_or_path"] = get_save_dir(model_name, finetuning_type, get("top.checkpoint_path"))
+
+        # quantization
+        if get("top.quantization_bit") in QUANTIZATION_BITS:
+            args["quantization_bit"] = int(get("top.quantization_bit"))
+            args["quantization_method"] = get("top.quantization_method")
+
+        # freeze config
+        if args["finetuning_type"] == "freeze":
+            args["freeze_trainable_layers"] = get("train.freeze_trainable_layers")
+            args["freeze_trainable_modules"] = get("train.freeze_trainable_modules")
+            args["freeze_extra_modules"] = get("train.freeze_extra_modules") or None
+
+        # lora config
+        if args["finetuning_type"] == "lora":
+            args["lora_rank"] = get("train.lora_rank")
+            args["lora_alpha"] = get("train.lora_alpha")
+            args["lora_dropout"] = get("train.lora_dropout")
+            args["loraplus_lr_ratio"] = get("train.loraplus_lr_ratio") or None
+            args["create_new_adapter"] = get("train.create_new_adapter")
+            args["use_rslora"] = get("train.use_rslora")
+            args["use_dora"] = get("train.use_dora")
+            args["pissa_init"] = get("train.use_pissa")
+            args["pissa_convert"] = get("train.use_pissa")
+            args["lora_target"] = get("train.lora_target") or "all"
+            args["additional_target"] = get("train.additional_target") or None
+
+            if args["use_llama_pro"]:
+                args["freeze_trainable_layers"] = get("train.freeze_trainable_layers")
+
+        # rlhf config
+        if args["stage"] == "ppo":
+            if finetuning_type in PEFT_METHODS:
+                args["reward_model"] = ",".join(
+                    [get_save_dir(model_name, finetuning_type, adapter) for adapter in get("train.reward_model")]
+                )
+            else:
+                args["reward_model"] = get_save_dir(model_name, finetuning_type, get("train.reward_model"))
+
+            args["reward_model_type"] = "lora" if finetuning_type == "lora" else "full"
+            args["ppo_score_norm"] = get("train.ppo_score_norm")
+            args["ppo_whiten_rewards"] = get("train.ppo_whiten_rewards")
+            args["top_k"] = 0
+            args["top_p"] = 0.9
+        elif args["stage"] in ["dpo", "kto"]:
+            args["pref_beta"] = get("train.pref_beta")
+            args["pref_ftx"] = get("train.pref_ftx")
+            args["pref_loss"] = get("train.pref_loss")
+
+        # galore config
+        if args["use_galore"]:
+            args["galore_rank"] = get("train.galore_rank")
+            args["galore_update_interval"] = get("train.galore_update_interval")
+            args["galore_scale"] = get("train.galore_scale")
+            args["galore_target"] = get("train.galore_target")
+
+        # badam config
+        if args["use_badam"]:
+            args["badam_mode"] = get("train.badam_mode")
+            args["badam_switch_mode"] = get("train.badam_switch_mode")
+            args["badam_switch_interval"] = get("train.badam_switch_interval")
+            args["badam_update_ratio"] = get("train.badam_update_ratio")
+
+        # swanlab config
+        if get("train.use_swanlab"):
+            args["swanlab_project"] = get("train.swanlab_project")
+            args["swanlab_run_name"] = get("train.swanlab_run_name")
+            args["swanlab_workspace"] = get("train.swanlab_workspace")
+            args["swanlab_api_key"] = get("train.swanlab_api_key")
+            args["swanlab_mode"] = get("train.swanlab_mode")
+
+        # eval config
+        if get("train.val_size") > 1e-6 and args["stage"] != "ppo":
+            args["val_size"] = get("train.val_size")
+            args["eval_strategy"] = "steps"
+            args["eval_steps"] = args["save_steps"]
+            args["per_device_eval_batch_size"] = args["per_device_train_batch_size"]
+
+        # ds config
+        if get("train.ds_stage") != "none":
+            ds_stage = get("train.ds_stage")
+            ds_offload = "offload_" if get("train.ds_offload") else ""
+            args["deepspeed"] = os.path.join(DEFAULT_CACHE_DIR, f"ds_z{ds_stage}_{ds_offload}config.json")
+
+        return args
+
+    def _parse_eval_args(self, data: Dict["Component", Any]) -> Dict[str, Any]:
+        get = lambda elem_id: data[self.manager.get_elem_by_id(elem_id)]
+        model_name, finetuning_type = get("top.model_name"), get("top.finetuning_type")
+        user_config = load_config()
+
+        args = dict(
+            stage="sft",
+            model_name_or_path=get("top.model_path"),
+            cache_dir=user_config.get("cache_dir", None),
+            preprocessing_num_workers=16,
+            finetuning_type=finetuning_type,
+            quantization_method=get("top.quantization_method"),
+            template=get("top.template"),
+            rope_scaling=get("top.rope_scaling") if get("top.rope_scaling") in ["linear", "dynamic"] else None,
+            flash_attn="fa2" if get("top.booster") == "flashattn2" else "auto",
+            use_unsloth=(get("top.booster") == "unsloth"),
+            dataset_dir=get("eval.dataset_dir"),
+            eval_dataset=",".join(get("eval.dataset")),
+            cutoff_len=get("eval.cutoff_len"),
+            max_samples=int(get("eval.max_samples")),
+            per_device_eval_batch_size=get("eval.batch_size"),
+            predict_with_generate=True,
+            max_new_tokens=get("eval.max_new_tokens"),
+            top_p=get("eval.top_p"),
+            temperature=get("eval.temperature"),
+            output_dir=get_save_dir(model_name, finetuning_type, get("eval.output_dir")),
+            trust_remote_code=True,
+        )
+
+        if get("eval.predict"):
+            args["do_predict"] = True
+        else:
+            args["do_eval"] = True
+
+        # checkpoints
+        if get("top.checkpoint_path"):
+            if finetuning_type in PEFT_METHODS:  # list
+                args["adapter_name_or_path"] = ",".join(
+                    [get_save_dir(model_name, finetuning_type, adapter) for adapter in get("top.checkpoint_path")]
+                )
+            else:  # str
+                args["model_name_or_path"] = get_save_dir(model_name, finetuning_type, get("top.checkpoint_path"))
+
+        # quantization
+        if get("top.quantization_bit") in QUANTIZATION_BITS:
+            args["quantization_bit"] = int(get("top.quantization_bit"))
+            args["quantization_method"] = get("top.quantization_method")
+
+        return args
+
+    def _preview(self, data: Dict["Component", Any], do_train: bool) -> Generator[Dict["Component", str], None, None]:
+        output_box = self.manager.get_elem_by_id("{}.output_box".format("train" if do_train else "eval"))
+        error = self._initialize(data, do_train, from_preview=True)
+        if error:
+            gr.Warning(error)
+            yield {output_box: error}
+        else:
+            args = self._parse_train_args(data) if do_train else self._parse_eval_args(data)
+            yield {output_box: gen_cmd(args)}
+
+    def _launch(self, data: Dict["Component", Any], do_train: bool) -> Generator[Dict["Component", Any], None, None]:
+        output_box = self.manager.get_elem_by_id("{}.output_box".format("train" if do_train else "eval"))
+        error = self._initialize(data, do_train, from_preview=False)
+        if error:
+            gr.Warning(error)
+            yield {output_box: error}
+        else:
+            self.do_train, self.running_data = do_train, data
+            args = self._parse_train_args(data) if do_train else self._parse_eval_args(data)
+
+            os.makedirs(args["output_dir"], exist_ok=True)
+            save_args(os.path.join(args["output_dir"], LLAMABOARD_CONFIG), self._form_config_dict(data))
+
+            env = deepcopy(os.environ)
+            env["LLAMABOARD_ENABLED"] = "1"
+            env["LLAMABOARD_WORKDIR"] = args["output_dir"]
+            if args.get("deepspeed", None) is not None:
+                env["FORCE_TORCHRUN"] = "1"
+
+            self.trainer = Popen(["llamafactory-cli", "train", save_cmd(args)], env=env)
+            yield from self.monitor()
+
+    def _form_config_dict(self, data: Dict["Component", Any]) -> Dict[str, Any]:
+        config_dict = {}
+        skip_ids = ["top.lang", "top.model_path", "train.output_dir", "train.config_path"]
+        for elem, value in data.items():
+            elem_id = self.manager.get_id_by_elem(elem)
+            if elem_id not in skip_ids:
+                config_dict[elem_id] = value
+
+        return config_dict
+
+    def preview_train(self, data):
+        yield from self._preview(data, do_train=True)
+
+    def preview_eval(self, data):
+        yield from self._preview(data, do_train=False)
+
+    def run_train(self, data):
+        yield from self._launch(data, do_train=True)
+
+    def run_eval(self, data):
+        yield from self._launch(data, do_train=False)
+
+    def monitor(self):
+        self.aborted = False
+        self.running = True
+
+        get = lambda elem_id: self.running_data[self.manager.get_elem_by_id(elem_id)]
+        lang, model_name, finetuning_type = get("top.lang"), get("top.model_name"), get("top.finetuning_type")
+        output_dir = get("{}.output_dir".format("train" if self.do_train else "eval"))
+        output_path = get_save_dir(model_name, finetuning_type, output_dir)
+
+        output_box = self.manager.get_elem_by_id("{}.output_box".format("train" if self.do_train else "eval"))
+        progress_bar = self.manager.get_elem_by_id("{}.progress_bar".format("train" if self.do_train else "eval"))
+        loss_viewer = self.manager.get_elem_by_id("train.loss_viewer") if self.do_train else None
+
+        running_log = ""
+        while self.trainer is not None:
+            if self.aborted:
+                yield {
+                    output_box: ALERTS["info_aborting"][lang],
+                    progress_bar: gr.Slider(visible=False),
+                }
+            else:
+                running_log, running_progress, running_loss = get_trainer_info(output_path, self.do_train)
+                return_dict = {
+                    output_box: running_log,
+                    progress_bar: running_progress,
+                }
+                if running_loss is not None:
+                    return_dict[loss_viewer] = running_loss
+
+                yield return_dict
+
+            try:
+                self.trainer.wait(2)
+                self.trainer = None
+            except TimeoutExpired:
+                continue
+
+        if self.do_train:
+            if os.path.exists(os.path.join(output_path, TRAINING_ARGS_NAME)):
+                finish_info = ALERTS["info_finished"][lang]
+            else:
+                finish_info = ALERTS["err_failed"][lang]
+        else:
+            if os.path.exists(os.path.join(output_path, "all_results.json")):
+                finish_info = get_eval_results(os.path.join(output_path, "all_results.json"))
+            else:
+                finish_info = ALERTS["err_failed"][lang]
+
+        return_dict = {
+            output_box: self._finalize(lang, finish_info) + "\n\n" + running_log,
+            progress_bar: gr.Slider(visible=False),
+        }
+        yield return_dict
+
+    def save_args(self, data):
+        output_box = self.manager.get_elem_by_id("train.output_box")
+        error = self._initialize(data, do_train=True, from_preview=True)
+        if error:
+            gr.Warning(error)
+            return {output_box: error}
+
+        lang = data[self.manager.get_elem_by_id("top.lang")]
+        config_path = data[self.manager.get_elem_by_id("train.config_path")]
+        os.makedirs(DEFAULT_CONFIG_DIR, exist_ok=True)
+        save_path = os.path.join(DEFAULT_CONFIG_DIR, config_path)
+
+        save_args(save_path, self._form_config_dict(data))
+        return {output_box: ALERTS["info_config_saved"][lang] + save_path}
+
+    def load_args(self, lang: str, config_path: str):
+        output_box = self.manager.get_elem_by_id("train.output_box")
+        config_dict = load_args(os.path.join(DEFAULT_CONFIG_DIR, config_path))
+        if config_dict is None:
+            gr.Warning(ALERTS["err_config_not_found"][lang])
+            return {output_box: ALERTS["err_config_not_found"][lang]}
+
+        output_dict: Dict["Component", Any] = {output_box: ALERTS["info_config_loaded"][lang]}
+        for elem_id, value in config_dict.items():
+            output_dict[self.manager.get_elem_by_id(elem_id)] = value
+
+        return output_dict
+
+    def check_output_dir(self, lang: str, model_name: str, finetuning_type: str, output_dir: str):
+        output_box = self.manager.get_elem_by_id("train.output_box")
+        output_dict: Dict["Component", Any] = {output_box: LOCALES["output_box"][lang]["value"]}
+        if model_name and output_dir and os.path.isdir(get_save_dir(model_name, finetuning_type, output_dir)):
+            gr.Warning(ALERTS["warn_output_dir_exists"][lang])
+            output_dict[output_box] = ALERTS["warn_output_dir_exists"][lang]
+
+            output_dir = get_save_dir(model_name, finetuning_type, output_dir)
+            config_dict = load_args(os.path.join(output_dir, LLAMABOARD_CONFIG))  # load llamaboard config
+            for elem_id, value in config_dict.items():
+                output_dict[self.manager.get_elem_by_id(elem_id)] = value
+
+        return output_dict