🚀 Qwen2.5-Coder-1.5B-Instruct-Reasoning

Qwen2.5-Coder-1.5B-Instruct-Reasoning 模型在 nvidia/OpenCodeReasoning 数据集上进行了监督微调（SFT），以增强其推理能力。

🚀 快速开始

Hugging Face使用示例

from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

base_model_name = "Qwen/Qwen2.5-Coder-1.5B-Instruct"
adapter_repo = "bunyaminergen/Qwen2.5-Coder-1.5B-Instruct-Reasoning"

tokenizer = AutoTokenizer.from_pretrained(adapter_repo, trust_remote_code=True)

model = AutoModelForCausalLM.from_pretrained(
    base_model_name,
    device_map="auto",
    torch_dtype="auto",
)

model.resize_token_embeddings(len(tokenizer))

model = PeftModel.from_pretrained(model, adapter_repo)
model.eval()

messages = [
    {"role": "system", "content": "You are a helpful coding assistant."},
    {"role": "user", "content": "Please provide a Python script that checks whether a number is prime."}
]

prompt = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

outputs = model.generate(
    **inputs,
    max_new_tokens=2048
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

✨ 主要特性

通过在 nvidia/OpenCodeReasoning 数据集上进行监督微调，模型增强了推理能力。在处理代码相关任务时，能够展现出更强大的逻辑推理和问题解决能力。

💻 使用示例

基础用法

from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

base_model_name = "Qwen/Qwen2.5-Coder-1.5B-Instruct"
adapter_repo = "bunyaminergen/Qwen2.5-Coder-1.5B-Instruct-Reasoning"

tokenizer = AutoTokenizer.from_pretrained(adapter_repo, trust_remote_code=True)

model = AutoModelForCausalLM.from_pretrained(
    base_model_name,
    device_map="auto",
    torch_dtype="auto",
)

model.resize_token_embeddings(len(tokenizer))

model = PeftModel.from_pretrained(model, adapter_repo)
model.eval()

messages = [
    {"role": "system", "content": "You are a helpful coding assistant."},
    {"role": "user", "content": "Please provide a Python script that checks whether a number is prime."}
]

prompt = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

outputs = model.generate(
    **inputs,
    max_new_tokens=2048
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

高级用法

在实际应用中，你可以根据具体需求调整输入的消息内容和生成参数，以满足不同的任务要求。例如，修改 max_new_tokens 参数来控制生成文本的长度。

📚 详细文档

对比

• 请关注 推理模型 中的 <think> </think> 特殊标记。可以看到，推理模型 现在能够进行 “思考”。

基础模型

`System:` You are a helpful coding assistant.
`User:` Please provide a Python script that checks whether a number is prime.
`Assistant:`
```python
def check_prime(num):
    # Check if the number is less than 2
    if num < 2:
        return False
    # Check for factors from 2 to the square root of the number
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    # If no factors were found, the number is prime
    return True

# Example usage
number = 7
if check_prime(number):
    print(f"{number} is a prime number.")
else:
    print(f"{number} is not a prime number.")

在这个Python脚本中，check_prime 函数接受一个整数作为输入，如果该数是质数则返回 True，否则返回 False。函数首先检查该数是否小于2，因为小于2的数不是质数。然后，它从2开始迭代到该数的平方根（包含）。如果在这个范围内找到该数的任何因数，则函数立即返回 False，表示该数不是质数。如果在检查所有可能的除数后没有找到因数，则函数得出该数是质数并返回 True。

示例用法展示了如何使用 check_prime 函数检查数字7是否为质数。输出将指示7是否为质数。

推理模型

`System:` You are a helpful coding assistant.
`User:` Please provide a Python script that checks whether a number is prime.
`Assistant:`
`<think>`
Okay, I need to write a Python program that checks if a given number is prime. Hmm, what's a prime number? Oh right, a
prime number has exactly two distinct positive divisors: 1 and itself. So for a number to be prime, it must not have any
divisors other than those two.

First, let's think about the steps involved. The first thing is to determine if there are any divisors other than 1 and
the number itself. How do I check that?

Well, for a number n, starting from 2 up to sqrt(n), check if any of them divide n. If any do, then it's not prime. But
wait, maybe even before checking up to the square root, some numbers might have factors beyond that. For example, take

9. The square root is 3. So checking 2,3,4 would catch 9's factors. Wait, but 3 divides 9, so the loop from 2 to sqrt(
   n) (which is 3 in this case) will check 2 and 3. So yes, checking up to the square root is sufficient because any
   composite number has at least one factor less than or equal to its square root.

So the plan is:

1. Read an integer from input.
2. Check if the number is less than 2. If so, it's not prime.
3. Otherwise, check from 2 up to the square root of the number. For each i, if the number mod i is zero, return False.
4. If none of the numbers in this range divide the number, return True.

Wait, but what about 0 and 1? Well, according to the problem statement, the input could be 0 or 1, which are not primes.
So we should handle those cases separately.

Let me outline the code structure.

Read the input number as an integer. Let's call it num.

Handle edge cases first:

- If num < 2: print "No" (since primes are >=2)
  Else:
  Compute sqrt_num = int(math.sqrt(num))
  Then loop from 2 to sqrt_num inclusive. For each i, check if num % i ==0. If any such i exists, return False. Else,
  after checking all, return True.

But how to compute the square root accurately in Python? Using math.isqrt for integers, which returns the floor of the
square root. That's better than using ** operator since it avoids floating point inaccuracies.

Wait, but what if the number is a perfect square? Like 9. Then math.isqrt(9) is 3. So in that case, the loop would check
up to 3. But when i reaches 3, 9%3 is 0, so it would return False, which is correct.

So the code would look something like this:

import math

n = int(input())
if n < 2:
print("No")
else:
sqrt_n = math.isqrt(n)
is_prime = True
for i in range(2, sqrt_n +1):
if n % i == 0:
is_prime = False
break
print("Yes" if is_prime else "No")

Wait, but wait, what about numbers like 25. The square root is 5. So the loop runs from 2 to 5. When i=5, 25%5 is 0, so
returns false. Correct.

This logic seems solid. Let me test some examples.

Test case 1: input 7. The loop runs up to 2. 2 to 2. Check 2. 7%2 is 1, so returns true. Output Yes.

Test case 2: input 6. sqrt(6) is ~2.449. So sqrt_n is 2. Loop from 2 to 2. Check 2. 6%2 is 0. So returns false. Output
No.

Another test case: 8. sqrt(8) is ~2.828. So sqrt_n is 2. Check 2. 8%2 is 0. So output No.

What about a prime number like 13. sqrt(13) is ~3.605. So loop up to 3. Check 2 and 3. 13%2 is 1, 13%3 is 1. So returns
true. Correct.

Edge case: 1. Output No.

Another edge case: 2. Output Yes.

What about a very large number, say 999983 (a prime). The code should check up to sqrt(999983) which is around 999.9. So
the loop runs 2 to 999. It will check all possible factors. Since it's a prime, none will divide it. So returns Yes.

So the code seems to handle all cases correctly.

I think that's the solution. Now, writing the code accordingly.
`</think>`

```python
import math

n = int(input())
if n < 2:
    print("No")
else:
    sqrt_n = math.isqrt(n)
    is_prime = True
    for i in range(2, sqrt_n + 1):
        if n % i == 0:
            is_prime = False
            break
    print("Yes" if is_prime else "No")

数据集

• nvidia/OpenCodeReasoning

训练

基础参数

PEFT/LoRA参数

模型参数

数据集参数

分词器参数

速度、大小、时间

计算基础设施

🔧 技术细节

该模型基于 Qwen/Qwen2.5-Coder-1.5B-Instruct 基础模型，使用 QLoRA 方法进行微调。通过在 nvidia/OpenCodeReasoning 数据集上进行监督微调，模型学习到了更多的代码推理知识，从而增强了其推理能力。在训练过程中，采用了一系列的优化策略，如混合精度训练、梯度检查点等，以提高训练效率和模型性能。

📄 许可证

• LICENSE

🔗 相关链接

• Github
• 网站
• 领英

👥 团队

• Bunyamin Ergen

📞 联系我们

• 邮箱

📚 参考资料

• 该模型是在原始模型 Qwen/Qwen2.5-Coder-1.5B-Instruct 的基础上，使用监督微调（SFT）方法进行微调得到的。

📝 引用

@software{       Qwen2.5-Coder-1.5B-Instruct-Reasoning,
  author       = {Bunyamin Ergen},
  title        = {{Qwen2.5-Coder-1.5B-Instruct-Reasoning}},
  year         = {2025},
  month        = {04},
}