零基础玩转IQuest-Coder：40B代码大模型实战教程

你是否曾幻想过拥有一个能帮你写代码、查Bug、优化算法的“AI编程搭档”？现在，它来了！

IQuest-Coder-V1-40B-Instruct是一款面向软件工程与竞技编程的新一代代码大语言模型（LLM），在多个权威编码基准测试中表现卓越。本文将带你从零开始，手把手完成该模型的本地部署与调用，即使你是AI或深度学习新手，也能轻松上手。

我们将使用vLLM作为推理引擎，在多GPU环境下高效运行这个40B参数量的大模型，并解决部署过程中可能遇到的关键报错问题。

1. 学习目标与前置知识

✅ 你能学到什么？

• 如何搭建支持大型代码模型的本地推理环境
• 使用vLLM部署 HuggingFace 格式的 LLM 模型
• 解决自定义架构模型不被 vLLM 支持的问题（Patch 实操）
• 下载并运行 IQuest-Coder-V1-40B-Instruct 指令模型
• 通过 API 调用你的本地 AI 编程助手

🧱 前置要求

💡提示：如果你没有本地高性能服务器，可考虑云平台租用实例（如阿里云、AutoDL等）进行实验。

2. 环境准备：构建vLLM推理环境

我们首先创建一个独立的虚拟环境来安装所有依赖项，避免与其他项目冲突。

2.1 创建Python虚拟环境

# 创建名为 vllm_env 的虚拟环境 python3 -m venv vllm_env # 激活环境 source vllm_env/bin/activate # 升级pip pip install --upgrade pip

2.2 安装核心依赖库

# 安装最新版vLLM（推荐0.13.0以上） pip install vllm # 安装DLPack扩展（部分CUDA操作需要） pip install torch-c-dlpack-ext # 安装魔搭（ModelScope）客户端用于下载模型 pip install modelscope

✅ 此时你的基础推理环境已准备就绪。

3. 模型下载：获取IQuest-Coder-V1-40B-Instruct

该模型托管于ModelScope（魔搭）社区，我们使用其命令行工具下载。

3.1 执行下载命令

modelscope download \ --model IQuestLab/IQuest-Coder-V1-40B-Loop-Instruct \ --local_dir ./IQuest-Coder-V1-40B-Loop-Instruct

📌说明： ---model：指定模型ID ---local_dir：本地保存路径

⚠️注意：由于模型体积巨大（FP16约150GB），下载时间较长，请确保网络稳定和磁盘充足。

4. 关键修复：为vLLM打补丁以支持IQuest架构

直接运行模型会报错：

Model architectures ['IQuestLoopCoderForCausalLM'] are not supported

这是因为 vLLM 尚未原生支持 IQuest-Coder 的自定义模型结构。我们需要手动添加支持。

4.1 修改模型注册表

找到 vLLM 安装目录下的模型注册文件：

vim vllm_env/lib/python3.12/site-packages/vllm/model_executor/models/registry.py

在"Zamba2ForCausalLM": ("zamba2", "Zamba2ForCausalLM")后新增两行：

"IQuestLoopCoderForCausalLM": ("iquest_loopcoder", "IQuestLoopCoderForCausalLM"), "IQuestCoderForCausalLM": ("llama", "LlamaForCausalLM"),

这一步告诉 vLLM：当遇到IQuestLoopCoderForCausalLM类型时，去加载名为iquest_loopcoder.py的模块。

4.2 创建自定义模型实现文件

新建文件：

touch vllm_env/lib/python3.12/site-packages/vllm/model_executor/models/iquest_loopcoder.py

将以下完整代码粘贴进去（即官方 PR 提供的实现）：

