# mthreads-Qwen2.5-0.5B

**Repository Path**: yjkyjkyjk/mthreads-Qwen2.5-0.5B

## Basic Information

- **Project Name**: mthreads-Qwen2.5-0.5B
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 237
- **Created**: 2026-01-03
- **Last Updated**: 2026-01-12

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README


# 2025秋季国科大GPU架构与编程（赵地）大作业二

[TOC]

gitee链接：https://gitee.com/yjkyjkyjk/mthreads-Qwen2.5-0.5B

## 生成数据集

### 下载pdf

可以在sciencedirect网页下载分章节的pdf https://www.sciencedirect.com/book/monograph/9780128119860/programming-massively-parallel-processors

需要登录sep网站-文献下载-Elsevier-SD

### pdf to markdown

python脚本直接读取pdf，得到的文本格式不稳定，为了提高数据集的生成质量，可以先把pdf转换成markdown，这里我直接使用了在线网站进行转换
https://lightpdf.cn/pdf-to-markdown

### 生成问答对

使用python脚本读取markdown文本，分成小的文本块，调用deepseek api，批量生成问答对

```python

class QAGenerator:
    def __init__(self, config):
        self.config = config
        self.client = AsyncOpenAI(
            api_key=config.DEEPSEEK_API_KEY,
            base_url=config.DEEPSEEK_BASE_URL
        )
        self.encoder = tiktoken.get_encoding("cl100k_base")
    
    def _load_sample_format(self) -> Dict[str, Any]:
        """加载样例格式"""
        try:
            with open(self.config.SAMPLE_FILE, 'r', encoding='utf-8') as f:
                return json.load(f)
        except:
            # 默认格式
            return {
                "format": {
                    "instruction": "问题",
                    "input": "上下文(可选)",
                    "output": "答案",
                    "type": "问答对"
                },
                "examples": []
            }
    
    def _create_prompt(self, text_chunk: str, sample_format: Dict) -> str:
        """创建生成问答对的prompt"""
        
        prompt = f"""基于以下英文文本内容，生成高质量、多样化的中文问答对。

## 文本内容：
{text_chunk}

## 生成要求：
1. 生成 {self.config.MIN_QUESTIONS_PER_CHUNK}-{self.config.MAX_QUESTIONS_PER_CHUNK} 个问答对
2. 问题要尽可能覆盖文本全部的重要知识点，忽略非必要的细节
3. 问题类型应该多样，包括但不限于提问概念、原理、编写代码等
4. 答案必须基于提供的文本内容，准确、完整
5. 不要在问题和回答中提及“文本”、“章节”、“图”、“表”等词语
6. 由于格式转化问题，本文可能存在一些内容错误和丢失，请修正或者补全
7. 问题要清晰明确，不要含糊
8. 每个问答对自成一体，不需要依赖其他问答对

## 问答示例，供参考：

1.	问题：什么是数据并行性？
 答案：数据并行性是指将计算任务围绕数据进行重组，使多个独立的计算可并行执行以提升整体效率的特性。比如将彩色图像转灰度图时，每个像素的转换计算相互独立，可由不同线程同时完成，能充分利用海量数据的并行处理潜力。
2.	问题：CUDA C程序的整体执行流程是怎样的？
 答案：CUDA C程序执行起始于主机（CPU）的串行代码，当调用核函数（并行设备代码）时，会在设备（GPU）上生成大量线程组成的网格来执行核函数逻辑；所有核函数对应的线程网格执行完毕后，程序会回到主机端继续执行串行代码，部分场景下还可实现CPU与GPU执行的重叠以提升整体效率。
3.	问题：CUDA中的核函数是什么？
 答案：核函数是CUDA C中标记有__global__关键字的特殊函数，它规定了设备端并行执行的代码逻辑，所有线程都会执行相同的核函数代码，是实现异构并行计算中设备端并行任务的核心载体，只能由主机代码启动执行（支持动态并行的架构除外）。
4.	问题：CUDA核函数的函数声明关键字有哪些，各自的作用是什么？
 答案：CUDA核函数相关的声明关键字主要有三个，__global__标识的是可在主机端调用、在设备端执行的核函数，是实现大规模并行计算的核心函数；__device__标识的是仅能在设备端执行且只能被核函数或其他设备函数调用的函数；__host__标识的是仅在主机端执行且仅能被主机函数调用的函数，无特殊关键字的函数默认是__host__函数。
5.	问题：CUDA中cudaMalloc函数的作用和参数要求是什么？
 答案：cudaMalloc是CUDA提供的用于在设备全局内存中分配存储空间的API函数，它的第一个参数需传入指向设备内存指针的地址且要强制转换为void**类型，用于接收分配的设备内存地址；第二个参数是要分配的内存字节数，其设计逻辑与C语言malloc函数相近，便于C程序员快速上手设备内存管理。


## 输出格式（JSON数组）：
[
  {{
    "instruction": "问题内容",
    "input": "相关的上下文或背景（全部设为空）",
    "output": "详细的答案"
  }},
  ...
]

现在，基于上面的文本内容生成问答对："""
        
        return prompt
    
    async def generate_qa_for_chunk(self, text_chunk: Dict[str, Any], 
                                   retries: int = 3) -> Optional[List[Dict]]:
        """为单个文本块生成问答对"""
        
        sample_format = self._load_sample_format()
        prompt = self._create_prompt(text_chunk['text'], sample_format)
        
        for attempt in range(retries):
            try:
                response = await self.client.chat.completions.create(
                    model=self.config.DEEPSEEK_MODEL,
                    messages=[
                        {
                            "role": "system", 
                            "content": "你是一个专业的问答对生成助手。请基于提供的文本生成高质量的问答对，并以JSON数组格式返回。"
                        },
                        {
                            "role": "user",
                            "content": prompt
                        }
                    ],
                    temperature=self.config.TEMPERATURE,
                    max_tokens=self.config.MAX_TOKENS,
                    response_format={"type": "json_object"}
                )
                
                content = response.choices[0].message.content
                
                try:
                    # 尝试解析JSON
                    result = json.loads(content)
                    
                    # 处理不同的JSON结构
                    if isinstance(result, list):
                        qa_pairs = result
                    elif isinstance(result, dict):
                        if "qa_pairs" in result:
                            qa_pairs = result["qa_pairs"]
                        elif "questions" in result:
                            qa_pairs = result["questions"]
                        else:
                            # 尝试从字典中提取数组
                            qa_pairs = [result]
                    else:
                        qa_pairs = []
                    
                    # 验证和标准化格式
                    validated_pairs = []
                    for pair in qa_pairs:
                        if isinstance(pair, dict):
                            validated_pair = {
                                "instruction": pair.get("instruction", pair.get("question", "")),
                                "input": pair.get("input", text_chunk['text'][:200] + "..."),
                                "output": pair.get("output", pair.get("answer", ""))
                            }
                            # 确保必要字段不为空
                            if validated_pair["instruction"] and validated_pair["output"]:
                                validated_pairs.append(validated_pair)
                    
                    if validated_pairs:
                        return validated_pairs
                    
                except json.JSONDecodeError as e:
                    if attempt < retries - 1:
                        await asyncio.sleep(1)
                        continue
                    print(f"JSON解析失败: {e}")
                    return None
                    
            except Exception as e:
                if attempt < retries - 1:
                    await asyncio.sleep(2 ** attempt)  # 指数退避
                    continue
                print(f"API调用失败: {e}")
                return None
        
        return None
    
    async def generate_qa_batch(self, chunks: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """批量生成问答对"""
        
        all_qa_pairs = []
        
        # 使用信号量控制并发
        semaphore = asyncio.Semaphore(10)  # 限制并发数
        
        async def process_with_semaphore(chunk):
            async with semaphore:
                return await self.generate_qa_for_chunk(chunk)
        
        # 分批处理
        for i in range(0, len(chunks), self.config.BATCH_SIZE):
            batch = chunks[i:i + self.config.BATCH_SIZE]
            tasks = [process_with_semaphore(chunk) for chunk in batch]
            
            batch_results = await asyncio.gather(*tasks, return_exceptions=True)
            
            for result in batch_results:
                if isinstance(result, Exception):
                    print(f"批处理出错: {result}")
                    continue
                if result:
                    all_qa_pairs.extend(result)
            
            print(f"✓ 进度: {min(i + self.config.BATCH_SIZE, len(chunks))}/{len(chunks)} chunks")
        
        return all_qa_pairs
    
    def save_to_alpaca_format(self, qa_pairs: List[Dict[str, Any]]):
        """保存为Alpaca格式"""
        
        alpaca_data = []
        for pair in qa_pairs:
            alpaca_item = {
                "instruction": pair["instruction"],
                "input": pair.get("input", ""),
                "output": pair["output"]
            }
            alpaca_data.append(alpaca_item)
        
        with open(self.config.OUTPUT_FILE, 'w', encoding='utf-8') as f:
            json.dump(alpaca_data, f, ensure_ascii=False, indent=2)
        
        print(f"✓ 已保存 {len(alpaca_data)} 个问答对到 {self.config.OUTPUT_FILE}")
```


