许可证: mit
库名称: transformers
管道标签: 文本生成
基础模型: GSAI-ML/LLaDA-8B-Instruct
语言:

• 英文
  标签:
• llada
• 工具调用
• lora
• peft
• 函数调用
• 工具
• 聊天机器人
• 助手
• 监督微调

LLaDA-8B-工具版

此仓库包含GSAI-ML/LLaDA-8B-Instruct模型的变体，由Proximile LLC进行微调以增强其工具调用能力。Proximile专注于为中小企业提供安全、本地化的人工智能解决方案。

更新时间线

• 2025年5月14日 – 首次公开发布。训练样本中缺少填充生成窗口其余部分的填充标记。
• 2025年5月17日 – 修复训练脚本以包含正确的填充；更新后的模型权重推送至此仓库。

关于LLaDA

LLaDA（基于掩码的大规模语言扩散模型）是一种新颖的语言模型架构，使用离散扩散进行文本生成。与传统的自回归模型不同，LLaDA通过迭代去噪过程生成文本，逐步用基于置信度分数的预测标记替换掩码标记。

模型描述

此合并的LoRA模型经过训练，以提升LLaDA处理工具调用任务的能力，包括：

• 生成正确的工具调用JSON
• 处理工具响应数据
• 根据工具输出提供有用的答案

训练细节

• 基础模型: GSAI-ML/LLaDA-8B-Instruct
• 训练方法: 使用LoRA进行监督微调（SFT）
• LoRA配置:
  • 秩（r）: 128
  • Alpha: 256
  • 目标模块: q_proj, k_proj, v_proj, gate_proj
• 训练数据: 修改后的ToolACE数据集子集。

安装

pip install transformers peft torch bitsandbytes  

使用

使用此模型的方法如下：

from transformers import AutoTokenizer, AutoModel  
from peft import PeftModel  

# 加载基础模型和分词器  
model_name = "Proximile/LLaDA-8B-Tools"  
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)  
model = AutoModel.from_pretrained(model_name, trust_remote_code=True, device_map="auto")  

聊天补全示例脚本

以下是使用模型进行工具调用聊天补全的完整示例：

import torch  
import json  
from transformers import AutoTokenizer, AutoModel  

# 常量  
MASK_TOKEN_ID = 126336  

def add_gumbel_noise(logits, temperature):  
    '''  
    古贝尔最大值是一种用于采样分类分布的方法。  
    对于扩散模型，低精度的古贝尔最大值会影响生成质量。  
    '''  
    if temperature <= 0:  
        return logits  
          
    logits = logits.to(torch.float64)  
    noise = torch.rand_like(logits, dtype=torch.float64)  
    gumbel_noise = (- torch.log(noise)) ** temperature  
    return logits.exp() / gumbel_noise  

def get_num_transfer_tokens(mask_index, steps):  
    '''  
    在反向过程中，我们预先计算每一步要转移的标记数量。  
    '''  
    mask_num = mask_index.sum(dim=1, keepdim=True)  
      
    # 确保至少有一个步骤  
    if steps == 0:  
        steps = 1  
          
    base = mask_num // steps  
    remainder = mask_num % steps  
      
    num_transfer_tokens = torch.zeros(mask_num.size(0), steps, device=mask_index.device, dtype=torch.int64) + base  
      
    for i in range(mask_num.size(0)):  
        if remainder[i] > 0:  
            num_transfer_tokens[i, :remainder[i]] += 1  
              
    return num_transfer_tokens  

