SWIFT 后训练 Deepseek-VL2 下令

SWIFT 后训练 Deepseek-VL2 下令

flyfish
后训练下令

1. CUDA_VISIBLE_DEVICES=1 swift sft     --model deepseek-ai/deepseek-vl2-tiny     --dataset coco-en-mini

复制代码

swift/cli/sft.py

1. from swift.llm import sft_main
3. if __name__ == '__main__':
4.     sft_main()

复制代码

init.py

在范例查抄阶段导入所有必要的范例信息，以资助范例查抄工具正常工作；在正常运行阶段，使用 _LazyModule 类实现模块的惰性加载，从而进步性能和减少内存占用。

2. from typing import TYPE_CHECKING
4. # 导入 _LazyModule 类，该类用于实现模块的惰性加载，即只有在真正使用模块中的对象时才进行加载，可提高性能和减少内存占用
5. from swift.utils.import_utils import _LazyModule
7. # TYPE_CHECKING 是一个布尔值常量，在类型检查工具（如 mypy）运行时为 True，在正常运行时为 False。
8. # 此条件判断用于区分类型检查阶段和正常运行阶段
9. if TYPE_CHECKING:
10.     # 在类型检查阶段，导入以下模块中的函数和类，这样类型检查工具可以正确识别代码中的类型信息，
11.     # 但这些导入不会在实际运行时产生开销
12.     from .infer import (
13.         # VllmEngine 是基于 vLLM 的推理引擎类
14.         VllmEngine,
15.         # RequestConfig 用于配置推理请求的参数
16.         RequestConfig,
17.         # LmdeployEngine 是基于 lmdeploy 的推理引擎类
18.         LmdeployEngine,
19.         # PtEngine 可能是基于 PyTorch 的推理引擎类
20.         PtEngine,
21.         # InferEngine 是通用的推理引擎基类
22.         InferEngine,
23.         # infer_main 是推理主函数，用于启动推理流程
24.         infer_main,
25.         # deploy_main 是部署主函数，用于启动推理服务的部署
26.         deploy_main,
27.         # InferClient 是推理客户端类，用于与推理服务进行交互
28.         InferClient,
29.         # run_deploy 用于运行部署操作
30.         run_deploy,
31.         # AdapterRequest 是适配器请求类，可能用于对请求进行适配处理
32.         AdapterRequest,
33.         # prepare_model_template 用于准备模型模板
34.         prepare_model_template
35.     )
36.     from .export import (
37.         # export_main 是导出主函数，用于将模型导出为特定格式
38.         export_main,
39.         # merge_lora 用于合并 LoRA（Low-Rank Adaptation）权重到基础模型中
40.         merge_lora,
41.         # quantize_model 用于对模型进行量化操作，以减少模型大小和计算量
42.         quantize_model,
43.         # export_to_ollama 用于将模型导出为 Ollama 支持的格式
44.         export_to_ollama
45.     )
46.     from .eval import (
47.         # eval_main 是评估主函数，用于对模型进行评估
48.         eval_main
49.     )
50.     from .app import (
51.         # app_main 是应用主函数，可能用于启动一个基于模型的应用程序
52.         app_main
53.     )
54.     from .train import (
55.         # sft_main 是监督微调主函数，用于对模型进行监督微调训练
56.         sft_main,
57.         # pt_main 可能是预训练主函数，用于对模型进行预训练
58.         pt_main,
59.         # rlhf_main 是基于强化学习的人类反馈微调主函数，用于使用人类反馈对模型进行微调
60.         rlhf_main,
61.         # get_multimodal_target_regex 用于获取多模态目标的正则表达式
62.         get_multimodal_target_regex
63.     )
64.     from .argument import (
65.         # EvalArguments 是评估参数类，用于配置评估过程中的参数
66.         EvalArguments,
67.         # InferArguments 是推理参数类，用于配置推理过程中的参数
68.         InferArguments,
69.         # TrainArguments 是训练参数类，用于配置训练过程中的参数
70.         TrainArguments,
71.         # ExportArguments 是导出参数类，用于配置模型导出过程中的参数
72.         ExportArguments,
73.         # DeployArguments 是部署参数类，用于配置模型部署过程中的参数
74.         DeployArguments,
75.         # RLHFArguments 是基于强化学习的人类反馈微调参数类，用于配置 RLHF 过程中的参数
76.         RLHFArguments,
77.         # WebUIArguments 是 Web 界面参数类，用于配置基于 Web 的用户界面的参数
78.         WebUIArguments,
79.         # BaseArguments 是基础参数类，可能包含一些通用的参数配置
80.         BaseArguments,
81.         # AppArguments 是应用参数类，用于配置应用程序的参数
82.         AppArguments
83.     )
84.     from .template import (
85.         # TEMPLATE_MAPPING 是模板映射字典，用于存储不同模板的映射关系
86.         TEMPLATE_MAPPING,
87.         # Template 是模板类，用于定义和处理模型输入输出的模板
88.         Template,
89.         # Word 可能是模板中的单词类，用于处理模板中的文本元素
90.         Word,
91.         # get_template 用于根据名称获取对应的模板
92.         get_template,
93.         # TemplateType 是模板类型枚举类，用于定义不同类型的模板
94.         TemplateType,
95.         # register_template 用于注册新的模板
96.         register_template,
97.         # TemplateInputs 是模板输入类，用于封装模板的输入信息
98.         TemplateInputs,
99.         # TemplateMeta 是模板元信息类，用于存储模板的元数据
100.         TemplateMeta,
101.         # get_template_meta 用于获取模板的元信息
102.         get_template_meta,
103.         # InferRequest 是推理请求类，用于封装推理请求的信息
104.         InferRequest,
105.         # load_image 用于加载图像数据
106.         load_image,
107.         # MaxLengthError 是最大长度错误类，用于处理输入超过最大长度的错误
108.         MaxLengthError,
109.         # load_file 用于加载文件数据
110.         load_file,
111.         # draw_bbox 用于绘制边界框，可能用于多模态任务中的图像标注
112.         draw_bbox
113.     )
114.     from .model import (
115.         # register_model 用于注册新的模型
116.         register_model,
117.         # MODEL_MAPPING 是模型映射字典，用于存储不同模型的映射关系
118.         MODEL_MAPPING,
119.         # ModelType 是模型类型枚举类，用于定义不同类型的模型
120.         ModelType,
121.         # get_model_tokenizer 用于获取模型和对应的分词器
122.         get_model_tokenizer,
123.         # safe_snapshot_download 用于安全地下载模型快照
124.         safe_snapshot_download,
125.         # HfConfigFactory 是 Hugging Face 配置工厂类，用于创建 Hugging Face 模型的配置
126.         HfConfigFactory,
127.         # ModelInfo 是模型信息类，用于存储模型的相关信息
128.         ModelInfo,
129.         # ModelMeta 是模型元信息类，用于存储模型的元数据
130.         ModelMeta,
131.         # ModelKeys 是模型键类，用于定义模型的关键信息
132.         ModelKeys,
133.         # register_model_arch 用于注册新的模型架构
134.         register_model_arch,
135.         # MultiModelKeys 是多模型键类，用于处理多个模型的关键信息
136.         MultiModelKeys,
137.         # ModelArch 是模型架构类，用于定义模型的架构
138.         ModelArch,
139.         # get_model_arch 用于获取模型的架构
140.         get_model_arch,
141.         # MODEL_ARCH_MAPPING 是模型架构映射字典，用于存储不同模型架构的映射关系
142.         MODEL_ARCH_MAPPING,
143.         # get_model_info_meta 用于获取模型的信息和元数据
144.         get_model_info_meta,
145.         # get_model_name 用于获取模型的名称
146.         get_model_name,
147.         # ModelGroup 是模型组类，用于管理多个模型
148.         ModelGroup,
149.         # Model 是模型类，可能是模型的基类
150.         Model,
151.         # get_model_tokenizer_with_flash_attn 用于获取支持 Flash Attention 的模型和分词器
152.         get_model_tokenizer_with_flash_attn,
153.         # get_model_tokenizer_multimodal 用于获取多模态模型和分词器
154.         get_model_tokenizer_multimodal,
155.         # load_by_unsloth 可能是使用 Unsloth 库加载模型的函数
156.         load_by_unsloth,
157.         # git_clone_github 用于从 GitHub 克隆模型仓库
158.         git_clone_github,
159.         # get_matched_model_meta 用于获取匹配的模型元信息
160.         get_matched_model_meta
161.     )
162.     from .dataset import (
163.         # AlpacaPreprocessor 是 Alpaca 数据集的预处理器类，用于对 Alpaca 数据集进行预处理
164.         AlpacaPreprocessor,
165.         # ResponsePreprocessor 是响应预处理器类，用于对模型的响应进行预处理
166.         ResponsePreprocessor,
167.         # MessagesPreprocessor 是消息预处理器类，用于对消息数据进行预处理
168.         MessagesPreprocessor,
169.         # AutoPreprocessor 是自动预处理器类，可根据数据集类型自动选择预处理器
170.         AutoPreprocessor,
171.         # DATASET_MAPPING 是数据集映射字典，用于存储不同数据集的映射关系
172.         DATASET_MAPPING,
173.         # MediaResource 是媒体资源类，用于处理数据集中的媒体资源
174.         MediaResource,
175.         # register_dataset 用于注册新的数据集
176.         register_dataset,
177.         # register_dataset_info 用于注册数据集的信息
178.         register_dataset_info,
179.         # EncodePreprocessor 是编码预处理器类，用于对数据进行编码处理
180.         EncodePreprocessor,
181.         # LazyLLMDataset 是惰性加载的大语言模型数据集类，可在需要时加载数据
182.         LazyLLMDataset,
183.         # ConstantLengthDataset 是固定长度数据集类，用于将数据集处理为固定长度
184.         ConstantLengthDataset,
185.         # load_dataset 用于加载数据集
186.         load_dataset,
187.         # DATASET_TYPE 是数据集类型枚举类，用于定义不同类型的数据集
188.         DATASET_TYPE,
189.         # sample_dataset 用于对数据集进行采样
190.         sample_dataset,
191.         # RowPreprocessor 是行预处理器类，用于对数据集中的每一行进行预处理
192.         RowPreprocessor,
193.         # DatasetMeta 是数据集元信息类，用于存储数据集的元数据
194.         DatasetMeta
195.     )
196.     from .utils import (
197.         # deep_getattr 是深度获取属性的函数，可递归获取对象的属性
198.         deep_getattr,
199.         # to_device 用于将数据移动到指定的设备（如 GPU）上
200.         to_device,
201.         # History 是历史记录类，用于存储对话历史等信息
202.         History,
203.         # Messages 是消息类，用于封装消息数据
204.         Messages,
205.         # history_to_messages 用于将历史记录转换为消息列表
206.         history_to_messages,
207.         # messages_to_history 用于将消息列表转换为历史记录
208.         messages_to_history,
209.         # Processor 是处理器基类，可用于定义各种数据处理逻辑
210.         Processor,
211.         # save_checkpoint 用于保存模型的检查点
212.         save_checkpoint,
213.         # ProcessorMixin 是处理器混合类，可用于为类添加处理功能
214.         ProcessorMixin,
215.         # get_temporary_cache_files_directory 用于获取临时缓存文件目录
216.         get_temporary_cache_files_directory,
217.         # get_cache_dir 用于获取缓存目录
218.         get_cache_dir
219.     )
220.     from .base import (
221.         # SwiftPipeline 是 Swift 管道类，可能用于定义和管理模型处理的流程
222.         SwiftPipeline
223.     )
224. else:
225.     # 在正常运行阶段，定义一个字典，包含所有不以 '_' 开头的全局变量，这些变量将被包含在惰性加载的模块中
226.     _extra_objects = {k: v for k, v in globals().items() if not k.startswith('_')}
227.    
228.     # 定义一个字典，表示各个子模块及其导出的对象，这些对象将在需要时进行惰性加载
229.     _import_structure = {
230.         'rlhf': ['rlhf_main'],
231.         'infer': [
232.             'deploy_main', 'VllmEngine', 'RequestConfig', 'LmdeployEngine', 'PtEngine', 'infer_main', 'InferClient',
233.             'run_deploy', 'InferEngine', 'AdapterRequest', 'prepare_model_template'
234.         ],
235.         'export': ['export_main', 'merge_lora', 'quantize_model', 'export_to_ollama'],
236.         'app': ['app_main'],
237.         'eval': ['eval_main'],
238.         'train': ['sft_main', 'pt_main', 'rlhf_main', 'get_multimodal_target_regex'],
239.         'argument': [
240.             'EvalArguments', 'InferArguments', 'TrainArguments', 'ExportArguments', 'WebUIArguments', 'DeployArguments',
241.             'RLHFArguments', 'BaseArguments', 'AppArguments'
242.         ],
243.         'template': [
244.             'TEMPLATE_MAPPING', 'Template', 'Word', 'get_template', 'TemplateType', 'register_template',
245.             'TemplateInputs', 'TemplateMeta', 'get_template_meta', 'InferRequest', 'load_image', 'MaxLengthError',
246.             'load_file', 'draw_bbox'
247.         ],
248.         'model': [
249.             'MODEL_MAPPING', 'ModelType', 'get_model_tokenizer', 'safe_snapshot_download', 'HfConfigFactory',
250.             'ModelInfo', 'ModelMeta', 'ModelKeys', 'register_model_arch', 'MultiModelKeys', 'ModelArch',
251.             'MODEL_ARCH_MAPPING', 'get_model_arch', 'get_model_info_meta', 'get_model_name', 'register_model',
252.             'ModelGroup', 'Model', 'get_model_tokenizer_with_flash_attn', 'get_model_tokenizer_multimodal',
253.             'load_by_unsloth', 'git_clone_github', 'get_matched_model_meta'
254.         ],
255.         'dataset': [
256.             'AlpacaPreprocessor', 'MessagesPreprocessor', 'DATASET_MAPPING', 'MediaResource', 'register_dataset',
257.             'register_dataset_info', 'EncodePreprocessor', 'LazyLLMDataset', 'ConstantLengthDataset', 'load_dataset',
258.             'DATASET_TYPE', 'sample_dataset', 'RowPreprocessor', 'ResponsePreprocessor', 'DatasetMeta'
259.         ],
260.         'utils': [
261.             'deep_getattr', 'to_device', 'History', 'Messages', 'history_to_messages', 'messages_to_history',
262.             'Processor', 'save_checkpoint', 'ProcessorMixin', 'get_temporary_cache_files_directory', 'get_cache_dir'
263.         ],
264.         'base': ['SwiftPipeline'],
265.     }
267.     import sys
269.     # 使用 _LazyModule 类替换当前模块，实现模块的惰性加载。
270.     # 当代码尝试访问模块中的对象时，_LazyModule 会动态加载所需的子模块和对象，而不是在模块导入时就全部加载
271.     sys.modules[__name__] = _LazyModule(
272.         __name__,  # 当前模块的名称
273.         globals()['__file__'],  # 当前模块的文件路径
274.         _import_structure,  # 子模块及其导出对象的映射字典
275.         module_spec=__spec__,  # 模块的规格信息
276.         extra_objects=_extra_objects  # 额外的全局对象
277.     )