## 大模型微调训练

### 配置服务器环境

先在Qwen3/LLaMA-Factory-main(看说明文档)

> llamafactory-cli webui 

然后在/autodl-tmp/models/huggingface_cache/gradio/frpc上传文件frpc_linux_amd64_v0.3

添加执行权限
> chmod +x frpc_linux_amd64_v0.3

之后再回到Qwen3/LLaMA-Factory-main

> llamafactory-cli webui

点击链接进入UI界面

### 添加数据集

把数据集json文件放进data文件夹，修改data目录下的dataset_info.json，添加数据集描述

alpaca格式示例：

```json
[
    {
        "instruction": "什么是数据并行性？",
        "input": "",
        "output": "数据并行性是指将计算任务围绕数据进行重组，使多个独立的计算可并行执行以提升整体效率的特性。比如将彩色图像转灰度图时，每个像素的转换计算相互独立，可由不同线程同时完成，能充分利用海量数据的并行处理潜力。"
    },
    {
        "instruction": "CUDA C程序的整体执行流程是怎样的？",
        "input": "",
        "output": "CUDA C程序执行起始于主机（CPU）的串行代码，当调用核函数（并行设备代码）时，会在设备（GPU）上生成大量线程组成的网格来执行核函数逻辑；所有核函数对应的线程网格执行完毕后，程序会回到主机端继续执行串行代码，部分场景下还可实现CPU与GPU执行的重叠以提升整体效率。"
    }
]
```