def generate(model, prompt, steps=128, gen_length=128, block_length=32, temperature=0.,  
             remasking='low_confidence', mask_id=MASK_TOKEN_ID):  
    '''  
    使用LLaDA的基于扩散的生成过程生成文本。  
    '''  
    device = next(model.parameters()).device  
    prompt = prompt.to(device)  
      
    x = torch.full((1, prompt.shape[1] + gen_length), mask_id, dtype=torch.long).to(device)  
    x[:, :prompt.shape[1]] = prompt.clone()  
      
    prompt_index = (x != mask_id)  
      
    assert gen_length % block_length == 0  
    num_blocks = gen_length // block_length  
      
    assert steps % num_blocks == 0  
    steps_per_block = steps // num_blocks  
      
    for num_block in range(num_blocks):  
        block_mask_index = (x[:, prompt.shape[1] + num_block * block_length: prompt.shape[1] + (num_block + 1) * block_length:] == mask_id)  
        num_transfer_tokens = get_num_transfer_tokens(block_mask_index, steps_per_block)  
          
        for i in range(steps_per_block):  
            mask_index = (x == mask_id)  
            if not mask_index.any():  
                break  
                  
            outputs = model(x)  
            logits = outputs.logits  
              
            logits_with_noise = add_gumbel_noise(logits, temperature=temperature)  
            x0 = torch.argmax(logits_with_noise, dim=-1)  # b, l  
              
            if remasking == 'low_confidence':  
                p = torch.nn.functional.softmax(logits.to(torch.float64), dim=-1)  
                x0_p = torch.squeeze(  
                    torch.gather(p, dim=-1, index=torch.unsqueeze(x0, -1)), -1)  # b, l  
            elif remasking == 'random':  
                x0_p = torch.rand((x0.shape[0], x0.shape[1]), device=x0.device)  
            else:  
                raise NotImplementedError(remasking)  
              
            x0_p[:, prompt.shape[1] + (num_block + 1) * block_length:] = -float('inf')  
              
            x0 = torch.where(mask_index, x0, x)  
            confidence = torch.where(mask_index, x0_p, -float('inf'))  
              
            transfer_index = torch.zeros_like(x0, dtype=torch.bool, device=x0.device)  
            for j in range(confidence.shape[0]):  
                _, select_index = torch.topk(confidence[j], k=num_transfer_tokens[j, i])  
                transfer_index[j, select_index] = True  
            x[transfer_index] = x0[transfer_index]  
      
    return x  

def chat_completion(model, tokenizer, messages, temperature=0.1, gen_length=128, steps=128):  
    """  
    生成聊天补全。  
      
    参数:  
        model: LLaDA工具调用模型  
        tokenizer: 分词器  
        messages: 包含'role'和'content'键的消息字典列表  
        temperature: 生成温度（0为贪婪）  
        gen_length: 生成文本的最大长度  
        steps: 去噪步骤数  
          
    返回:  
        生成的响应文本  
    """  
    # 为模型格式化输入  
    formatted_input = tokenizer.apply_chat_template(  
        messages,   
        tokenize=False,   
        add_generation_prompt=True  
    )  
      
    # 分词输入  
    input_ids = tokenizer(formatted_input, return_tensors="pt")["input_ids"]  
      
    # 生成响应  
    with torch.no_grad():  
        output_ids = generate(  
            model,   
            input_ids,   
            steps=steps,  
            gen_length=gen_length,  
            block_length=32,  
            temperature=temperature,  
            remasking='low_confidence'  
        )  
      
    # 解码生成的输出  
    generated_text = tokenizer.decode(output_ids[0, input_ids.shape[1]:], skip_special_tokens=False).split("<|")[0]  
    return generated_text  

