[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"similar-THUDM--SwissArmyTransformer":3,"tool-THUDM--SwissArmyTransformer":61},[4,18,26,36,44,53],{"id":5,"name":6,"github_repo":7,"description_zh":8,"stars":9,"difficulty_score":10,"last_commit_at":11,"category_tags":12,"status":17},4358,"openclaw","openclaw\u002Fopenclaw","OpenClaw 是一款专为个人打造的本地化 AI 助手，旨在让你在自己的设备上拥有完全可控的智能伙伴。它打破了传统 AI 助手局限于特定网页或应用的束缚，能够直接接入你日常使用的各类通讯渠道，包括微信、WhatsApp、Telegram、Discord、iMessage 等数十种平台。无论你在哪个聊天软件中发送消息，OpenClaw 都能即时响应，甚至支持在 macOS、iOS 和 Android 设备上进行语音交互，并提供实时的画布渲染功能供你操控。\n\n这款工具主要解决了用户对数据隐私、响应速度以及“始终在线”体验的需求。通过将 AI 部署在本地，用户无需依赖云端服务即可享受快速、私密的智能辅助，真正实现了“你的数据，你做主”。其独特的技术亮点在于强大的网关架构，将控制平面与核心助手分离，确保跨平台通信的流畅性与扩展性。\n\nOpenClaw 非常适合希望构建个性化工作流的技术爱好者、开发者，以及注重隐私保护且不愿被单一生态绑定的普通用户。只要具备基础的终端操作能力（支持 macOS、Linux 及 Windows WSL2），即可通过简单的命令行引导完成部署。如果你渴望拥有一个懂你",349277,3,"2026-04-06T06:32:30",[13,14,15,16],"Agent","开发框架","图像","数据工具","ready",{"id":19,"name":20,"github_repo":21,"description_zh":22,"stars":23,"difficulty_score":10,"last_commit_at":24,"category_tags":25,"status":17},3808,"stable-diffusion-webui","AUTOMATIC1111\u002Fstable-diffusion-webui","stable-diffusion-webui 是一个基于 Gradio 构建的网页版操作界面，旨在让用户能够轻松地在本地运行和使用强大的 Stable Diffusion 图像生成模型。它解决了原始模型依赖命令行、操作门槛高且功能分散的痛点，将复杂的 AI 绘图流程整合进一个直观易用的图形化平台。\n\n无论是希望快速上手的普通创作者、需要精细控制画面细节的设计师，还是想要深入探索模型潜力的开发者与研究人员，都能从中获益。其核心亮点在于极高的功能丰富度：不仅支持文生图、图生图、局部重绘（Inpainting）和外绘（Outpainting）等基础模式，还独创了注意力机制调整、提示词矩阵、负向提示词以及“高清修复”等高级功能。此外，它内置了 GFPGAN 和 CodeFormer 等人脸修复工具，支持多种神经网络放大算法，并允许用户通过插件系统无限扩展能力。即使是显存有限的设备，stable-diffusion-webui 也提供了相应的优化选项，让高质量的 AI 艺术创作变得触手可及。",162132,"2026-04-05T11:01:52",[14,15,13],{"id":27,"name":28,"github_repo":29,"description_zh":30,"stars":31,"difficulty_score":32,"last_commit_at":33,"category_tags":34,"status":17},1381,"everything-claude-code","affaan-m\u002Feverything-claude-code","everything-claude-code 是一套专为 AI 编程助手（如 Claude Code、Codex、Cursor 等）打造的高性能优化系统。它不仅仅是一组配置文件，而是一个经过长期实战打磨的完整框架，旨在解决 AI 代理在实际开发中面临的效率低下、记忆丢失、安全隐患及缺乏持续学习能力等核心痛点。\n\n通过引入技能模块化、直觉增强、记忆持久化机制以及内置的安全扫描功能，everything-claude-code 能显著提升 AI 在复杂任务中的表现，帮助开发者构建更稳定、更智能的生产级 AI 代理。其独特的“研究优先”开发理念和针对 Token 消耗的优化策略，使得模型响应更快、成本更低，同时有效防御潜在的攻击向量。\n\n这套工具特别适合软件开发者、AI 研究人员以及希望深度定制 AI 工作流的技术团队使用。无论您是在构建大型代码库，还是需要 AI 协助进行安全审计与自动化测试，everything-claude-code 都能提供强大的底层支持。作为一个曾荣获 Anthropic 黑客大奖的开源项目，它融合了多语言支持与丰富的实战钩子（hooks），让 AI 真正成长为懂上",160015,2,"2026-04-18T11:30:52",[14,13,35],"语言模型",{"id":37,"name":38,"github_repo":39,"description_zh":40,"stars":41,"difficulty_score":32,"last_commit_at":42,"category_tags":43,"status":17},2271,"ComfyUI","Comfy-Org\u002FComfyUI","ComfyUI 是一款功能强大且高度模块化的视觉 AI 引擎，专为设计和执行复杂的 Stable Diffusion 图像生成流程而打造。它摒弃了传统的代码编写模式，采用直观的节点式流程图界面，让用户通过连接不同的功能模块即可构建个性化的生成管线。\n\n这一设计巧妙解决了高级 AI 绘图工作流配置复杂、灵活性不足的痛点。用户无需具备编程背景，也能自由组合模型、调整参数并实时预览效果，轻松实现从基础文生图到多步骤高清修复等各类复杂任务。ComfyUI 拥有极佳的兼容性，不仅支持 Windows、macOS 和 Linux 全平台，还广泛适配 NVIDIA、AMD、Intel 及苹果 Silicon 等多种硬件架构，并率先支持 SDXL、Flux、SD3 等前沿模型。\n\n无论是希望深入探索算法潜力的研究人员和开发者，还是追求极致创作自由度的设计师与资深 AI 绘画爱好者，ComfyUI 都能提供强大的支持。其独特的模块化架构允许社区不断扩展新功能，使其成为当前最灵活、生态最丰富的开源扩散模型工具之一，帮助用户将创意高效转化为现实。",109154,"2026-04-18T11:18:24",[14,15,13],{"id":45,"name":46,"github_repo":47,"description_zh":48,"stars":49,"difficulty_score":32,"last_commit_at":50,"category_tags":51,"status":17},6121,"gemini-cli","google-gemini\u002Fgemini-cli","gemini-cli 是一款由谷歌推出的开源 AI 命令行工具，它将强大的 Gemini 大模型能力直接集成到用户的终端环境中。对于习惯在命令行工作的开发者而言，它提供了一条从输入提示词到获取模型响应的最短路径，无需切换窗口即可享受智能辅助。\n\n这款工具主要解决了开发过程中频繁上下文切换的痛点，让用户能在熟悉的终端界面内直接完成代码理解、生成、调试以及自动化运维任务。无论是查询大型代码库、根据草图生成应用，还是执行复杂的 Git 操作，gemini-cli 都能通过自然语言指令高效处理。\n\n它特别适合广大软件工程师、DevOps 人员及技术研究人员使用。其核心亮点包括支持高达 100 万 token 的超长上下文窗口，具备出色的逻辑推理能力；内置 Google 搜索、文件操作及 Shell 命令执行等实用工具；更独特的是，它支持 MCP（模型上下文协议），允许用户灵活扩展自定义集成，连接如图像生成等外部能力。此外，个人谷歌账号即可享受免费的额度支持，且项目基于 Apache 2.0 协议完全开源，是提升终端工作效率的理想助手。",100752,"2026-04-10T01:20:03",[52,13,15,14],"插件",{"id":54,"name":55,"github_repo":56,"description_zh":57,"stars":58,"difficulty_score":32,"last_commit_at":59,"category_tags":60,"status":17},4721,"markitdown","microsoft\u002Fmarkitdown","MarkItDown 是一款由微软 AutoGen 团队打造的轻量级 Python 工具，专为将各类文件高效转换为 Markdown 格式而设计。它支持 PDF、Word、Excel、PPT、图片（含 OCR）、音频（含语音转录）、HTML 乃至 YouTube 链接等多种格式的解析，能够精准提取文档中的标题、列表、表格和链接等关键结构信息。\n\n在人工智能应用日益普及的今天，大语言模型（LLM）虽擅长处理文本，却难以直接读取复杂的二进制办公文档。MarkItDown 恰好解决了这一痛点，它将非结构化或半结构化的文件转化为模型“原生理解”且 Token 效率极高的 Markdown 格式，成为连接本地文件与 AI 分析 pipeline 的理想桥梁。此外，它还提供了 MCP（模型上下文协议）服务器，可无缝集成到 Claude Desktop 等 LLM 应用中。\n\n这款工具特别适合开发者、数据科学家及 AI 研究人员使用，尤其是那些需要构建文档检索增强生成（RAG）系统、进行批量文本分析或希望让 AI 助手直接“阅读”本地文件的用户。虽然生成的内容也具备一定可读性，但其核心优势在于为机器",93400,"2026-04-06T19:52:38",[52,14],{"id":62,"github_repo":63,"name":64,"description_en":65,"description_zh":66,"ai_summary_zh":66,"readme_en":67,"readme_zh":68,"quickstart_zh":69,"use_case_zh":70,"hero_image_url":71,"owner_login":72,"owner_name":73,"owner_avatar_url":74,"owner_bio":75,"owner_company":76,"owner_location":76,"owner_email":77,"owner_twitter":78,"owner_website":79,"owner_url":80,"languages":81,"stars":102,"forks":103,"last_commit_at":104,"license":105,"difficulty_score":10,"env_os":106,"env_gpu":107,"env_ram":108,"env_deps":109,"category_tags":114,"github_topics":115,"view_count":32,"oss_zip_url":76,"oss_zip_packed_at":76,"status":17,"created_at":119,"updated_at":120,"faqs":121,"releases":147},9228,"THUDM\u002FSwissArmyTransformer","SwissArmyTransformer","SwissArmyTransformer is a flexible and powerful library to develop your own Transformer variants.","SwissArmyTransformer 是一款灵活且强大的开源库，旨在帮助开发者轻松构建自定义的 Transformer 模型变体。正如其名“瑞士军刀”所示，它让 BERT、GPT、T5、GLM 等多种主流模型共享同一套核心代码骨架，仅需通过轻量级的“混合组件（Mixin）”即可适配不同场景，从而解决了传统开发中重复造轮子、代码冗余以及大模型训练难以扩展的痛点。\n\n该工具特别适合人工智能研究人员和算法工程师使用，尤其是那些需要预训练或微调参数量在 1 亿至 200 亿之间大型模型的用户。其核心技术亮点在于深度集成了 DeepSpeed-ZeRO 优化技术与模型并行策略，显著提升了大模型训练的效率与稳定性。此外，SwissArmyTransformer 独创的 Mixin 机制允许用户仅用一行代码即可为任意模型添加如 Prefix-tuning（前缀微调）或自回归缓存等复杂功能，无需修改底层架构。这种模块化设计不仅大幅降低了新模型的研发门槛，也让从实验原型到生产部署的过程变得更加简洁高效，是探索下一代 Transformer 架构的理想基石。","# Introduction\n`sat`(`SwissArmyTransformer`) is a flexible and powerful library to develop your own Transformer variants.\n\n`sat` is named after \"swiss army knife\", meaning that all the models (e.g. BERT, GPT, T5, GLM, CogView, ViT...) **share the same backbone code** and cater for versatile usages with some extra light-weight mixins. \n\n`sat` is powered by `deepspeed-ZeRO` and model parallelism, aiming to provide the best practice for pretraining and finetuning large models (100M\\~20B parameters). \n\n## Install\n```\n    pip install SwissArmyTransformer\n```\n# Features\n\n* **Add model-agnostic components**, e.g. prefix-tuning, in just *ONE* line! \n\n    - [Prefix-tuning](https:\u002F\u002Farxiv.org\u002Fpdf\u002F2101.00190) (or [P-tuning](https:\u002F\u002Farxiv.org\u002Fabs\u002F2103.10385)) improves finetuning via adding trainable parameters in each attention layer. To apply it to a [GLM](https:\u002F\u002Farxiv.org\u002Fpdf\u002F2103.10360.pdf) classification (or any other) model is easy with our library.\n\n    ```python\n        class ClassificationModel(GLMModel): # can also be BertModel, RobertaModel, etc. \n            def __init__(self, args, transformer=None, **kwargs):\n                super().__init__(args, transformer=transformer, **kwargs)\n                self.add_mixin('classification_head', MLPHeadMixin(args.hidden_size, 2048, 1))\n                # Arm an arbitrary model with Prefix-tuning with this line!\n                self.add_mixin('prefix-tuning', PrefixTuningMixin(args.num_layers, args.hidden_size \u002F\u002F args.num_attention_heads, args.num_attention_heads, args.prefix_len))\n    ```\n\n    - GPT and other auto-regressive models act differently during training and inference. During inference, text is generated token-by-token and we need to cache previous states for efficiency. With our lib, you only need to consider the behavior during training (teacher-forcing) and transform it to a cached auto-regressive model via adding a mixin:\n\n    ```python\n        model, args = AutoModel.from_pretrained('glm-10b-chinese', args)\n        model.add_mixin('auto-regressive', CachedAutoregressiveMixin())\n        # Generate a sequence with beam search\n        from sat.generation.autoregressive_sampling import filling_sequence\n        from sat.generation.sampling_strategies import BeamSearchStrategy\n        output, *mems = filling_sequence(model, input_seq,\n                        batch_size=args.batch_size,\n                        strategy=BeamSearchStrategy(args.batch_size))\n    ```     \n\n\n* **Build your Transformer-based model with minimal codes**. We mentioned [GLM](https:\u002F\u002Farxiv.org\u002Fpdf\u002F2103.10360.pdf), which only differs from standard transformer (called BaseModel) on position embedding (and training losses). We only need to focus on the related part when coding.\n\n    \u003Cdetails>\u003Csummary>Extend the whole definition: \u003C\u002Fsummary>\u003Cp>\n\n    ```python\n    class BlockPositionEmbeddingMixin(BaseMixin):\n        # Here define parameters for the mixin\n        def __init__(self, max_sequence_length, hidden_size, init_method_std=0.02):\n            super(BlockPositionEmbeddingMixin, self).__init__()\n            self.max_sequence_length = max_sequence_length\n            self.hidden_size = hidden_size\n            self.block_position_embeddings = torch.nn.Embedding(max_sequence_length, hidden_size)\n            torch.nn.init.normal_(self.block_position_embeddings.weight, mean=0.0, std=init_method_std)\n        \n        # Here define the method for the mixin\n        def position_embedding_forward(self, position_ids, **kwargs):\n            position_ids, block_position_ids = position_ids[:, 0], position_ids[:, 1]\n            position_embeddings = self.transformer.position_embeddings(position_ids)\n            block_position_embeddings = self.block_position_embeddings(block_position_ids)\n            return position_embeddings + block_position_embeddings\n\n    class GLMModel(BaseModel):\n        def __init__(self, args, transformer=None):\n            super().__init__(args, transformer=transformer)\n            self.add_mixin('block_position_embedding', \n                BlockPositionEmbeddingMixin(args.max_sequence_length, args.hidden_size)\n            ) # Add the mixin for GLM\n    ```\n\n*  **Comprehensive supports for training**. `sat` aims to provide the best practice for pretraining and finetuning, where you only need to finish `forward_step` and `create_dataset_function` but with hyperparameters to alter useful training configurations.\n    - Extend the training to multiple GPUs or nodes by specifying `--num_nodes`, `--num_gpus` and a simple `hostfile`. \n    - DeepSpeed and Model parallelism.\n    - Better integration of ZeRO-2 and activation checkpointing.\n    - Automatic extending and shuffling training data and `memmap`. \n    - Successfully support the training of [CogView2](http:\u002F\u002Fgithub.com\u002FTHUDM\u002FCogView2) and [CogVideo](https:\u002F\u002Fgithub.com\u002FTHUDM\u002Fcogvideo).\n    - The only open-source codebase supporting finetuning [T5-10B](https:\u002F\u002Farxiv.org\u002Fabs\u002F1910.10683) on GPUs currently.\n\n\u003C\u002Fp>\u003C\u002Fdetails>\n\n\n# Quick Tour\n\nThe most typical python file to use `Bert` in sat (for inference) is as follows:\n```python\n# @File: inference_bert.py\nfrom sat import get_args, get_tokenizer, AutoModel\n# Parse args, initialize the environment. This is necessary.\nargs = get_args() \n# Automatically download and load model. Will also dump model-related hyperparameters to args.\nmodel, args = AutoModel.from_pretrained('bert-base-uncased', args) \n# Get the BertTokenizer according to args.tokenizer_type (automatically set).\ntokenizer = get_tokenizer(args) \n# Here to use bert as you want!\n# ...\n```\nThen we can run the code via\n```bash\n    SAT_HOME=\u002Fpath\u002Fto\u002Fdownload python inference_bert.py --mode inference\n```\nAll officially supported model names are in [urls.py](sat\u002Fresources\u002Furls.py).\n\nTo finetune or pretrain a transformer is also extremely easy!\n```python\n# @File: finetune_bert.py\nfrom sat import get_args, get_tokenizer, AutoModel\nfrom sat.model.mixins import MLPHeadMixin\n\ndef create_dataset_function(path, args):\n    # Here to load the dataset\n    # ...\n    assert isinstance(dataset, torch.utils.data.Dataset)\n    return dataset\n\ndef forward_step(data_iterator, model, args, timers):\n    inputs = next(data_iterator) # from the dataset of create_dataset_function.\n    loss, *others = model(inputs)\n    return loss\n    \n# Parse args, initialize the environment. This is necessary.\nargs = get_args() \nmodel, args = AutoModel.from_pretrained('bert-base-uncased', args) \ntokenizer = get_tokenizer(args) \n# Here to use bert as you want!\nmodel.del_mixin('bert-final')\nmodel.add_mixin('classification_head', MLPHeadMixin(args.hidden_size, 2048, 1))\n# ONE LINE to train! \n# args already includes hyperparams such as lr, train-iters, zero-stage ...\ntraining_main(args, \n    model_cls=model, \n    forward_step_function=forward_step, # user define\n    create_dataset_function=create_dataset_function # user define\n)\n```\nThen we can run the code via\n```shell\ndeepspeed --include localhost:0,1 finetune_bert.py \\\n    --experiment-name ftbert \\\n    --mode finetune --train-iters 1000 --save \u002Fpath\u002Fto\u002Fsave \\\n    --train-data \u002Fpath\u002Fto\u002Ftrain --valid-data \u002Fpath\u002Fto\u002Fvalid \\\n    --lr 0.00002 --batch-size 8 --zero-stage 1 --fp16\n```\nHere we use data-parallel on GPUs 0,1. We can also launch the training on many inter-connected machines via `--hostfile \u002Fpath\u002Fto\u002Fhostfile`. See the tutorial for more details.\n\nTo write your own model, you only need to consider the difference between the standard Transformer. For example, if you have a idea to improve the attention operation:\n```python\nfrom sat.model import BaseMixin\nclass MyAttention(BaseMixin):\n    def __init__(self, hidden_size):\n        super(MyAttention, self).__init__()\n        # MyAttention may needs some new params, e.g. a learnable alpha.\n        self.learnable_alpha = torch.nn.Parameter(torch.ones(hidden_size))\n    \n    # This is a hook function, the name `attention_fn` is special.\n    def attention_fn(q, k, v, mask, dropout=None, **kwargs):\n        # Code for my attention.\n        # ...\n        return attention_results\n```\nHere `attention_fn` is a hook function, replacing the default action by the new function. All available hooks are in [transformer_defaults.py](\u002Fsat\u002Ftransformer_defaults.py). \nNow we can use `add_mixin` to apply our change to all the transformers, such as BERT, Vit and CogView. See the tutorial for more details. \n\n## Tutorials \n* [How to use pretrained models collected in sat?](tutorials\u002Fmodel_usage)\n* [Why and how to train models in sat?](tutorials\u002Ftraining)\n\n# Citation\nCurrently we don't have a paper, so you don't need to formally cite us!~ \n\nIf this project helps your research or engineering, use `\\footnote{https:\u002F\u002Fgithub.com\u002FTHUDM\u002FSwissArmyTransformer}` to mention us and recommend `SwissArmyTransformer` to others.\n\nThe tutorial for contributing sat is on the way!\n\nThe project is based on (a user of) DeepSpeed, Megatron-LM and Huggingface transformers. Thanks for their awesome work.\n","# 引言\n`sat`（`SwissArmyTransformer`）是一个灵活且功能强大的库，用于开发您自己的 Transformer 变体。\n\n`sat` 的名称源自“瑞士军刀”，意指所有模型（例如 BERT、GPT、T5、GLM、CogView、ViT 等）**共享相同的骨干代码**，并通过一些轻量级的混入模块来满足多种用途。\n\n`sat` 由 `deepspeed-ZeRO` 和模型并行技术驱动，旨在为大规模模型（1 亿至 200 亿参数）的预训练和微调提供最佳实践。\n\n## 安装\n```\n    pip install SwissArmyTransformer\n```\n# 特性\n\n* **添加与模型无关的组件**，例如前缀调优，只需 *一行* 代码！\n\n    - [前缀调优](https:\u002F\u002Farxiv.org\u002Fpdf\u002F2101.00190)（或 [P-tuning](https:\u002F\u002Farxiv.org\u002Fabs\u002F2103.10385)）通过在每个注意力层中添加可训练参数来改进微调。使用我们的库，将它应用于 [GLM](https:\u002F\u002Farxiv.org\u002Fpdf\u002F2103.10360.pdf) 分类模型（或任何其他模型）非常容易。\n\n    ```python\n        class ClassificationModel(GLMModel): # 也可以是 BertModel、RobertaModel 等。\n            def __init__(self, args, transformer=None, **kwargs):\n                super().__init__(args, transformer=transformer, **kwargs)\n                self.add_mixin('classification_head', MLPHeadMixin(args.hidden_size, 2048, 1))\n                # 仅需这一行代码，即可为任意模型配备前缀调优！\n                self.add_mixin('prefix-tuning', PrefixTuningMixin(args.num_layers, args.hidden_size \u002F\u002F args.num_attention_heads, args.num_attention_heads, args.prefix_len))\n    ```\n\n    - GPT 和其他自回归模型在训练和推理时的行为不同。在推理过程中，文本是逐 token 生成的，我们需要缓存之前的状态以提高效率。借助我们的库，您只需考虑训练阶段的行为（教师强制），并通过添加一个混入模块将其转换为缓存式自回归模型：\n\n    ```python\n        model, args = AutoModel.from_pretrained('glm-10b-chinese', args)\n        model.add_mixin('auto-regressive', CachedAutoregressiveMixin())\n        # 使用束搜索生成序列\n        from sat.generation.autoregressive_sampling import filling_sequence\n        from sat.generation.sampling_strategies import BeamSearchStrategy\n        output, *mems = filling_sequence(model, input_seq,\n                        batch_size=args.batch_size,\n                        strategy=BeamSearchStrategy(args.batch_size))\n    ```     \n\n\n* **用最少的代码构建基于 Transformer 的模型**。我们提到了 [GLM](https:\u002F\u002Farxiv.org\u002Fpdf\u002F2103.10360.pdf)，它与标准 Transformer（称为 BaseModel）的区别仅在于位置嵌入（以及训练损失）。我们在编码时只需关注相关部分。\n\n    \u003Cdetails>\u003Csummary>扩展完整定义：\u003C\u002Fsummary>\u003Cp>\n\n    ```python\n    class BlockPositionEmbeddingMixin(BaseMixin):\n        # 在这里定义混入模块的参数\n        def __init__(self, max_sequence_length, hidden_size, init_method_std=0.02):\n            super(BlockPositionEmbeddingMixin, self).__init__()\n            self.max_sequence_length = max_sequence_length\n            self.hidden_size = hidden_size\n            self.block_position_embeddings = torch.nn.Embedding(max_sequence_length, hidden_size)\n            torch.nn.init.normal_(self.block_position_embeddings.weight, mean=0.0, std=init_method_std)\n        \n        # 在这里定义混入模块的方法\n        def position_embedding_forward(self, position_ids, **kwargs):\n            position_ids, block_position_ids = position_ids[:, 0], position_ids[:, 1]\n            position_embeddings = self.transformer.position_embeddings(position_ids)\n            block_position_embeddings = self.block_position_embeddings(block_position_ids)\n            return position_embeddings + block_position_embeddings\n\n    class GLMModel(BaseModel):\n        def __init__(self, args, transformer=None):\n            super().__init__(args, transformer=transformer)\n            self.add_mixin('block_position_embedding', \n                BlockPositionEmbeddingMixin(args.max_sequence_length, args.hidden_size)\n            ) # 为 GLM 添加混入模块\n    ```\n\n*  **全面的训练支持**。`sat` 致力于提供预训练和微调的最佳实践，您只需完成 `forward_step` 和 `create_dataset_function`，并通过超参数调整有用的训练配置。\n    - 通过指定 `--num_nodes`、`--num_gpus` 和简单的 `hostfile`，可以将训练扩展到多台 GPU 或节点。\n    - DeepSpeed 和模型并行技术。\n    - 更好地集成 ZeRO-2 和激活检查点。\n    - 自动扩展和打乱训练数据，并支持 `memmap`。\n    - 成功支持 [CogView2](http:\u002F\u002Fgithub.com\u002FTHUDM\u002FCogView2) 和 [CogVideo](https:\u002F\u002Fgithub.com\u002FTHUDM\u002Fcogvideo) 的训练。\n    - 目前唯一支持在 GPU 上微调 [T5-10B](https:\u002F\u002Farxiv.org\u002Fabs\u002F1910.10683) 的开源代码库。\n\n\u003C\u002Fp>\u003C\u002Fdetails>\n\n\n# 快速游览\n\n在 `sat` 中使用 `Bert` 进行推理的典型 Python 文件如下：\n```python\n# @文件: inference_bert.py\nfrom sat import get_args, get_tokenizer, AutoModel\n# 解析参数，初始化环境。这是必要的。\nargs = get_args() \n# 自动下载并加载模型。同时会将模型相关的超参数存储到 args 中。\nmodel, args = AutoModel.from_pretrained('bert-base-uncased', args) \n# 根据 args.tokenizer_type（自动设置）获取 BertTokenizer。\ntokenizer = get_tokenizer(args) \n# 现在您可以按需使用 Bert 了！\n# ...\n```\n然后我们可以通过以下命令运行代码：\n```bash\n    SAT_HOME=\u002Fpath\u002Fto\u002Fdownload python inference_bert.py --mode inference\n```\n所有官方支持的模型名称都列在 [urls.py](sat\u002Fresources\u002Furls.py) 中。\n\n对 Transformer 进行微调或预训练也非常简单！\n```python\n# @文件: finetune_bert.py\nfrom sat import get_args, get_tokenizer, AutoModel\nfrom sat.model.mixins import MLPHeadMixin\n\ndef create_dataset_function(path, args):\n    # 在这里加载数据集\n    # ...\n    assert isinstance(dataset, torch.utils.data.Dataset)\n    return dataset\n\ndef forward_step(data_iterator, model, args, timers):\n    inputs = next(data_iterator) # 来自 create_dataset_function 加载的数据集。\n    loss, *others = model(inputs)\n    return loss\n    \n# 解析参数，初始化环境。这是必要的。\nargs = get_args() \nmodel, args = AutoModel.from_pretrained('bert-base-uncased', args) \ntokenizer = get_tokenizer(args) \n# 现在您可以按需使用 Bert 了！\nmodel.del_mixin('bert-final')\nmodel.add_mixin('classification_head', MLPHeadMixin(args.hidden_size, 2048, 1))\n# 仅需一行代码即可开始训练！\n\n# args 已经包含了学习率、训练迭代次数、zero-stage 等超参数...\ntraining_main(args, \n    model_cls=model, \n    forward_step_function=forward_step, # 用户自定义\n    create_dataset_function=create_dataset_function # 用户自定义\n)\n```\n然后我们可以通过以下命令运行代码：\n```shell\ndeepspeed --include localhost:0,1 finetune_bert.py \\\n    --experiment-name ftbert \\\n    --mode finetune --train-iters 1000 --save \u002Fpath\u002Fto\u002Fsave \\\n    --train-data \u002Fpath\u002Fto\u002Ftrain --valid-data \u002Fpath\u002Fto\u002Fvalid \\\n    --lr 0.00002 --batch-size 8 --zero-stage 1 --fp16\n```\n这里我们在 GPU 0 和 1 上使用数据并行。我们也可以通过 `--hostfile \u002Fpath\u002Fto\u002Fhostfile` 在多台互联的机器上启动训练。更多详情请参阅教程。\n\n要编写自己的模型，你只需要考虑它与标准 Transformer 的不同之处。例如，如果你有一个改进注意力机制的想法：\n```python\nfrom sat.model import BaseMixin\nclass MyAttention(BaseMixin):\n    def __init__(self, hidden_size):\n        super(MyAttention, self).__init__()\n        # MyAttention 可能需要一些新的参数，比如一个可学习的 alpha。\n        self.learnable_alpha = torch.nn.Parameter(torch.ones(hidden_size))\n    \n    # 这是一个钩子函数，函数名 `attention_fn` 是特殊的。\n    def attention_fn(q, k, v, mask, dropout=None, **kwargs):\n        # 我的注意力机制实现代码。\n        # ...\n        return attention_results\n```\n这里的 `attention_fn` 是一个钩子函数，它会替换默认的注意力计算过程。所有可用的钩子函数都在 [transformer_defaults.py](\u002Fsat\u002Ftransformer_defaults.py) 中。现在我们可以使用 `add_mixin` 将我们的修改应用到所有的 Transformer 模型中，比如 BERT、Vit 和 CogView。更多细节请参阅教程。\n\n## 教程\n* [如何使用 sat 中收集的预训练模型？](tutorials\u002Fmodel_usage)\n* [为什么以及如何在 sat 中训练模型？](tutorials\u002Ftraining)\n\n# 引用\n目前我们还没有发表论文，所以不需要正式引用我们！~\n\n如果这个项目对你的研究或工程工作有所帮助，请使用 `\\footnote{https:\u002F\u002Fgithub.com\u002FTHUDM\u002FSwissArmyTransformer}` 来提及我们，并向他人推荐 `SwissArmyTransformer`。\n\n关于如何为 sat 贡献代码的教程正在准备中！\n\n该项目基于 DeepSpeed、Megatron-LM 和 Huggingface Transformers（由其用户开发）。感谢这些优秀团队的工作。","# SwissArmyTransformer 快速上手指南\n\nSwissArmyTransformer (简称 `sat`) 是一个灵活且强大的库，旨在帮助开发者构建自己的 Transformer 变体。其核心理念是“瑞士军刀”，即所有模型（如 BERT, GPT, T5, GLM, CogView, ViT 等）**共享同一套骨干代码**，并通过轻量级的 Mixin 机制实现多样化功能。该工具基于 `deepspeed-ZeRO` 和模型并行技术，专为大规模模型（1 亿至 200 亿参数）的预训练和微调提供最佳实践。\n\n## 环境准备\n\n*   **系统要求**：Linux 操作系统（推荐 Ubuntu）。\n*   **Python 版本**：建议 Python 3.8 或更高版本。\n*   **前置依赖**：\n    *   PyTorch (需与 CUDA 版本匹配)\n    *   DeepSpeed (用于分布式训练和 ZeRO 优化)\n    *   NVIDIA GPU (用于加速训练和推理，支持多卡及多机分布式)\n\n> **提示**：确保已正确安装 CUDA 驱动和对应的 PyTorch 版本，以发挥 `sat` 在大规模模型训练上的性能优势。\n\n## 安装步骤\n\n通过 pip 直接安装官方发布版本：\n\n```bash\npip install SwissArmyTransformer\n```\n\n> **国内加速建议**：如果下载速度较慢，推荐使用国内镜像源进行安装：\n> ```bash\n> pip install SwissArmyTransformer -i https:\u002F\u002Fpypi.tuna.tsinghua.edu.cn\u002Fsimple\n> ```\n\n## 基本使用\n\n### 1. 模型推理 (Inference)\n\n以下示例展示了如何加载预训练的 BERT 模型并进行推理。`sat` 会自动处理模型下载和环境初始化。\n\n```python\n# @File: inference_bert.py\nfrom sat import get_args, get_tokenizer, AutoModel\n\n# 解析参数并初始化环境（必需步骤）\nargs = get_args() \n\n# 自动下载并加载模型，同时将模型相关的超参数写入 args\nmodel, args = AutoModel.from_pretrained('bert-base-uncased', args) \n\n# 根据 args.tokenizer_type 获取对应的分词器\ntokenizer = get_tokenizer(args) \n\n# 在此处使用 bert 进行你的任务！\n# ...\n```\n\n运行上述代码：\n\n```bash\nSAT_HOME=\u002Fpath\u002Fto\u002Fdownload python inference_bert.py --mode inference\n```\n\n*注：`SAT_HOME` 环境变量用于指定模型文件的下载保存路径。所有官方支持的模型名称可在 `sat\u002Fresources\u002Furls.py` 中查看。*\n\n### 2. 模型微调 (Finetuning)\n\n`sat` 让微调变得极其简单。你只需定义数据加载函数和前向传播步骤，其余训练配置（如学习率、Zero 阶段等）均可通过命令行参数控制。\n\n```python\n# @File: finetune_bert.py\nfrom sat import get_args, get_tokenizer, AutoModel\nfrom sat.model.mixins import MLPHeadMixin\nfrom sat.training.deepspeed_training import training_main\n\ndef create_dataset_function(path, args):\n    # 在此处加载数据集\n    # ...\n    assert isinstance(dataset, torch.utils.data.Dataset)\n    return dataset\n\ndef forward_step(data_iterator, model, args, timers):\n    inputs = next(data_iterator) # 来自 create_dataset_function 定义的数据集\n    loss, *others = model(inputs)\n    return loss\n    \n# 解析参数并初始化环境\nargs = get_args() \nmodel, args = AutoModel.from_pretrained('bert-base-uncased', args) \ntokenizer = get_tokenizer(args) \n\n# 修改模型结构：移除原有头部，添加分类头\nmodel.del_mixin('bert-final')\nmodel.add_mixin('classification_head', MLPHeadMixin(args.hidden_size, 2048, 1))\n\n# 一行代码启动训练！\n# args 已包含 lr, train-iters, zero-stage 等超参数\ntraining_main(args, \n    model_cls=model, \n    forward_step_function=forward_step, # 用户自定义\n    create_dataset_function=create_dataset_function # 用户自定义\n)\n```\n\n运行微调脚本（示例使用 2 张 GPU 进行数据并行训练）：\n\n```shell\ndeepspeed --include localhost:0,1 finetune_bert.py \\\n    --experiment-name ftbert \\\n    --mode finetune --train-iters 1000 --save \u002Fpath\u002Fto\u002Fsave \\\n    --train-data \u002Fpath\u002Fto\u002Ftrain --valid-data \u002Fpath\u002Fto\u002Fvalid \\\n    --lr 0.00002 --batch-size 8 --zero-stage 1 --fp16\n```\n\n*   **分布式扩展**：如需在多机集群上训练，可通过 `--hostfile \u002Fpath\u002Fto\u002Fhostfile` 指定主机文件。\n*   **混合精度训练**：示例中已开启 `--fp16` 以节省显存并加速训练。\n\n### 3. 自定义模型组件 (Mixin)\n\n`sat` 的核心特性是通过 Mixin 机制轻松扩展模型。例如，若要改进注意力机制，只需定义一个继承自 `BaseMixin` 的类并实现对应的钩子函数：\n\n```python\nfrom sat.model import BaseMixin\nimport torch\n\nclass MyAttention(BaseMixin):\n    def __init__(self, hidden_size):\n        super(MyAttention, self).__init__()\n        # 定义新参数，例如可学习的 alpha\n        self.learnable_alpha = torch.nn.Parameter(torch.ones(hidden_size))\n    \n    # 钩子函数，名称 `attention_fn` 是特殊的，将替换默认行为\n    def attention_fn(q, k, v, mask, dropout=None, **kwargs):\n        # 在此编写自定义的注意力逻辑\n        # ...\n        return attention_results\n```\n\n定义完成后，使用 `model.add_mixin('my_attention', MyAttention(...))` 即可将该改进应用到 BERT、ViT 或 CogView 等任何基于 `sat` 的模型中。","某 AI 实验室团队正致力于基于 GLM 架构研发一款垂直领域的法律大模型，并计划引入 Prefix-tuning 技术以低成本适配多个细分法律任务。\n\n### 没有 SwissArmyTransformer 时\n- **代码复用率极低**：若要尝试 BERT、GPT 或 GLM 等不同骨干网络，必须为每种架构单独重写训练循环和注意力机制，导致大量重复劳动。\n- **新功能集成困难**：想加入 Prefix-tuning 等前沿微调技术，需深入修改模型底层源码，极易破坏原有逻辑且调试周期长达数周。\n- **推理与训练割裂**：自回归模型在训练（教师强制）和推理（逐词生成+缓存）时的行为差异巨大，开发者需维护两套完全不同的代码逻辑。\n- **大模型扩展受限**：缺乏原生的 DeepSpeed-ZeRO 和模型并行支持，难以在有限显存下高效预训练或微调参数量达百亿级的模型。\n\n### 使用 SwissArmyTransformer 后\n- **架构切换零成本**：所有模型共享同一套骨干代码，仅通过更换类名即可在 BERT、GLM 等架构间无缝切换，专注业务逻辑而非底层实现。\n- **插件式功能加载**：仅需一行 `add_mixin` 代码即可为任意模型武装 Prefix-tuning 能力，无需触碰核心源码，实验迭代从周级缩短至小时级。\n- **训推一体自动化**：开发者只需关注训练态逻辑，添加 `CachedAutoregressiveMixin` 混入类后，库自动处理推理时的状态缓存与束搜索生成。\n- **原生大规模支持**：内置 DeepSpeed-ZeRO 优化与模型并行策略，让团队能轻松驾驭 100M 至 20B 参数规模的模型预训练与微调任务。\n\nSwissArmyTransformer 通过“混入式”架构设计，将大模型研发从繁琐的底层造轮子解放为高效的积木式创新。","https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002FTHUDM_SwissArmyTransformer_0f7984e0.png","THUDM","THUKEG","https:\u002F\u002Foss.gittoolsai.com\u002Favatars\u002FTHUDM_698cabbc.png","ChatGLM, GLM-4, CogVLM, CodeGeeX, CogView, ImageReward, CogVideoX | CogDL, GraphMAE, AMiner | Zhipu.ai (Z.ai) & Knowledge Engineering Group (KEG)",null,"keg.cs.tsinghua@gmail.com","thukeg","https:\u002F\u002Fhuggingface.co\u002FTHUDM","https:\u002F\u002Fgithub.com\u002FTHUDM",[82,86,90,94,98],{"name":83,"color":84,"percentage":85},"Python","#3572A5",97.4,{"name":87,"color":88,"percentage":89},"Cuda","#3A4E3A",1.5,{"name":91,"color":92,"percentage":93},"C++","#f34b7d",0.9,{"name":95,"color":96,"percentage":97},"Shell","#89e051",0.2,{"name":99,"color":100,"percentage":101},"C","#555555",0,1116,99,"2026-04-02T13:20:45","Apache-2.0","未说明","必需 NVIDIA GPU（基于 DeepSpeed 和模型并行特性），具体型号和显存大小取决于模型规模（支持 100M~20B 参数模型），需支持 CUDA（版本未明确指定）","未说明（建议根据模型规模配置，大模型训练需大量内存）",{"notes":110,"python":106,"dependencies":111},"该工具基于 DeepSpeed、Megatron-LM 和 Huggingface transformers 构建，专为大规模模型（最高 200 亿参数）的预训练和微调设计。支持通过命令行参数（如 --num_gpus, --hostfile）轻松扩展至多卡或多节点分布式训练。支持 ZeRO-2 优化器和激活重计算技术。首次使用可通过 AutoModel.from_pretrained 自动下载模型。",[112,113,64],"deepspeed","torch",[14,35],[116,117,118],"pytorch","transformer","pretrained-models","2026-03-27T02:49:30.150509","2026-04-19T03:05:11.026340",[122,127,132,137,142],{"id":123,"question_zh":124,"answer_zh":125,"source_url":126},41423,"在模型并行（Model Parallel）训练中使用 LoRA 时，权重矩阵 A 和 B 是如何分布的？为什么代码中使用了 `copy_to_model_parallel_region`？","在模型并行设置下：\n1. **矩阵 B**：在不同进程（设备）间是切分的（split），即每个设备上的 B 是不同的，对应于原始权重的切分部分。代码中标记为 `B.model_parallel = True`，DeepSpeed 会自动处理。\n2. **矩阵 A**：在所有设备上保持一致。虽然初始化时基于切分的权重创建，但通过前向传播中的 `copy_to_model_parallel_region` 操作，确保在反向传播时梯度会在设备间进行 `all_reduce` 聚合。由于初始化和梯度更新始终一致，A 在训练过程中保持所有设备同步。\n参考代码逻辑：https:\u002F\u002Fgithub.com\u002FTHUDM\u002FSwissArmyTransformer\u002Fblob\u002Faa1277ec81c56b447e00a987f31caf1d0afe7856\u002Fsat\u002Fmodel\u002Ffinetune\u002Flora2.py#L131","https:\u002F\u002Fgithub.com\u002FTHUDM\u002FSwissArmyTransformer\u002Fissues\u002F162",{"id":128,"question_zh":129,"answer_zh":130,"source_url":131},41424,"SwissArmyTransformer (SAT) 能否直接读取 HuggingFace 格式的 `.bin` 权重文件进行微调训练？","不能直接转换或使用。因为 SAT 与 HuggingFace 的参数命名和文件格式不同，HF 的 `.bin` 文件通常仅用于推理（inference），无法直接用于 SAT 的训练流程。\n解决方案：\n1. 使用官方提供的 SAT 格式权重文件（通常包含配置和特定格式的权重）。\n2. 如果只有 HF 权重，需要自行编写代码实现参数映射和格式转换，或者重新实现对应的训练代码以适配 HF 格式。\n3. 对于 VisualGLM-6B 等模型，建议从国内镜像下载已转换好的 SAT 格式文件（如 wisemodel.cn 上的资源）。","https:\u002F\u002Fgithub.com\u002FTHUDM\u002FSwissArmyTransformer\u002Fissues\u002F157",{"id":133,"question_zh":134,"answer_zh":135,"source_url":136},41425,"如何加载预训练模型并在不同的模型并行度（model_parallel_size）下进行继续训练？例如原模型是 mp=1，我想用 mp=2 训练。","可以通过 `from_pretrained` 函数加载模型时覆盖参数来实现。即使预训练模型是在 mp=1 下训练的，也可以在加载时指定新的并行度进行微调。\n具体代码示例：\n```python\nmodel, args = AutoModel.from_pretrained('path_to_model', overwrite_args={'model_parallel_size': 2})\n```\n这样即可在 model_parallel_size=2 的环境下继续训练。官方示例可参考：https:\u002F\u002Fgithub.com\u002FTHUDM\u002FSwissArmyTransformer\u002Fblob\u002Fmain\u002Fexamples\u002Fllama\u002Fsplit_model.py","https:\u002F\u002Fgithub.com\u002FTHUDM\u002FSwissArmyTransformer\u002Fissues\u002F70",{"id":138,"question_zh":139,"answer_zh":140,"source_url":141},41426,"如何使用 HuggingFace 接口加载 icetk_glm_130B 的 tokenizer 和 GLM-130B 模型？它与 ChatGLM 系列有什么区别？","1. **加载方法**：SAT 框架下的模型代码结构与 HF 有所不同，建议直接参考 SAT 仓库中的官方模型实现代码进行对比学习：https:\u002F\u002Fgithub.com\u002FTHUDM\u002FSwissArmyTransformer\u002Ftree\u002Fmain\u002Fsat\u002Fmodel\u002Fofficial。每个模型定义约 100 行，易于理解。\n2. **详细用法**：具体加载和运行流程请参考 GLM-130B 的专用仓库：https:\u002F\u002Fgithub.com\u002FTHUDM\u002FGLM-130B。\n3. **区别**：GLM-130B 是千亿参数级别的基座模型，而 ChatGLM-6B\u002FChatGLM2-6B 是基于较小参数量（6B）并经过指令微调的版本，两者在架构细节、词表和应用场景上均有差异，具体需对比源码或技术报告。","https:\u002F\u002Fgithub.com\u002FTHUDM\u002FSwissArmyTransformer\u002Fissues\u002F145",{"id":143,"question_zh":144,"answer_zh":145,"source_url":146},41427,"在进行 BERT 蒸馏（Distillation）任务保存模型时，报错 `argparse.ArgumentError: argument --num-types: conflicting option string`，如何解决？","该错误是由于在保存模型提取参数时，子模型的参数定义发生了冲突（重复添加了 `--num-types` 参数）。\n解决方案：\n维护者已修复此问题并合并了相关代码。请拉取最新的代码版本，或者应用相关的修复补丁（PR #61）。\n修复逻辑主要是在保存时检查子模型枚举过程中是否存在参数重复，避免重复注册 argparse 参数。\n参考修复分支：https:\u002F\u002Fgithub.com\u002FTHUDM\u002FSwissArmyTransformer\u002Fpull\u002F61","https:\u002F\u002Fgithub.com\u002FTHUDM\u002FSwissArmyTransformer\u002Fissues\u002F60",[148],{"id":149,"version":150,"summary_zh":76,"released_at":151},333422,"v0.1.10","2022-06-12T07:21:32"]