数据集描述：

```json
    "sample": {
        "file_name": "sample.json",
        "columns": {
            "prompt": "instruction",
            "query": "input",
            "response": "output"
        }
    },
    "PMPP3": {
        "file_name": "PMPP3.json",
        "columns": {
            "prompt": "instruction",
            "query": "input",
            "response": "output"
        }
    },
```


### LLaMA-Factory使用方法


进入Qwen3/LLaMA-Factory-main目录，命令行输入：

> llamafactory-cli webui

点击链接打开webui，选择Qwen2.5-1.5B-Instruct

训练中出现报错：

    RuntimeError: Now torch_musa only allows explicit value of `scale` parameter, whose value is equal to `1/sqrt(query.size(-1))`

解决方案：

miniconda3/lib/python3.10/site-packages/transformers/integrations/sdpa_attention.py

第89行添加：

> musa_scale_factor = 1.0 / (query.size(-1) ** 0.5) # 添加

第96行修改：

> scale=musa_scale_factor

![](83bff9d695ccbe2593feff0c3d9adc4.jpg)

训练完毕以后，输入导出路径，点击导出

### 基础题训练方法

在LLaMA-Factory的webui中，选择Qwen2.5-0.5B模型，使用100道样例问答对作为数据集，学习率调为5e-4，batch_size调为8，训练30个epoch，其他参数默认，让loss过拟合到0.01以下，这样微调出来的模型提交以后准确率就可以到0.35以上

### 上传modelscope

参考文档：https://www.modelscope.cn/docs/models/upload

在导出模型文件以后直接使用下面的命令就可以创建一个新的modelscope仓库:

> modelscope upload owner/awesome-new-model /path/to/model_folder --token YOUR-MODELSCOPE-TOKEN

获取token：https://www.modelscope.cn/my/myaccesstoken

## 推理

### 修改下载脚本

download_model.py

```python
# download_model.py（仅用于下载，下载完成后可删除）
import os
from modelscope import snapshot_download

# 模型名称
model_name = "yjkyjkyjk/PPMP3-Qwen2.5-1.5B-Instruct"
local_model_path = "./local-model"

# 下载模型到指定目录
local_model_path = snapshot_download(
    model_name,
    local_dir=local_model_path
)

print("下载完成！")
```

### 优化推理速度

我尝试了使用vllm_musa进行推理，但是遇到了兼容性问题，在批量推理时，只有第一个问题的回答是正常的，其他回答会出现乱码，没有找到解决方法。最终还是使用transformers推理框架。

#### 1.批量处理

使用了批量处理的方式，在health_check端点返回“batch”，一次接收所有prompts，然后利用transformers的批量处理进行推理，最后一次返回所有结果。由于测试的问题数量较少，基础题共300个，加分题共358个，且模型占用的显存很小，所以可以把batch_size设为prompts的数量。

```python
OPTIMAL_BATCH_SIZE = 512  # 定义批量大小

def process_batch_prompts(prompts: List[str]) -> List[str]:
    """使用模型的批量处理功能"""
    formatted_prompts = [f"Q: {p}\nA:" for p in prompts]
    
    model_outputs = generator(
        formatted_prompts,
        **generator_config,
        batch_size=min(len(prompts), OPTIMAL_BATCH_SIZE)
    )
    
    results = []
    for i, output in enumerate(model_outputs):
        generated = output[0]["generated_text"].strip()
        results.append(generated)
    
    return results
```

#### 2.半精度

使用float16减少显存占用和加速计算

```python
model = AutoModelForCausalLM.from_pretrained(
    LOCAL_MODEL_PATH,
    torch_dtype=torch.float16,
    low_cpu_mem_usage=True,
    device_map="auto"
)
```

#### 3.计算图优化

启用KV缓存：在自回归生成中缓存键值对，避免重复计算

使用评估模式，关闭dropout等训练专用层

```python
model.config.use_cache = True  # 启用KV缓存
model.eval()  # 设置为评估模式
use_cache=True  # 生成时使用缓存
```

#### 4.预热

在开始推理之前，预热模型，提前触发JIT编译和CUDA/MUSA内核初始化，减少第一次推理的延迟

```python
# 预热模型
with torch.no_grad():
    warmup_input = tokenizer("Q: Warmup\nA:", return_tensors="pt").to(model.device)
    _ = model.generate(**warmup_input, max_new_tokens=10, do_sample=False)
```

####  5.参数优化

使用贪婪解码，比采样或beam search更快

开启提前停止，遇到EOS token立即停止生成