# 示例用法  
if __name__ == "__main__":  
    # 加载基础模型和分词器  
    model_name = "Proximile/LLaDA-8B-Tools"  
    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)  
    model = AutoModel.from_pretrained(model_name, trust_remote_code=True, device_map="auto")  
      
    # 定义工具调用函数模式  
    tool_schema = [  
        {  
            "type": "function",  
            "function": {  
                "name": "get_weather",  
                "description": "获取给定位置的当前天气",  
                "parameters": {  
                    "type": "object",  
                    "properties": {  
                        "location": {  
                            "type": "string",  
                            "description": "城市和州，例如：San Francisco, CA"  
                        },  
                        "unit": {  
                            "type": "string",  
                            "enum": ["celsius", "fahrenheit"],  
                            "description": "温度单位"  
                        }  
                    },  
                    "required": ["location", "unit"]  
                }  
            }  
        }  
    ]  
      
    # 创建包含工具描述的系统提示的对话  
    system_prompt = """你是一个具有工具调用能力的助手。当你收到工具调用响应时，使用输出格式化原始用户问题的答案。  

如果你选择使用以下一个或多个工具函数，请用包含适当参数的JSON函数调用列表进行响应，以最佳回答给定的提示。  

列表中的每个工具请求应完全采用以下格式：{"name": 函数名, "parameters": {参数名和值的字典}}。不要使用变量。只需一个两键字典的列表，每个字典以函数名开头，后跟参数字典。  

以下是你可以使用的工具函数：  

""" + json.dumps(tool_schema, indent=4) + """  

在收到函数调用的结果后，你需要向用户制定响应。如果返回数据中未找到所需信息，要么尝试新的函数调用，要么告知用户你无法根据现有知识回答。用户无法看到函数结果。你必须解释数据并根据数据提供响应。  

如果用户请求不需要函数调用，直接回答用户的查询即可。"""  
      
    messages = [  
        {"role": "system", "content": system_prompt},  
        {"role": "user", "content": "纽约的天气怎么样？"}  
    ]  
      
    # 生成助手响应（预期工具调用）  
    assistant_response = chat_completion(model, tokenizer, messages)  
    print(f"助手: {assistant_response}")  
      
    # 模拟工具响应  
    tool_response = json.dumps({  
        "location": "New York, NY",  
        "temperature": 72,  
        "unit": "fahrenheit",  
        "condition": "Partly Cloudy",  
        "humidity": 65,  
        "wind_speed": 8,  
        "wind_direction": "NE"  
    })  
      
    # 将助手和工具响应添加到对话中  
    messages.append({"role": "assistant", "content": assistant_response})  
    messages.append({"role": "ipython", "content": tool_response})  
      
    # 生成最终的助手响应  
    final_response = chat_completion(model, tokenizer, messages)  
    print(f"助手（带工具数据）: {final_response}")  

# 助手: [{"name": "get_weather", "parameters": {"location": "New York", "unit": "fahrenheit"}}]  
# 助手（带工具数据）: 纽约当前的天气如下：  
# - 温度: 72°F  
# - 天气状况: 局部多云  
# - 湿度: 65%  
# - 风速: 8英里/小时  
# - 风向: 东北风  

限制

• LLaDA基于扩散的生成与标准LLM不同，在某些情况下可能表现不同
• 模型仍可能产生幻觉或生成错误的工具调用格式
• 工具调用的格式必须与示例中显示的完全匹配（这是官方llama 3.1格式的修改版本）

引用

如果在研究中使用此模型，请引用原始LLaDA论文以及此适配器：

@misc{llada-8b-tools,  
  author = {Proximile LLC},  
  title = {LLaDA-8B-Tools},  
  year = {2025},  
  publisher = {Hugging Face},  
  howpublished = {\url{https://huggingface.co/Proximile/LLaDA-8B-Tools}}  
}  

关于Proximile LLC

Proximile LLC为中小企业提供安全、经济高效且私密的人工智能解决方案。我们专注于：

• 本地化AI推理解决方案，确保无与伦比的隐私
• 经济高效的硬件配置，包括Jetson Orin Nano Super
• 安全本地AI应用，包括聊天机器人、RAG系统和自定义AI工具
• 专业服务，涵盖合规与治理、知识管理和IT自动化

访问proximile.llc了解更多关于我们为您的企业提供的安全本地AI解决方案。

许可证

此适配器与基础LLaDA模型采用相同的许可证发布。