aurora

1
import gradio as gr
2
from typing import TYPE_CHECKING, Dict
3
from transformers.trainer_utils import SchedulerType
4

5
from llmtuner.extras.constants import TRAINING_STAGES
6
from llmtuner.webui.common import list_checkpoint, list_dataset, DEFAULT_DATA_DIR
7
from llmtuner.webui.components.data import create_preview_box
8
from llmtuner.webui.utils import gen_plot
9

10
if TYPE_CHECKING:
11
    from gradio.components import Component
12
    from llmtuner.webui.engine import Engine
13

14

15
def create_train_tab(engine: "Engine") -> Dict[str, "Component"]:
16
    input_elems = engine.manager.get_base_elems()
17
    elem_dict = dict()
18

19
    with gr.Row():
20
        training_stage = gr.Dropdown(
21
            choices=list(TRAINING_STAGES.keys()), value=list(TRAINING_STAGES.keys())[0], scale=2
22
        )
23
        dataset_dir = gr.Textbox(value=DEFAULT_DATA_DIR, scale=2)
24
        dataset = gr.Dropdown(multiselect=True, scale=4)
25
        preview_elems = create_preview_box(dataset_dir, dataset)
26

27
    training_stage.change(list_dataset, [dataset_dir, training_stage], [dataset], queue=False)
28
    dataset_dir.change(list_dataset, [dataset_dir, training_stage], [dataset], queue=False)
29

30
    input_elems.update({training_stage, dataset_dir, dataset})
31
    elem_dict.update(dict(
32
        training_stage=training_stage, dataset_dir=dataset_dir, dataset=dataset, **preview_elems
33
    ))
34

35
    with gr.Row():
36
        cutoff_len = gr.Slider(value=1024, minimum=4, maximum=8192, step=1)
37
        learning_rate = gr.Textbox(value="5e-5")
38
        num_train_epochs = gr.Textbox(value="3.0")
39
        max_samples = gr.Textbox(value="100000")
40
        compute_type = gr.Radio(choices=["fp16", "bf16"], value="fp16")
41

42
    input_elems.update({cutoff_len, learning_rate, num_train_epochs, max_samples, compute_type})
43
    elem_dict.update(dict(
44
        cutoff_len=cutoff_len, learning_rate=learning_rate, num_train_epochs=num_train_epochs,
45
        max_samples=max_samples, compute_type=compute_type
46
    ))
47

48
    with gr.Row():
49
        batch_size = gr.Slider(value=4, minimum=1, maximum=512, step=1)
50
        gradient_accumulation_steps = gr.Slider(value=4, minimum=1, maximum=512, step=1)
51
        lr_scheduler_type = gr.Dropdown(
52
            choices=[scheduler.value for scheduler in SchedulerType], value="cosine"
53
        )
54
        max_grad_norm = gr.Textbox(value="1.0")
55
        val_size = gr.Slider(value=0, minimum=0, maximum=1, step=0.001)
56

57
    input_elems.update({batch_size, gradient_accumulation_steps, lr_scheduler_type, max_grad_norm, val_size})
58
    elem_dict.update(dict(
59
        batch_size=batch_size, gradient_accumulation_steps=gradient_accumulation_steps,
60
        lr_scheduler_type=lr_scheduler_type, max_grad_norm=max_grad_norm, val_size=val_size
61
    ))
62

63
    with gr.Accordion(label="Advanced config", open=False) as advanced_tab:
64
        with gr.Row():
65
            logging_steps = gr.Slider(value=5, minimum=5, maximum=1000, step=5)
66
            save_steps = gr.Slider(value=100, minimum=10, maximum=5000, step=10)
67
            warmup_steps = gr.Slider(value=0, minimum=0, maximum=5000, step=1)
68
            neftune_alpha = gr.Slider(value=0, minimum=0, maximum=10, step=0.1)
69

70
            with gr.Column():
71
                train_on_prompt = gr.Checkbox(value=False)