禁用不必要的采样策略以加速推理

```python
generator_config = {
    'do_sample': False,  # 不使用采样，使用贪婪解码
    'num_beams': 1,  # 不使用beam search
    'temperature': None,  # 禁用温度采样
    'top_p': None,  # 禁用核采样
    'early_stopping': True,  # 提前停止
}
```

### 完整推理代码

```python
import torch_musa
from fastapi import FastAPI
from pydantic import BaseModel
import os
os.environ["TRANSFORMERS_OFFLINE"] = "1"
from transformers import pipeline, set_seed
from transformers import AutoModelForCausalLM, AutoTokenizer
import socket
from typing import Union, List
import concurrent.futures
import time
import torch

def check_internet(host="8.8.8.8", port=53, timeout=3):
    try:
        socket.setdefaulttimeout(timeout)
        socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect((host, port))
        return True
    except Exception:
        return False

# 本地模型路径
LOCAL_MODEL_PATH = "./local-model"

# --- 网络连通性测试 ---
internet_ok = check_internet()
print("【Internet Connectivity Test】:",
      "CONNECTED" if internet_ok else "OFFLINE / BLOCKED")

# --- 模型加载（从本地加载，无需网络）---
print(f"从本地加载模型：{LOCAL_MODEL_PATH}")

# 优化环境变量
os.environ["TOKENIZERS_PARALLELISM"] = "false"

# 手动加载本地模型和tokenizer
tokenizer = AutoTokenizer.from_pretrained(LOCAL_MODEL_PATH)
model = AutoModelForCausalLM.from_pretrained(
    LOCAL_MODEL_PATH,
    torch_dtype=torch.float16,
    low_cpu_mem_usage=True,
    device_map="auto"
)

# 启用缓存以加速推理
model.config.use_cache = True

# 设置为评估模式
model.eval()

# 预热模型
print("预热模型...")
with torch.no_grad():
    warmup_input = tokenizer("Q: Warmup\nA:", return_tensors="pt").to(model.device)
    _ = model.generate(**warmup_input, max_new_tokens=10, do_sample=False)
    
# 同步设备
if hasattr(torch, 'musa') and torch.musa.is_available():
    torch.musa.synchronize()
elif torch.cuda.is_available():
    torch.cuda.synchronize()
    
print("模型预热完成")

# 优化pipeline配置
generator_config = {
    'max_new_tokens': 200,
    'num_return_sequences': 1,
    'do_sample': False,
    'temperature': None,
    'top_p': None,
    'repetition_penalty': 1.0,
    'pad_token_id': tokenizer.eos_token_id,
    'eos_token_id': tokenizer.eos_token_id,
    'num_beams': 1,
    'early_stopping': True,
    'use_cache': True,
}

# 初始化pipeline
generator = pipeline(
    'text-generation',
    model=model,
    tokenizer=tokenizer,
)
set_seed(42)

# --- API 定义 ---
app = FastAPI(
    title="Simple Inference Server",
    description="A simple API to run a small language model."
)

class PromptRequest(BaseModel):
    prompt: Union[str, List[str]]

class PredictResponse(BaseModel):
    response: Union[str, List[str]]

OPTIMAL_BATCH_SIZE = 512

def process_single_prompt(prompt_text: str) -> str:
    """处理单个prompt的辅助函数"""
    prompt = f"Q: {prompt_text}\nA:"
    
    model_output = generator(
        prompt,
        **generator_config
    )
    
    generated = model_output[0]["generated_text"].strip()
    
    # 提取纯答案
    answer_only = extract_answer_only(generated, prompt_text)
    return answer_only

def process_batch_prompts(prompts: List[str]) -> List[str]:
    """使用模型的批量处理功能"""
    formatted_prompts = [f"Q: {p}\nA:" for p in prompts]
    
    model_outputs = generator(
        formatted_prompts,
        **generator_config,
        batch_size=min(len(prompts), OPTIMAL_BATCH_SIZE)
    )
    
    results = []
    for i, output in enumerate(model_outputs):
        generated = output[0]["generated_text"].strip()
        results.append(generated)
    
    return results

# --- API 端点 ---
@app.post("/predict", response_model=PredictResponse)
def predict(request: PromptRequest):
    """
    接收一个或多个prompt，使用加载的模型进行推理，并返回结果。
    始终启用批量处理模式。
    """
    
    # 检查输入是字符串还是列表
    is_batch = isinstance(request.prompt, list)
    
    if not is_batch:
        # 单条处理
        result = process_single_prompt(request.prompt)
        return PredictResponse(response=result)
    else:
        # 批量处理
        prompts = request.prompt
        
        print(f"批量模式：处理 {len(prompts)} 个prompts")
        start_time = time.time()
        
        results = process_batch_prompts(prompts)
        
        elapsed_time = time.time() - start_time
        print(f"批量处理完成，耗时: {elapsed_time:.2f}秒，平均每个: {elapsed_time/len(prompts):.3f}秒")
        
        return PredictResponse(response=results)

@app.get("/")
def health_check():
    """
    健康检查端点，用于确认服务是否启动成功。
    """
    return {"status": "batch"}
```