# SPDX-License-Identifier: Apache-2.0 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Inference-only LoopCoder model compatible with HuggingFace weights.""" from __future__ import annotations from collections.abc import Iterable from dataclasses import replace from typing import Any import torch from torch import nn from transformers import PretrainedConfig from vllm.attention.backends.abstract import AttentionType from vllm.attention.layer import Attention from vllm.compilation.decorators import support_torch_compile from vllm.config import CacheConfig, VllmConfig from vllm.distributed import get_tensor_model_parallel_world_size from vllm.model_executor.layers.activation import SiluAndMul from vllm.model_executor.layers.layernorm import LayerNorm from vllm.model_executor.layers.linear import ( ColumnParallelLinear, MergedColumnParallelLinear, QKVParallelLinear, RowParallelLinear, ) from vllm.model_executor.layers.logits_processor import LogitsProcessor from vllm.model_executor.layers.quantization import QuantizationConfig from vllm.model_executor.layers.rotary_embedding import get_rope from vllm.model_executor.layers.vocab_parallel_embedding import ( ParallelLMHead, VocabParallelEmbedding, ) from vllm.model_executor.model_loader.weight_utils import ( default_weight_loader, maybe_remap_kv_scale_name, ) from vllm.sequence import IntermediateTensors from .utils import ( AutoWeightsLoader, extract_layer_index, make_empty_intermediate_tensors_factory, make_layers, maybe_prefix, ) class LoopCoderRMSNorm(nn.Module): """ LoopCoderRMSNorm is equivalent to T5LayerNorm. """ def __init__(self, hidden_size: int, eps: float = 1e-6): super().__init__() self.weight = nn.Parameter(torch.ones(hidden_size)) self.variance_epsilon = eps def forward(self, hidden_states: torch.Tensor): input_dtype = hidden_states.dtype hidden_states = hidden_states.to(torch.float32) variance = hidden_states.pow(2).mean(-1, keepdim=True) hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon) return self.weight * hidden_states.to(input_dtype) class LoopCoderMLP(nn.Module): def __init__( self, hidden_size: int, intermediate_size: int, hidden_act: str, quant_config: QuantizationConfig | None = None, prefix: str = "", ) -> None: super().__init__() self.gate_up_proj = MergedColumnParallelLinear( hidden_size, [intermediate_size] * 2, bias=False, quant_config=quant_config, prefix=f"{prefix}.gate_up_proj", ) self.down_proj = RowParallelLinear( intermediate_size, hidden_size, bias=False, quant_config=quant_config, prefix=f"{prefix}.down_proj", ) if hidden_act != "silu": raise ValueError( f"Unsupported activation: {hidden_act}. Only silu is supported for now." ) self.act_fn = SiluAndMul() def forward(self, x): gate_up, _ = self.gate_up_proj(x) x = self.act_fn(gate_up) x, _ = self.down_proj(x) return x class LoopCoderAttention(nn.Module): def __init__( self, config: PretrainedConfig, hidden_size: int, num_heads: int, num_kv_heads: int, max_position: int = 4096 * 32, cache_config: CacheConfig | None = None, quant_config: QuantizationConfig | None = None, prefix: str = "", attn_type: str = AttentionType.DECODER, dual_chunk_attention_config: dict[str, Any] | None = None, layer_idx: int = 0 ) -> None: super().__init__() self.layer_idx = layer_idx self.hidden_size = hidden_size tp_size = get_tensor_model_parallel_world_size() self.total_num_heads = num_heads assert self.total_num_heads % tp_size == 0 self.num_heads = self.total_num_heads // tp_size self.total_num_kv_heads = num_kv_heads if self.total_num_kv_heads >= tp_size: # Number of KV heads is greater than TP size, so we partition # the KV heads across multiple tensor parallel GPUs. assert self.total_num_kv_heads % tp_size == 0 else: # Number of KV heads is less than TP size, so we replicate # the KV heads across multiple tensor parallel GPUs. assert tp_size % self.total_num_kv_heads == 0 self.num_kv_heads = max(1, self.total_num_kv_heads // tp_size) self.head_dim = hidden_size // self.total_num_heads self.q_size = self.num_heads * self.head_dim self.kv_size = self.num_kv_heads * self.head_dim self.scaling = self.head_dim**-0.5 self.dual_chunk_attention_config = dual_chunk_attention_config # Get loop_num from config, default to 2 if not specified self.loop_num = getattr(config, "loop_num", 2) self.loop_window_size = getattr(config, "loop_window_size", 64) # Use total number of hidden layers instead of hardcoded 24 total_layers = config.num_hidden_layers self.qkv_proj = QKVParallelLinear( hidden_size, self.head_dim, self.total_num_heads, self.total_num_kv_heads, bias=False, quant_config=quant_config, prefix=f"{prefix}.qkv_proj", ) self.o_proj = RowParallelLinear( self.total_num_heads * self.head_dim, hidden_size, bias=False, quant_config=quant_config, prefix=f"{prefix}.o_proj", ) self.rotary_emb = get_rope( self.head_dim, max_position=max_position, rope_parameters=config.rope_parameters, dual_chunk_attention_config=dual_chunk_attention_config, ) self.attn = nn.ModuleList() base_cache_config = cache_config for loop_idx in range(self.loop_num): base_layer_idx = extract_layer_index(prefix) unique_layer_idx = loop_idx * total_layers + base_layer_idx unique_prefix = prefix.replace( f"layers.{base_layer_idx}", f"layers.{unique_layer_idx}" ) if loop_idx == 0: loop_cache_config = cache_config else: if base_cache_config is not None: loop_cache_config = replace( base_cache_config, sliding_window=self.loop_window_size, ) else: loop_cache_config = CacheConfig( sliding_window=self.loop_window_size, cache_dtype="auto", ) self.attn.append( Attention( self.num_heads, self.head_dim, self.scaling, num_kv_heads=self.num_kv_heads, cache_config=loop_cache_config, quant_config=quant_config, attn_type=attn_type, prefix=f"{unique_prefix}.attn", **{ "layer_idx": unique_layer_idx, "dual_chunk_attention_config": dual_chunk_attention_config, } if dual_chunk_attention_config and loop_idx == 0 else {}, ) ) def forward( self, positions: torch.Tensor, hidden_states: torch.Tensor, loop_idx: int, gate_proj: LoopGateProjection | None = None, ) -> torch.Tensor: if loop_idx == 0: attn = self.attn[0] qkv, _ = self.qkv_proj(hidden_states) q, k, v = qkv.split([self.q_size, self.kv_size, self.kv_size], dim=-1) q, k = self.rotary_emb(positions, q, k) attn_output = attn(q, k, v) output, _ = self.o_proj(attn_output) return output else: global_attn = self.attn[0] local_attn = self.attn[loop_idx] qkv, _ = self.qkv_proj(hidden_states) q, k, v = qkv.split([self.q_size, self.kv_size, self.kv_size], dim=-1) q, k = self.rotary_emb(positions, q, k) num_tokens, _ = q.shape num_heads = self.num_heads head_dim = self.head_dim q_reshaped = q.view(num_tokens, num_heads, head_dim).transpose(0, 1) global_attn_output = global_attn(q, None, None) local_attn_output = local_attn(q, k, v) assert gate_proj is not None, "gate_proj must be provided for loop_idx > 0" gate = gate_proj(q_reshaped) output = global_attn_output * gate + local_attn_output * (1 - gate) output, _ = self.o_proj(output) return output class LoopCoderDecoderLayer(nn.Module): def __init__( self, config: PretrainedConfig, cache_config: CacheConfig | None = None, quant_config: QuantizationConfig | None = None, prefix: str = "", layer_idx: int = 0 ) -> None: super().__init__() self.hidden_size = config.hidden_size dual_chunk_attention_config = getattr( config, "dual_chunk_attention_config", None ) self.layer_idx = layer_idx if getattr(config, "is_causal", True): attn_type = AttentionType.DECODER else: attn_type = AttentionType.ENCODER_ONLY self.self_attn = LoopCoderAttention( config=config, hidden_size=self.hidden_size, num_heads=config.num_attention_heads, max_position=config.max_position_embeddings, num_kv_heads=config.num_key_value_heads, cache_config=cache_config, quant_config=quant_config, prefix=f"{prefix}.self_attn", attn_type=attn_type, dual_chunk_attention_config=dual_chunk_attention_config, layer_idx=self.layer_idx, ) self.mlp = LoopCoderMLP( hidden_size=self.hidden_size, intermediate_size=config.intermediate_size, hidden_act=config.hidden_act, quant_config=quant_config, prefix=f"{prefix}.mlp", ) self.input_layernorm = LoopCoderRMSNorm(config.hidden_size, eps=config.rms_norm_eps) self.post_attention_layernorm = LoopCoderRMSNorm(config.hidden_size, eps=config.rms_norm_eps) def forward( self, positions: torch.Tensor, hidden_states: torch.Tensor, loop_idx: int, gate_proj: LoopGateProjection | None = None, ) -> tuple[torch.Tensor, torch.Tensor]: residual = hidden_states hidden_states = self.input_layernorm(hidden_states) hidden_states = self.self_attn( positions=positions, hidden_states=hidden_states, loop_idx=loop_idx, gate_proj=gate_proj, ) hidden_states = hidden_states + residual residual = hidden_states hidden_states = self.post_attention_layernorm(hidden_states) hidden_states = self.mlp(hidden_states) hidden_states = hidden_states + residual return hidden_states class LoopGateProjection(nn.Module): """Gate projection for mixed attention in Loop 2+. Computes: g = sigmoid(linear(Q)) for each head independently. This gate determines how much to use Loop1's KV (global) vs current loop's KV (local). Supports tensor parallelism: each GPU handles a subset of heads. The weight matrix has shape [num_heads, head_dim] and is split along the head dimension. """ def __init__( self, total_num_heads: int, head_dim: int, quant_config: QuantizationConfig | None = None, prefix: str = "", ): super().__init__() self.total_num_heads = total_num_heads self.head_dim = head_dim tp_size = get_tensor_model_parallel_world_size() assert self.total_num_heads % tp_size == 0 self.num_heads = self.total_num_heads // tp_size self.gate_proj = ColumnParallelLinear( head_dim, self.total_num_heads, bias=True, gather_output=False, quant_config=quant_config, prefix=prefix, ) def forward(self, query: torch.Tensor) -> torch.Tensor: """Compute gate values from query tensor. Args: query: [num_heads, num_tokens, head_dim] (vLLM flattened format) where num_heads is the number of heads on this TP rank and num_tokens = batch * seq_len Returns: gate: [num_tokens, num_heads * head_dim] (flattened format matching q shape) """ num_heads, num_tokens, head_dim = query.shape assert num_heads == self.num_heads, f"Expected {self.num_heads} heads, got {num_heads}" query_flat = query.reshape(-1, head_dim) gate_logits_flat, _ = self.gate_proj(query_flat) gate_logits = gate_logits_flat.reshape(num_heads, num_tokens, self.num_heads) # [num_heads, num_tokens, num_heads] # Extract diagonal: each head h's query should use output column h # gate_logits[h, :, h] gives the output for head h at each token gate_logits = torch.diagonal(gate_logits, dim1=0, dim2=2) # [num_tokens, num_heads] gate_logits = gate_logits.transpose(0, 1) # [num_heads, num_tokens] gate_logits = gate_logits.unsqueeze(-1) # [num_heads, num_tokens, 1] # Apply sigmoid gate = torch.sigmoid(gate_logits) # [num_heads, num_tokens, 1] # Expand and reshape to match q shape: [num_tokens, num_heads * head_dim] gate = gate.transpose(0, 1) # [num_tokens, num_heads, 1] gate = gate.expand(-1, -1, head_dim) # [num_tokens, num_heads, head_dim] gate = gate.reshape(num_tokens, num_heads * head_dim) # [num_tokens, num_heads * head_dim] return gate @support_torch_compile( dynamic_arg_dims={ "input_ids": 0, "positions": -1, "intermediate_tensors": 0, "inputs_embeds": 0, } ) class IQuestLoopCoderModel(nn.Module): def __init__( self, *, vllm_config: VllmConfig, prefix: str = "", decoder_layer_type: type[nn.Module] = LoopCoderDecoderLayer, ): super().__init__() config = vllm_config.model_config.hf_config cache_config = vllm_config.cache_config quant_config = vllm_config.quant_config # TODO (@robertgshaw2): see if this can be moved out if cache_config.sliding_window is not None and hasattr( config, "max_window_layers" ): assert config.max_window_layers == config.num_hidden_layers, ( "Sliding window for some but all layers is not supported. " "This model uses sliding window but `max_window_layers` = {} " "is less than `num_hidden_layers` = {}. Please open an issue " "to discuss this feature.".format( config.max_window_layers, config.num_hidden_layers, ) ) self.config = config self.quant_config = quant_config self.vocab_size = config.vocab_size self.embed_tokens = VocabParallelEmbedding( config.vocab_size, config.hidden_size, quant_config=quant_config, prefix=f"{prefix}.embed_tokens", ) self.loop_num = getattr(self.config, "loop_num", 2) self.window_size = getattr(self.config, "loop_window_size", 64) # Gate projections for Loop 2+ (one per layer) head_dim = config.hidden_size // config.num_attention_heads _, _, self.gate_projections = make_layers( config.num_hidden_layers, lambda prefix: LoopGateProjection( total_num_heads=config.num_attention_heads, head_dim=head_dim, quant_config=quant_config, prefix=prefix, ), prefix=f"{prefix}.gate_projections", ) self.start_layer, self.end_layer, self.layers = make_layers( config.num_hidden_layers, lambda prefix: LoopCoderDecoderLayer( config=config, cache_config=cache_config, quant_config=quant_config, prefix=prefix, layer_idx=extract_layer_index(prefix), ), prefix=f"{prefix}.layers", ) self.make_empty_intermediate_tensors = make_empty_intermediate_tensors_factory( ["hidden_states", "residual"], config.hidden_size ) self.norm = LoopCoderRMSNorm(config.hidden_size, eps=config.rms_norm_eps) def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor: return self.embed_tokens(input_ids) def forward( self, input_ids: torch.Tensor, positions: torch.Tensor, intermediate_tensors: IntermediateTensors | None = None, inputs_embeds: torch.Tensor | None = None, ) -> torch.Tensor | IntermediateTensors: if inputs_embeds is not None: hidden_states = inputs_embeds else: hidden_states = self.embed_input_ids(input_ids) for loop_idx in range(self.loop_num): for layer_idx, layer in enumerate(self.layers[self.start_layer : self.end_layer]): # Get the actual layer index (accounting for pipeline parallelism) actual_layer_idx = self.start_layer + layer_idx # Get gate_proj for this layer (only for loop_idx > 0) gate_proj = ( self.gate_projections[actual_layer_idx] if loop_idx > 0 else None ) hidden_states = layer( positions, hidden_states, loop_idx, gate_proj ) hidden_states = self.norm(hidden_states) return hidden_states def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]: stacked_params_mapping = [ # (param_name, shard_name, shard_id) ("qkv_proj", "q_proj", "q"), ("qkv_proj", "k_proj", "k"), ("qkv_proj", "v_proj", "v"), ("gate_up_proj", "gate_proj", 0), ("gate_up_proj", "up_proj", 1), ] params_dict = dict(self.named_parameters(remove_duplicate=False)) loaded_params: set[str] = set() for name, loaded_weight in weights: if "rotary_emb.inv_freq" in name: continue if self.quant_config is not None and ( scale_name := self.quant_config.get_cache_scale(name) ): # Loading kv cache quantization scales param = params_dict[scale_name] weight_loader = getattr(param, "weight_loader", default_weight_loader) loaded_weight = ( loaded_weight if loaded_weight.dim() == 0 else loaded_weight[0] ) weight_loader(param, loaded_weight) loaded_params.add(scale_name) continue for param_name, weight_name, shard_id in stacked_params_mapping: if "gate_projections" in name: continue if weight_name not in name: continue name = name.replace(weight_name, param_name) # Skip loading extra bias for GPTQ models. if name.endswith(".bias") and name not in params_dict: continue if name.endswith("scale"): # Remapping the name of FP8 kv-scale. name = maybe_remap_kv_scale_name(name, params_dict) if name is None: continue param = params_dict[name] weight_loader = getattr(param, "weight_loader", default_weight_loader) if weight_loader == default_weight_loader: weight_loader(param, loaded_weight) else: weight_loader(param, loaded_weight, shard_id) break else: if name.startswith("gate_projections."): if name.endswith(".weight"): vllm_name = name.replace(".weight", ".gate_proj.weight") elif name.endswith(".bias"): vllm_name = name.replace(".bias", ".gate_proj.bias") else: continue if vllm_name in params_dict: param = params_dict[vllm_name] weight_loader = getattr(param, "weight_loader", default_weight_loader) weight_loader(param, loaded_weight) loaded_params.add(vllm_name) continue continue if name.endswith(".bias") and name not in params_dict: continue # Remapping the name of FP8 kv-scale. name = maybe_remap_kv_scale_name(name, params_dict) if name is None: continue param = params_dict[name] weight_loader = getattr(param, "weight_loader", default_weight_loader) weight_loader(param, loaded_weight) loaded_params.add(name) return loaded_params class IQuestLoopCoderForCausalLM(nn.Module): def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""): super().__init__() config = vllm_config.model_config.hf_config quant_config = vllm_config.quant_config self.config = config self.quant_config = quant_config self.model = IQuestLoopCoderModel( vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model") ) if config.tie_word_embeddings: self.lm_head = self.model.embed_tokens else: self.lm_head = ParallelLMHead( config.vocab_size, config.hidden_size, quant_config=quant_config, prefix=maybe_prefix(prefix, "lm_head"), ) self.logits_processor = LogitsProcessor(config.vocab_size) self.make_empty_intermediate_tensors = ( self.model.make_empty_intermediate_tensors ) def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor: return self.model.embed_input_ids(input_ids) def forward( self, input_ids: torch.Tensor, positions: torch.Tensor, intermediate_tensors: IntermediateTensors | None = None, inputs_embeds: torch.Tensor | None = None, ) -> torch.Tensor | IntermediateTensors: hidden_states = self.model( input_ids, positions, intermediate_tensors, inputs_embeds ) return hidden_states def compute_logits( self, hidden_states: torch.Tensor, ) -> torch.Tensor | None: logits = self.logits_processor(self.lm_head, hidden_states) return logits def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]: loader = AutoWeightsLoader( self, skip_prefixes=(["lm_head."] if self.config.tie_word_embeddings else None), ) return loader.load_weights(weights)