复制代码

Python __init__.py 文件的作用

在Python中，__init__.py 文件是一个特别的文件，用于将一个目录标记为一个Python包（package）。虽然从Python 3.3开始，引入了隐式定名空间包（Implicit Namespace Packages），答应没有 __init__.py 文件的目录也被视为包，但 __init__.py 文件仍旧具有紧张的作用。以下是 __init__.py 文件的主要用途和功能：
主要用途

• 标记包：
  
  
  
  • 在Python 2中，__init__.py 文件是必需的，用于将一个目录标记为包。虽然在Python 3中不再是强制要求，但它仍旧是推荐的做法。
    
  • 它明确地告诉Python解释器，这个目录应该被视为一个包，并且可以包含其他模块。
    
  
  
• 初始化代码：
  
  
  
  • 可以在 __init__.py 文件中编写初始化代码，这些代码会在包第一次被导入时执行。例如，设置全局变量、配置日记记录、初始化资源等。
    
  
  
• 控制包的内容：
  
  
  
  • 通过在 __init__.py 中定义 __all__ 列表，可以显式指定哪些模块或对象会被导出（即可以通过 from package import * 导入）。
    
  • 这有助于隐蔽内部实现细节，只暴露必要的接口给外部使用。
    
  
  
• 简化导入路径：
  
  
  
  • 可以在 __init__.py 中导入子模块或子包，使得用户可以直接从包名导入所需的功能，而不必要知道具体的子模块路径。例如：
    1. # 在 __init__.py 中
    2. from .submodule import some_function
    4. # 用户可以直接这样导入
    5. from package import some_function

    复制代码
  
  