72
                upcast_layernorm = gr.Checkbox(value=False)
73

74
    input_elems.update({logging_steps, save_steps, warmup_steps, neftune_alpha, train_on_prompt, upcast_layernorm})
75
    elem_dict.update(dict(
76
        advanced_tab=advanced_tab, logging_steps=logging_steps, save_steps=save_steps, warmup_steps=warmup_steps,
77
        neftune_alpha=neftune_alpha, train_on_prompt=train_on_prompt, upcast_layernorm=upcast_layernorm
78
    ))
79

80
    with gr.Accordion(label="LoRA config", open=False) as lora_tab:
81
        with gr.Row():
82
            lora_rank = gr.Slider(value=8, minimum=1, maximum=1024, step=1, scale=1)
83
            lora_dropout = gr.Slider(value=0.1, minimum=0, maximum=1, step=0.01, scale=1)
84
            lora_target = gr.Textbox(scale=1)
85
            additional_target = gr.Textbox(scale=1)
86
            resume_lora_training = gr.Checkbox(value=True, scale=1)
87

88
    input_elems.update({lora_rank, lora_dropout, lora_target, additional_target, resume_lora_training})
89
    elem_dict.update(dict(
90
        lora_tab=lora_tab, lora_rank=lora_rank, lora_dropout=lora_dropout, lora_target=lora_target,
91
        additional_target=additional_target, resume_lora_training=resume_lora_training,
92
    ))
93

94
    with gr.Accordion(label="RLHF config", open=False) as rlhf_tab:
95
        with gr.Row():
96
            dpo_beta = gr.Slider(value=0.1, minimum=0, maximum=1, step=0.01, scale=1)
97
            reward_model = gr.Dropdown(scale=3)
98
            refresh_btn = gr.Button(scale=1)
99

100
    refresh_btn.click(
101
        list_checkpoint,
102
        [engine.manager.get_elem_by_name("top.model_name"), engine.manager.get_elem_by_name("top.finetuning_type")],
103
        [reward_model],
104
        queue=False
105
    )
106

107
    input_elems.update({dpo_beta, reward_model})
108
    elem_dict.update(dict(rlhf_tab=rlhf_tab, dpo_beta=dpo_beta, reward_model=reward_model, refresh_btn=refresh_btn))
109

110
    with gr.Row():
111
        cmd_preview_btn = gr.Button()
112
        start_btn = gr.Button()
113
        stop_btn = gr.Button()
114

115
    with gr.Row():
116
        with gr.Column(scale=3):
117
            with gr.Row():
118
                output_dir = gr.Textbox()
119

120
            with gr.Row():
121
                resume_btn = gr.Checkbox(visible=False, interactive=False, value=False)
122
                process_bar = gr.Slider(visible=False, interactive=False)
123

124
            with gr.Box():
125
                output_box = gr.Markdown()
126

127
        with gr.Column(scale=1):
128
            loss_viewer = gr.Plot()
129

130
    input_elems.add(output_dir)
131
    output_elems = [output_box, process_bar]
132

133
    cmd_preview_btn.click(engine.runner.preview_train, input_elems, output_elems)
134
    start_btn.click(engine.runner.run_train, input_elems, output_elems)
135
    stop_btn.click(engine.runner.set_abort, queue=False)
136
    resume_btn.change(engine.runner.monitor, outputs=output_elems)
137

138
    elem_dict.update(dict(
139
        cmd_preview_btn=cmd_preview_btn, start_btn=start_btn, stop_btn=stop_btn, output_dir=output_dir,
140
        resume_btn=resume_btn, process_bar=process_bar, output_box=output_box, loss_viewer=loss_viewer
141
    ))
142

143
    output_box.change(
144
        gen_plot,
145
        [
146
            engine.manager.get_elem_by_name("top.model_name"),
147
            engine.manager.get_elem_by_name("top.finetuning_type"),
148
            output_dir
149
        ],
150
        loss_viewer,
151
        queue=False
152
    )
153

154
    return elem_dict
155