重构代码

Author: Your Name

examples/train/rft/rft.py

@@ -22,7 +22,7 @@ def do_sample(model: str, model_type: str, dataset: List[str], iter: int):
     for device in range(device_count):
         sample_cmd = (f'{conda_prefix} CUDA_VISIBLE_DEVICES={device} swift sample '
                       f'--model {model} --model_type {model_type} '
-                      f'--dataset {" ".join(dataset)} '
+                      f'--dataset {' '.join(dataset)} '
                       f'--data_range {device} {device_count} '
                       f'--max_length 2048 '
                       f'--system "You are a math model, you should **think step by step** carefully, '
@@ -61,7 +61,7 @@ def do_sample(model: str, model_type: str, dataset: List[str], iter: int):
         sample_cmd = (
             f'{conda_prefix} CUDA_VISIBLE_DEVICES={device} swift sample '
             f'--model {model} --model_type {model_type} '  # change to --resume_from_checkpoint to use the latest optimizer state # noqa
-            f'--dataset {" ".join(dataset)} '
+            f'--dataset {' '.join(dataset)} '
             f'--data_range {device} {device_count} '
             f'--max_length 2048 '
             f'--system "You are a math model, you should **think step by step** carefully, '
@@ -108,7 +108,7 @@ def do_train(model: str, model_type: str, datasets: List[str], iter, cmd='sft'):
     ga = 128 // get_device_count() // 2
     train_cmd = (f'{conda_prefix} {gpu_prefix} swift {cmd} '
                  f'--model {model} --model_type {model_type} '
-                 f'--dataset {" ".join(datasets)} '
+                 f'--dataset {' '.join(datasets)} '
                  f'--max_length 2048 '
                  f'--num_train_epochs 1 '
                  f'--load_args false '

gen_data.py

@@ -9,34 +9,36 @@
 from typing import Dict, List
 from math_tool import parse_expression, SYMBOL_TO_OPERATION, OPERATION_DEFINITIONS
 
+
 def generate_safe_expression():
     """Generate an expression that won't cause overflow errors"""
     # Start with a moderate number
     expression = str(random.randint(1, 20))
-    
+
     # Add 3-5 operations with safe numbers
     num_ops = random.randint(1, 6)
-    
+
     for i in range(num_ops):
         # Choose operation
         op = random.choice(['@', '&', '$', '^'])
-        
+
         # For @ operation, use smaller numbers to avoid overflow
         if op == '@':
             # For exponentiation, keep the exponent small
             num = random.randint(1, 3)
         else:
             num = random.randint(1, 10)
-            
+
         expression += op + str(num)
-    
+
     return expression
 
-def generate_dataset(num_samples: int = 1000, output_file: str = "math_operations_dataset.jsonl") -> None:
+
+def generate_dataset(num_samples: int = 1000, output_file: str = 'math_operations_dataset.jsonl') -> None:
     """
     Generates a dataset of custom mathematical expressions and their results.
     Saves the dataset as a JSONL file.
-    
+
     Args:
         num_samples: Number of samples to generate
         output_file: Path to save the JSONL file
@@ -45,24 +47,31 @@ def generate_dataset(num_samples: int = 1000, output_file: str = "math_operation
         for _ in range(num_samples):
             # Generate a safe expression
             expression = generate_safe_expression()
-            
+
             # Calculate the result
             try:
                 result = parse_expression(expression)
-                
+
                 # Create the data entry
                 # data_entry = {
                 #     "query": f"Calculate the result of the expression: {expression}",
                 #     "answer": result
                 # }
-                data_entry = {"messages": [{"role": "user", "content": f"Calculate the result of the expression: {expression}"}],"response":result}
-                
+                data_entry = {
+                    'messages': [{
+                        'role': 'user',
+                        'content': f"Calculate the result of the expression: {expression}"
+                    }],
+                    'response': result
+                }
+
                 # Write to JSONL file
                 f.write(json.dumps(data_entry) + '\n')
             except Exception as e:
                 print(f"Skipping problematic expression {expression}: {e}")
                 continue
-    
+
     print(f"Generated dataset with {num_samples} samples and saved to {output_file}")
 
-generate_dataset()
+
+generate_dataset()

scripts/benchmark/exp_utils.py

@@ -122,7 +122,7 @@ def run(self, exp: Experiment):
             exp.runtime = runtime
             envs = deepcopy(runtime.get('env', {}))
             envs.update(os.environ)
-            logger.info(f'Running cmd: {runtime["running_cmd"]}, env: {runtime.get("env", {})}')
+            logger.info(f'Running cmd: {runtime['running_cmd']}, env: {runtime.get('env', {})}')
             os.makedirs('exp', exist_ok=True)
             log_file = os.path.join('exp', f'{exp.name}.eval.log')
             exp.handler = subprocess.Popen(runtime['running_cmd'] + f' > {log_file} 2>&1', env=envs, shell=True)
@@ -140,7 +140,7 @@ def run(self, exp: Experiment):
             exp.runtime = runtime
             envs = deepcopy(runtime.get('env', {}))
             envs.update(os.environ)
-            logger.info(f'Running cmd: {runtime["running_cmd"]}, env: {runtime.get("env", {})}')
+            logger.info(f'Running cmd: {runtime['running_cmd']}, env: {runtime.get('env', {})}')
             os.makedirs('exp', exist_ok=True)
             log_file = os.path.join('exp', f'{exp.name}.{exp.cmd}.log')
             exp.handler = subprocess.Popen(runtime['running_cmd'] + f' > {log_file} 2>&1', env=envs, shell=True)
@@ -162,10 +162,10 @@ def _build_eval_cmd(self, exp: Experiment):
         if best_model_checkpoint is not None:
             if not os.path.exists(os.path.join(best_model_checkpoint, 'args.json')):
                 cmd = f'swift eval --ckpt_dir {best_model_checkpoint} ' \
-                      + f'--infer_backend pt --train_type full --eval_dataset {" ".join(eval_dataset)}'
+                      + f'--infer_backend pt --train_type full --eval_dataset {' '.join(eval_dataset)}'
         else:
-            cmd = f'swift eval --model {exp.args.get("model")} --infer_backend pt ' \
-                  f'--eval_dataset {" ".join(eval_dataset)}'
+            cmd = f'swift eval --model {exp.args.get('model')} --infer_backend pt ' \
+                  f'--eval_dataset {' '.join(eval_dataset)}'
 
         return {
             'running_cmd': cmd,

scripts/benchmark/generate_report.py

@@ -69,23 +69,23 @@ def tuner_hyper_params(self):
             return ''
         if args['sft_type'] in ('lora', 'adalora', 'longlora'):
             if 'lora_rank' in args:
-                hyper_params += f'rank={args["lora_rank"]}/' \
-                                f'target={args["lora_target_modules"]}/' \
-                                f'alpha={args["lora_alpha"]}/' \
-                                f'lr_ratio={args.get("lora_lr_ratio", None)}/' \
-                                f'use_rslora={args.get("use_rslora", False)}/' \
-                                f'use_dora={args.get("use_dora", False)}'
+                hyper_params += f'rank={args['lora_rank']}/' \
+                                f'target={args['lora_target_modules']}/' \
+                                f'alpha={args['lora_alpha']}/' \
+                                f'lr_ratio={args.get('lora_lr_ratio', None)}/' \
+                                f'use_rslora={args.get('use_rslora', False)}/' \
+                                f'use_dora={args.get('use_dora', False)}'
             else:
                 hyper_params = ''
         if args['sft_type'] == 'full':
             if 'use_galore' in args and args['use_galore'] == 'true':
-                hyper_params += f'galore_rank={args["galore_rank"]}/' \
-                                f'galore_per_parameter={args["galore_optim_per_parameter"]}/' \
-                                f'galore_with_embedding={args["galore_with_embedding"]}/'
+                hyper_params += f'galore_rank={args['galore_rank']}/' \
+                                f'galore_per_parameter={args['galore_optim_per_parameter']}/' \
+                                f'galore_with_embedding={args['galore_with_embedding']}/'
         if args['sft_type'] == 'llamapro':
-            hyper_params += f'num_blocks={args["llamapro_num_new_blocks"]}/'
+            hyper_params += f'num_blocks={args['llamapro_num_new_blocks']}/'
         if 'neftune_noise_alpha' in args and args['neftune_noise_alpha']:
-            hyper_params += f'neftune_noise_alpha={args["neftune_noise_alpha"]}/'
+            hyper_params += f'neftune_noise_alpha={args['neftune_noise_alpha']}/'
 
         if hyper_params.endswith('/'):
             hyper_params = hyper_params[:-1]
@@ -95,8 +95,8 @@ def tuner_hyper_params(self):
     def hyper_parameters(self):
         if 'learning_rate' not in self.args:
             return ''
-        return f'lr={self.args["learning_rate"]}/' \
-               f'epoch={self.args["num_train_epochs"]}'
+        return f'lr={self.args['learning_rate']}/' \
+               f'epoch={self.args['num_train_epochs']}'
 
     @property
     def train_speed(self):
@@ -190,10 +190,10 @@ def generate_sft_report(outputs: List[ModelOutput]):
             ceval_acc = '' if not ceval_acc else f'**{ceval_acc:.3f}**'
 
         line = f'|{output.name}|' \
-               f'{output.args["model_type"]}|' \
-               f'{output.args.get("dataset")}|' \
-               f'{output.args.get("train_dataset_mix_ratio", 0.)}|' \
-               f'{output.args.get("sft_type")}|' \
+               f'{output.args['model_type']}|' \
+               f'{output.args.get('dataset')}|' \
+               f'{output.args.get('train_dataset_mix_ratio', 0.)}|' \
+               f'{output.args.get('sft_type')}|' \
                f'{output.tuner_hyper_params}|' \
                f'{output.num_trainable_parameters}({output.trainable_parameters_percentage})|' \
                f'{use_flash_attn}|' \
@@ -267,14 +267,14 @@ def generate_export_report(outputs: List[ModelOutput]):
             ceval_acc = '' if not ceval_acc else f'**{ceval_acc:.3f}**'
 
         if output.train_dataset_info:
-            dataset_info = f'{output.args["dataset"]}/{output.train_dataset_info}'
+            dataset_info = f'{output.args['dataset']}/{output.train_dataset_info}'
         else:
-            dataset_info = f'{output.args["dataset"]}'
+            dataset_info = f'{output.args['dataset']}'
         line = f'|{output.name}|' \
-               f'{output.args["model_type"]}|' \
+               f'{output.args['model_type']}|' \
                f'{dataset_info}|' \
-               f'{output.args["quant_method"]}|' \
-               f'{output.args["quant_bits"]}|' \
+               f'{output.args['quant_method']}|' \
+               f'{output.args['quant_bits']}|' \
                f'{infer_speed}|' \
                f'{gsm8k_acc}|' \
                f'{arc_acc}|' \

swift/llm/base.py

@@ -43,9 +43,9 @@ def _compat_dsw_gradio(args) -> None:
             os.environ['GRADIO_ROOT_PATH'] = f"/{os.environ['JUPYTER_NAME']}/proxy/{args.server_port}"
 
     def main(self):
-        logger.info(f'Start time of running main: {dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")}')
+        logger.info(f'Start time of running main: {dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')}')
         result = self.run()
-        logger.info(f'End time of running main: {dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")}')
+        logger.info(f'End time of running main: {dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')}')
         return result
 
     @abstractmethod

swift/llm/dataset/dataset/llm.py

@@ -285,7 +285,7 @@ def preprocess(self, row: Dict[str, Any]) -> Dict[str, Any]:
             chapter = row[f'chapter{i}']
             if chapter is not None:
                 cur_prompt += f'{chapter}'
-        cur_prompt += f'{row["response"]}'
+        cur_prompt += f'{row['response']}'
         return super().preprocess({'response': cur_prompt})
 
 

swift/llm/dataset/dataset/mllm.py

@@ -566,7 +566,7 @@ def preprocess_row(row: Dict[str, Any]) -> Dict[str, Any]:
         what = ''
         if ':' in action:
             action, what = action[:action.find(':')], action[action.find(':') + 1:]
-        row['response'] = f'Action: {action.strip()}\nAction Input: {where.strip()}{"," + what.strip()}'
+        row['response'] = f'Action: {action.strip()}\nAction Input: {where.strip()}{',' + what.strip()}'
         return row
 
     conversations = []

swift/llm/export/ollama.py

@@ -38,15 +38,15 @@ def export_to_ollama(args: ExportArguments):
     with open(os.path.join(args.output_dir, 'Modelfile'), 'w', encoding='utf-8') as f:
         f.write(f'FROM {pt_engine.model_dir}\n')
         f.write(f'TEMPLATE """{{{{ if .System }}}}'
-                f'{replace_and_concat(template, template_meta.system_prefix, "{{SYSTEM}}", "{{ .System }}")}'
-                f'{{{{ else }}}}{replace_and_concat(template, template_meta.prefix, "", "")}'
+                f'{replace_and_concat(template, template_meta.system_prefix, '{{SYSTEM}}', '{{ .System }}')}'
+                f'{{{{ else }}}}{replace_and_concat(template, template_meta.prefix, '', '')}'
                 f'{{{{ end }}}}')
         f.write(f'{{{{ if .Prompt }}}}'
-                f'{replace_and_concat(template, template_meta.prompt, "{{QUERY}}", "{{ .Prompt }}")}'
+                f'{replace_and_concat(template, template_meta.prompt, '{{QUERY}}', '{{ .Prompt }}')}'
                 f'{{{{ end }}}}')
         f.write('{{ .Response }}')
         f.write(replace_and_concat(template, template_meta.suffix, '', '') + '"""\n')
-        f.write(f'PARAMETER stop "{replace_and_concat(template, template_meta.suffix, "", "")}"\n')
+        f.write(f'PARAMETER stop "{replace_and_concat(template, template_meta.suffix, '', '')}"\n')
 
         request_config = RequestConfig(
             temperature=args.temperature,
@@ -65,5 +65,5 @@ def export_to_ollama(args: ExportArguments):
     logger.info('Save Modelfile done, you can start ollama by:')
     logger.info('> ollama serve')
     logger.info('In another terminal:')
-    logger.info('> ollama create my-custom-model ' f'-f {os.path.join(args.output_dir, "Modelfile")}')
+    logger.info('> ollama create my-custom-model ' f'-f {os.path.join(args.output_dir, 'Modelfile')}')
     logger.info('> ollama run my-custom-model')

swift/llm/infer/protocol.py

@@ -261,7 +261,7 @@ class ChatCompletionResponse:
     def to_cmpl_response(self) -> 'CompletionResponse':
         self = deepcopy(self)
         choices = [choice.to_cmpl_choice() for choice in self.choices]
-        id_ = f'cmpl{self.id[len("chatcmpl"):]}'
+        id_ = f'cmpl{self.id[len('chatcmpl'):]}'
         return CompletionResponse(self.model, choices, self.usage, id_, created=self.created)
 
 
@@ -315,7 +315,7 @@ class ChatCompletionStreamResponse:
     def to_cmpl_response(self) -> 'CompletionStreamResponse':
         self = deepcopy(self)
         choices = [choice.to_cmpl_choice() for choice in self.choices]
-        id_ = f'cmpl{self.id[len("chatcmpl"):]}'
+        id_ = f'cmpl{self.id[len('chatcmpl'):]}'
         return CompletionStreamResponse(self.model, choices, self.usage, id_, created=self.created)
 
 

swift/plugin/tool_call.py

@@ -1,9 +1,10 @@
-from typing import Tuple,Any, Optional
+from typing import Tuple, Any, Optional
+
+
 class TOOL_CALL:
+
     def __call__(self, completion: str) -> Tuple[Any, bool, Optional[float]]:
         raise NotImplementedError
 
 
-tools = {
-    
-}
+tools = {}

swift/trainers/arguments.py

@@ -104,9 +104,9 @@ class GRPOArgumentsMixin:
     offload_optimizer: bool = False
     offload_model: bool = False
     gc_collect_after_offload: bool = False
-    is_reward_tool_call:bool = True #是否额外单独计算每个tool call的format得分
-    tool_call_weight:float = 1.0
-    tool_call:str = None
+    is_reward_tool_call: bool = True  #是否额外单独计算每个tool call的format得分
+    tool_call_weight: float = 1.0
+    tool_call: str = None
 
 
 @dataclass

swift/trainers/rlhf_arguments.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import List, Optional,Callable
+from typing import List, Optional, Callable
 
 from trl import CPOConfig as HfCPOConfig
 from trl import DPOConfig as HfDPOConfig