## 常见问题与解决方案

1.模型没有加载完成，没有超过限制时间900s，可能是网络问题，重新提交即可

超过900s也可能是网络问题，一般4B及以下的模型都能在时限内加载完成，可以尝试重新提交

2.如何使用autodl模拟测评环境

在autodl上，在租用实例时选择基础镜像，使用激活conda base环境：

> conda activate base

检查软件包版本是否与评测机一致：

> pip list

克隆仓库，进入仓库目录

安装软件包：

> pip install --no-cache-dir -r requirements.txt

下载模型：

> python download_model.py

运行服务：

> uvicorn serve:app --host 0.0.0.0 --port 8000

使用curl测试

```
curl -X POST http://localhost:8000/predict \
  -H "Content-Type: application/json" \
  -d '{"prompt": "什么是数据并行性？"}'

curl -X POST http://localhost:8000/predict \
  -H "Content-Type: application/json" \
  -d '{"prompt": "CUDA C程序的整体执行流程是怎样的？"}'

curl -X POST http://localhost:8000/predict \
  -H "Content-Type: application/json" \
  -d '{"prompt": "CUDA中的核函数是什么？"}'

curl -X POST http://localhost:8000/predict \
  -H "Content-Type: application/json" \
  -d '{"prompt": "CUDA核函数的函数声明关键字有哪些，各自的作用是什么？"}'

curl -X POST http://localhost:8000/predict \
  -H "Content-Type: application/json" \
  -d '{"prompt": "CUDA中cudaMalloc函数的作用和参数要求是什么？"}'


curl -X POST http://localhost:8000/predict \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": [
      "什么是数据并行性？",
      "CUDA C程序的整体执行流程是怎样的？",
      "CUDA中的核函数是什么？",
      "CUDA核函数的函数声明关键字有哪些，各自的作用是什么？",
      "CUDA中cudaMalloc函数的作用和参数要求是什么？"
    ]
  }'


curl -X POST http://localhost:8000/predict \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": [
      "什么是数据并行性？",
      "CUDA C程序的整体执行流程是怎样的？",
      "CUDA中的核函数是什么？",
      "CUDA核函数的函数声明关键字有哪些，各自的作用是什么？",
      "CUDA中cudaMalloc函数的作用和参数要求是什么？",
      "CUDA中cudaMemcpy函数的功能和参数构成是什么？",
      "CUDA中的blockDim内置变量代表什么？",
      "CUDA中的threadIdx内置变量的作用是什么？",
      "CUDA中的blockIdx内置变量的含义是什么？",
      "CUDA核函数启动时的执行配置参数有什么作用？",
      "为什么CUDA核函数中常需要添加边界检查的条件判断？",
      "CUDA中的设备全局内存和主机内存有什么本质区别？",
      "CUDA核函数的执行网格是如何组织的？",
      "什么是CUDA中的SPMD并行编程模式？",
      "CUDA中cudaFree函数的作用是什么？",
      "CUDA中线程块的维度设置有什么限制？",
      "如何将CUDA线程映射到二维数据（如图像像素）？",
      "CUDA中的__syncthreads()函数有什么作用？",
      "使用__syncthreads()有哪些注意事项？",
      "什么是CUDA的透明可扩展性？",
      "CUDA中线程块的资源分配是如何进行的？",
      "如何查询CUDA设备的属性信息？",
      "CUDA设备属性中maxThreadsPerBlock的含义是什么？",
      "CUDA中的warp是什么？",
      "CUDA中warp的调度机制是怎样的？",
      "什么是CUDA的延迟容忍（隐藏）机制？",
      "CUDA中SM的核心组成部分有哪些？",
      "为什么CUDA需要为SM分配大量线程？",
      "CUDA中线程块的执行顺序是怎样的？",
      "在图像模糊核函数中，如何处理边界像素的计算？",
      "CUDA中gridDim内置变量的作用是什么？",
      "CUDA中线程块的尺寸选择需要考虑哪些因素？",
      "什么是CUDA的零开销线程调度？",
      "CUDA中多维度线程块和网格的优势是什么？",
      "CUDA中线程同步为什么仅能在块内实现？",
      "为什么内存访问效率对CUDA程序性能至关重要？",
      "什么是计算-全局内存访问比？",
      "CUDA中的寄存器内存有什么特点？",
      "CUDA中的共享内存有什么特性？",
      "CUDA中的常量内存有什么作用？",
      "CUDA中的全局内存有什么优缺点？"
    ]
  }'
```

3. MUSA设备上的torch.cat操作在dim=2（或dim=-2）时有兼容性问题，需要禁用KV cache（use_cache=False）

但是禁用KV cache以后速度会很慢，可以考虑尝试其他Transformer版本

版本太低会出现tokenizer报错，版本太高会出现cat报错，经过尝试4.45版本正好合适

4. MUSA设备要求显式设置scale参数，并且它的值必须是1/sqrt(query.size(-1))。这是MUSA设备的一个特殊要求。可以使用其他注意力实现方式。