✅ 至此，vLLM 已完全支持 IQuest-Coder 模型。

5. 启动模型服务

一切准备就绪，启动模型！

vllm serve ./IQuest-Coder-V1-40B-Loop-Instruct \ --host 0.0.0.0 \ --port 8000 \ --tensor-parallel-size 4 \ --trust-remote-code \ --dtype bfloat16 \ --gpu-memory-utilization 0.85

参数说明：

启动成功后，你会看到类似输出：

INFO: Started server process [PID] INFO: Waiting for application startup. INFO: Application startup complete. INFO: Uvicorn running on http://0.0.0.0:8000

🎉 恭喜！你的IQuest-Coder 40B模型已成功运行！

6. 调用模型API：体验AI编程助手

你可以通过 OpenAI 兼容接口调用该模型。

示例请求（Python）

import requests url = "http://localhost:8000/v1/completions" headers = {"Content-Type": "application/json"} data = { "model": "./IQuest-Coder-V1-40B-Loop-Instruct", "prompt": "写一个快速排序的Python实现，并加上详细注释。", "max_tokens": 512, "temperature": 0.2 } response = requests.post(url, json=data, headers=headers) print(response.json()["choices"][0]["text"])

返回示例（节选）

def quicksort(arr): """ 快速排序函数 参数: arr - 待排序列表 返回: 排好序的新列表 """ if len(arr) <= 1: return arr pivot = arr[len(arr) // 2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quicksort(left) + middle + quicksort(right)

是不是又快又准？这才是真正的“智能编程”！

7. 总结

本文带你完成了IQuest-Coder-V1-40B-Instruct模型的完整本地部署流程：

1. ✅ 搭建了基于 vLLM 的高性能推理环境
2. ✅ 成功下载并加载了百亿参数代码模型
3. ✅ 解决了因架构不兼容导致的Model architectures [...] are not supported报错
4. ✅ 通过打补丁方式扩展了 vLLM 对新模型的支持能力
5. ✅ 实现了本地 API 服务调用，打造专属 AI 编程助手

这款模型不仅能在常规编码任务中表现出色，在SWE-Bench Verified（76.2%）和LiveCodeBench v6（81.1%）等复杂软件工程评测中也处于领先水平，是当前最具潜力的代码大模型之一。

💡获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。