• 惰性加载和按需加载：
  
  
  
  • 如您之前提到的，可以利用 __init__.py 实现惰性加载（Lazy Loading），即在实际必要时才加载某些模块，从而优化性能和内存使用。
    
  
  

示例

__init__.py 文件在Python包中扮演着多种脚色，包括但不限于：

• 标记目录为包
  
• 执行初始化代码
  
• 控制包的内容和接口
  
• 简化导入路径
  
• 实现惰性加载
  假设有一个项目布局如下：
  

1. my_package/
2.     __init__.py
3.     module_a.py
4.     module_b.py
5.     subpackage/
6.         __init__.py
7.         module_c.py

复制代码

简朴的 __init__.py

1. # my_package/__init__.py
2. print("Initializing my_package")

复制代码

当您导入 my_package 时，这段打印语句会执行，表明包正在被初始化。
控制包内容

1. # my_package/__init__.py
2. from .module_a import function_a
3. from .module_b import function_b
5. __all__ = ['function_a', 'function_b']

复制代码

在这种情况下，用户可以通过以下方式导入 function_a 和 function_b：

1. from my_package import function_a, function_b

复制代码

同时，from my_package import * 只会导入 __all__ 列表中指定的对象。
惰性加载

如前所述，可以使用 _LazyModule 类实现惰性加载：

1. # my_package/__init__.py
2. import sys
3. from typing import TYPE_CHECKING
4. from swift.utils.import_utils import _LazyModule
6. if TYPE_CHECKING:
7.     from .module_a import function_a
8.     from .module_b import function_b
9. else:
10.     _import_structure = {
11.         'module_a': ['function_a'],
12.         'module_b': ['function_b'],
13.     }
15.     sys.modules[__name__] = _LazyModule(
16.         __name__,
17.         globals()['__file__'],
18.         _import_structure,
19.         module_spec=__spec__,
20.     )

复制代码

在这个例子中，module_a 和 module_b 只有在它们的实际函数被调用时才会被加载。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。