```python
if hasattr(model.config, '_attn_implementation'):
    model.config._attn_implementation = "eager"
elif hasattr(model.config, 'attention_type'):
    model.config.attention_type = "eager"
```
---

更大规模的测试：
```
curl -X POST http://localhost:8000/predict \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": [
      "什么是数据并行性？",
      "CUDA C程序的整体执行流程是怎样的？",
      "CUDA中的核函数是什么？",
      "CUDA核函数的函数声明关键字有哪些，各自的作用是什么？",
      "CUDA中cudaMalloc函数的作用和参数要求是什么？",
      "CUDA中cudaMemcpy函数的功能和参数构成是什么？",
      "CUDA中的blockDim内置变量代表什么？",
      "CUDA中的threadIdx内置变量的作用是什么？",
      "CUDA中的blockIdx内置变量的含义是什么？",
      "CUDA核函数启动时的执行配置参数有什么作用？",
      "为什么CUDA核函数中常需要添加边界检查的条件判断？",
      "CUDA中的设备全局内存和主机内存有什么本质区别？",
      "CUDA核函数的执行网格是如何组织的？",
      "什么是CUDA中的SPMD并行编程模式？",
      "CUDA中cudaFree函数的作用是什么？",
      "CUDA中线程块的维度设置有什么限制？",
      "如何将CUDA线程映射到二维数据（如图像像素）？",
      "CUDA中的__syncthreads()函数有什么作用？",
      "使用__syncthreads()有哪些注意事项？",
      "什么是CUDA的透明可扩展性？",
      "CUDA中线程块的资源分配是如何进行的？",
      "如何查询CUDA设备的属性信息？",
      "CUDA设备属性中maxThreadsPerBlock的含义是什么？",
      "CUDA中的warp是什么？",
      "CUDA中warp的调度机制是怎样的？",
      "什么是CUDA的延迟容忍（隐藏）机制？",
      "CUDA中SM的核心组成部分有哪些？",
      "为什么CUDA需要为SM分配大量线程？",
      "CUDA中线程块的执行顺序是怎样的？",
      "在图像模糊核函数中，如何处理边界像素的计算？",
      "CUDA中gridDim内置变量的作用是什么？",
      "CUDA中线程块的尺寸选择需要考虑哪些因素？",
      "什么是CUDA的零开销线程调度？",
      "CUDA中多维度线程块和网格的优势是什么？",
      "CUDA中线程同步为什么仅能在块内实现？",
      "为什么内存访问效率对CUDA程序性能至关重要？",
      "什么是计算-全局内存访问比？",
      "CUDA中的寄存器内存有什么特点？",
      "CUDA中的共享内存有什么特性？",
      "CUDA中的常量内存有什么作用？",
      "CUDA中的全局内存有什么优缺点？",
      "什么是数据局部性？",
      "什么是CUDA中的分块（tiling）技术？",
      "分块技术能提升CUDA程序性能的核心原因是什么？",
      "矩阵乘法中使用分块技术的优势是什么？",
      "CUDA核函数中自动数组变量会被分配到哪里？",
      "CUDA中共享内存的作用域和生命周期是怎样的？",
      "CUDA中常量内存的作用域和生命周期是怎样的？",
      "为什么CUDA程序中要谨慎使用寄存器？",
      "分块矩阵乘法中为什么需要添加边界检查？",
      "CUDA中全局内存的访问延迟和带宽与片上内存有多大差距？",
      "什么是CUDA中的“边角转换（corner turning）”技术？",
      "CUDA中共享内存的容量限制会带来什么影响？",
      "CUDA中内存资源如何限制并行性？",
      "如何动态调整CUDA核函数的共享内存用量？",
      "什么是CUDA中的全局内存合并访问？",
      "在CUDA的行优先存储矩阵中，如何实现全局内存的合并访问？",
      "什么是CUDA中的内存通道和内存银行？",
      "内存通道和银行如何提升CUDA的内存访问带宽？",
      "为什么CUDA程序需要足够多的并行线程来充分利用内存带宽？",
      "什么是CUDA中的控制流发散？",
      "控制流发散对CUDA程序性能有什么影响？",
      "CUDA中如何减少控制流发散的影响？",
      "CUDA中动态资源分配的含义是什么？",
      "CUDA中寄存器资源的分配会如何影响并行性？",
      "什么是CUDA中的“性能悬崖”？",
      "CUDA中共享内存的使用会如何影响并行性？",
      "什么是CUDA中的线程粒度？",
      "调整CUDA线程粒度的优势是什么？",
      "矩阵乘法中提升线程粒度的具体方式是什么？",
      "CUDA中warp内线程的执行特性是什么？",
      "为什么CUDA中要尽量避免warp内的控制流发散？",
      "CUDA中归约算法为什么会出现控制流发散？",
      "如何优化归约算法中的控制流发散？",
      "CUDA中的Occupancy（占用率）指什么？",
      "影响CUDA Occupancy的因素有哪些？",
      "CUDA中如何计算核函数的Occupancy？",
      "什么是CUDA中的内存银行冲突？",
      "如何避免CUDA中的共享内存银行冲突？",
      "CUDA中全局内存的对齐访问有什么要求？",
      "IEEE 754浮点数格式由哪几部分组成？",
      "什么是浮点数的规格化表示？",
      "什么是浮点数的偏移（excess）编码？",
      "什么是浮点数的非规格化（denormal）数？",
      "浮点数的精度和什么因素相关？",
      "什么是浮点数的ULP？",
      "什么是浮点数运算的准确度？",
      "浮点数运算中的舍入误差是如何产生的？",
      "为什么并行归约的顺序会影响浮点数的计算结果？",
      "如何提升并行归约的浮点数计算精度？",
      "什么是NaN和无穷大？",
      "什么是信号NaN（SNaN）和安静NaN（QNaN）？",
      "什么是数值算法的稳定性？",
      "高斯消元法为什么会出现数值不稳定性？",
      "什么是高斯消元法的选主元（pivoting）技术？",
      "浮点数的表示范围由什么因素决定？",
      "什么是浮点数的下溢和上溢？",
      "为什么并行算法的数值结果可能与串行算法不同？",
      "单精度和双精度浮点数的主要区别是什么？",
      "什么是数值计算中的大数吞小数现象？",
      "CUDA中矩阵乘法算子如何利用共享内存减少全局内存访问？",
      "GPU架构中SM的资源分配如何限制矩阵乘法算子的并行度？",
      "CUDA卷积算子中，如何通过线程索引映射实现1D输入的元素访问？",
      "GPU架构的warp divergence为何会影响卷积算子的边界处理性能？",
      "CUDA中SpMV算子基于CSR格式时，线程如何映射到矩阵非零元素？",
      "GPU架构的全局内存合并访问对SpMV算子性能有何影响？",
      "CUDA卷积神经网络卷积层算子中，如何使用常量内存存储卷积核？",
      "GPU架构的共享内存bank冲突如何影响tiled矩阵乘法性能？",
      "CUDA中1D卷积算子如何处理边界的“幽灵细胞”？",
      "GPU架构的L2缓存对稀疏矩阵向量乘法（SpMV）有何优化作用？",
      "CUDA矩阵乘法算子中，如何通过线程块维度设置提升并行效率？",
      "CUDA卷积算子中，线程块的TILE_SIZE选择需考虑哪些GPU架构限制？",
      "GPU架构的SIMD硬件如何提升ConvNets卷积层的计算吞吐量？",
      "CUDA中SpMV算子如何通过填充优化（Padding）提升内存访问效率？",
      "GPU架构的内存带宽瓶颈为何对矩阵乘法算子影响显著？",
      "CUDA卷积算子中，如何使用自动变量（寄存器）提升计算速度？",
      "GPU架构的SM多线程调度如何隐藏矩阵乘法算子的内存延迟？",
      "CUDA中2D卷积算子如何将2D输入线性化以适配全局内存存储？",
      "GPU架构的常量内存缓存对卷积核访问有何优化？",
      "CUDA中SpMV算子的线程块大小选择需匹配哪些GPU架构参数？",
      "CUDA矩阵乘法算子中，如何通过边界检查处理非TILE_WIDTH倍数的矩阵？",
      "GPU架构的共享内存带宽比全局内存高多少，对卷积算子有何意义？",
      "CUDA中ConvNets的反向传播算子，如何复用前向传播的中间数据？",
      "GPU架构的warp大小（32线程）如何影响卷积算子的线程块设计？",
      "CUDA中SpMV算子的csrVal数组，如何确保线程访问的合并性？",
      "CUDA矩阵乘法算子中，__syncthreads()的作用是什么？",
      "GPU架构的多通道内存（如GDDR6）如何提升矩阵乘法算子的带宽？",
      "CUDA中1D卷积算子的掩码（Mask）存储在常量内存的优势是什么？",
      "GPU架构的SM核心数如何影响ConvNets卷积层的计算速度？",
      "CUDA中SpMV算子如何处理行数远大于线程块数的稀疏矩阵？",
      "CUDA矩阵乘法算子中，TILE_WIDTH选择为16或32的依据是什么？",
      "GPU架构的内存对齐要求如何影响卷积算子的输入数据存储？",
      "CUDA中ConvNets的卷积层算子，如何处理多通道输入（如RGB图像）？",
      "GPU架构的L1缓存对矩阵乘法算子的tiling优化有何补充？",
      "CUDA中SpMV算子的csrColInd数组，为何需要与csrVal数组一一对应？",
      "CUDA卷积算子中，如何通过循环展开提升指令执行效率？",
      "GPU架构的功耗限制如何影响卷积算子的性能调优？",
      "CUDA中矩阵乘法算子的Pvalue累加变量为何要声明为volatile？",
      "GPU架构的异步执行如何提升SpMV算子的整体吞吐量？",
      "CUDA中1D卷积算子的输出数组P，如何分配全局内存以避免内存碎片？",
      "GPU架构的共享内存bank冲突如何在SpMV算子中避免？",
      "CUDA中ConvNets的反向传播算子，如何计算卷积核的梯度？",
      "GPU架构的计算能力（如Compute Capability 8.6）对矩阵乘法算子有何影响？",
      "CUDA中SpMV算子如何处理空行（无非零元素的矩阵行）？",
      "CUDA卷积算子中，cudaMemcpyToSymbol的作用是什么？",
      "GPU架构的内存控制器数量如何影响SpMV算子的带宽？",
      "CUDA中矩阵乘法算子的线程块维度（如dim3(16,16)）为何选择二维？",
      "GPU架构的warp调度器如何选择就绪warp执行？",
      "CUDA中2D卷积算子的halo细胞加载，如何避免线程冗余计算？",
      "GPU架构的常量内存容量限制（64KB）如何影响ConvNets的大尺寸卷积核？",
      "CUDA中SpMV算子的输出向量初始化为何要使用cudaMemset？",
      "CUDA矩阵乘法算子中，如何通过blockDim和gridDim计算总线程数？",
      "GPU架构的L2缓存一致性对多SM执行SpMV算子有何意义？",
      "CUDA中卷积算子的__shared__变量声明为何要指定大小？",
      "GPU架构的张量核心（Tensor Cores）如何提升ConvNets卷积层性能？",
      "CUDA中SpMV算子的csrRowPtr数组为何要比矩阵行数多1？",
      "CUDA矩阵乘法算子中，如何处理浮点数溢出？",
      "GPU架构的内存带宽与计算吞吐量的比例（如1TB/s带宽、10TFLOPS计算）如何影响卷积算子？",
      "CUDA中ConvNets的卷积层算子，如何实现零填充（Zero Padding）？",
      "GPU架构的SM调度器如何分配线程块到SM？",
      "CUDA中SpMV算子如何通过线程私有化提升性能？",
      "CUDA卷积算子中，cudaGetDeviceProperties的作用是什么？",
      "GPU架构的多进程并发对SpMV算子有何影响？",
      "CUDA中矩阵乘法算子的Nds[ty][tx] = N[(ph*TILE_WIDTH + ty)*Width + Col]索引计算的含义是什么？",
      "GPU架构的L1缓存写回策略对卷积算子有何影响？",
      "CUDA中SpMV算子的__device__函数作用是什么？",
      "CUDA中ConvNets的卷积层算子，如何通过im2col转换提升性能？",
      "结合算法与CUDA编程，tiled矩阵乘法算子如何通过数据复用提升计算/内存访问比？",
      "算法层面如何优化SpMV算子的负载均衡，CUDA编程如何实现该优化？",
      "结合算法与CUDA，2D卷积算子如何通过分块大小选择平衡共享内存占用与并行度？",
      "ConvNets的卷积层算法如何转换为矩阵乘法，CUDA编程如何高效实现该转换？",
      "算法层面如何处理稀疏矩阵的转置以优化SpMV算子，CUDA编程如何实现转置？",
      "结合算法与CUDA，矩阵乘法算子如何通过循环展开提升指令吞吐量？",
      "卷积算子的算法如何通过“halo细胞复用”减少数据传输，CUDA编程如何实现？",
      "SpMV算子的算法如何通过“行合并”优化，CUDA编程如何实现该优化？",
      "结合算法与CUDA，ConvNets的反向传播算子如何优化梯度计算的内存访问？",
      "矩阵乘法算子的算法如何处理非正方形矩阵，CUDA编程如何调整线程映射？",
      "卷积算子的算法如何通过“多尺度分块”优化，CUDA编程如何实现？",
      "SpMV算子的算法如何通过“原子操作优化”处理输出向量的累加，CUDA编程如何实现？",
      "结合算法与CUDA，ConvNets的卷积层算子如何优化多通道输入的计算？",
      "矩阵乘法算子的算法如何通过“预取”优化内存访问，CUDA编程如何实现？",
      "卷积算子的算法如何处理“空洞卷积”（Dilated Convolution），CUDA编程如何调整索引计算？",
      "SpMV算子的算法如何通过“压缩存储格式转换”（如CSR转ELL）优化，CUDA编程如何实现转换？",
      "结合算法与CUDA，矩阵乘法算子如何通过“精度调整”平衡性能与准确性？",
      "如何用Triton实现ConvNets的3×3卷积层，并通过自动分块优化提升性能？",
      "如何用TileLang优化SpMV算子的CSR格式访问，提升非合并内存访问效率？",
      "Triton实现的矩阵乘法算子如何与CUDA的tiled实现对比，优势在哪里？",
      "如何用TileLang实现2D卷积的tiled优化，自动处理halo细胞加载？",
      "Triton实现的ConvNets反向传播算子，如何利用自动微分和内存复用提升性能？",
      "如何用TileLang优化稀疏矩阵转置后的SpMV算子，利用转置后的连续访问模式？",
      "Triton与CUDA的SpMV算子在处理大规模稀疏矩阵时，性能差异的主要原因是什么？",
      "如何用TileLang实现ConvNets的深度卷积（Depthwise Convolution），优化组内内存局部性？"
    ]
  }'
```