+ GteNewForSequenceClassification support

Signed-off-by: wang.yuqi <noooop@126.com>

Author: noooop

docs/models/supported_models.md

@@ -453,19 +453,24 @@ If your model is not in the above list, we will try to automatically convert the
 
 Specified using `--task score`.
 
-| Architecture                          | Models            | Example HF Models                                                                    | [V1](gh-issue:8779)   |
-|---------------------------------------|-------------------|--------------------------------------------------------------------------------------|-----------------------|
-| `BertForSequenceClassification`       | BERT-based        | `cross-encoder/ms-marco-MiniLM-L-6-v2`, etc.                                         |                       |
-| `Qwen3ForSequenceClassification`      | Qwen3-based       | `tomaarsen/Qwen3-Reranker-0.6B-seq-cls`, `Qwen/Qwen3-Reranker-0.6B` (see note), etc. |                       |
-| `RobertaForSequenceClassification`    | RoBERTa-based     | `cross-encoder/quora-roberta-base`, etc.                                             |                       |
-| `XLMRobertaForSequenceClassification` | XLM-RoBERTa-based | `BAAI/bge-reranker-v2-m3`, etc.                                                      |                       |
+| Architecture                          | Models              | Example HF Models                                                                    | [V1](gh-issue:8779) |
+|---------------------------------------|---------------------|--------------------------------------------------------------------------------------|---------------------|
+| `BertForSequenceClassification`       | BERT-based          | `cross-encoder/ms-marco-MiniLM-L-6-v2`, etc.                                         |                     |
+| `GteNewForSequenceClassification`     | mGTE-TRM (see note) | `Alibaba-NLP/gte-multilingual-reranker-base`, etc.                                   |                     |
+| `Qwen3ForSequenceClassification`      | Qwen3-based         | `tomaarsen/Qwen3-Reranker-0.6B-seq-cls`, `Qwen/Qwen3-Reranker-0.6B` (see note), etc. |                     |
+| `RobertaForSequenceClassification`    | RoBERTa-based       | `cross-encoder/quora-roberta-base`, etc.                                             |                     |
+| `XLMRobertaForSequenceClassification` | XLM-RoBERTa-based   | `BAAI/bge-reranker-v2-m3`, etc.                                                      |                     |
+
+!!! note
+    The second-generation GTE model (mGTE-TRM) is named `NewModel`. The name `NewModel` is too generic, you should set `--hf-overrides '{"architectures": ["GteNewForSequenceClassification"]}'` to specify the use of the `GteNewForSequenceClassification` architecture.
 
 !!! note
     Load the official original `Qwen3 Reranker` by using the following command. More information can be found at: <gh-file:examples/offline_inference/qwen3_reranker.py>.
 
     ```bash
     vllm serve Qwen/Qwen3-Reranker-0.6B --hf_overrides '{"architectures": ["Qwen3ForSequenceClassification"],"classifier_from_token": ["no", "yes"],"is_original_qwen3_reranker": true}'
     ```
+
 [](){ #supported-mm-models }
 
 ## List of Multimodal Language Models

tests/models/language/pooling/test_gte.py

@@ -59,6 +59,9 @@
 ]
 
 RERANK_MODELS = [
+    RerankModelInfo("Alibaba-NLP/gte-multilingual-reranker-base",
+                    architecture="GteNewForSequenceClassification",
+                    enable_test=True),
     RerankModelInfo("Alibaba-NLP/gte-reranker-modernbert-base",
                     architecture="ModernBertForSequenceClassification",
                     enable_test=False),
@@ -93,10 +96,30 @@ def test_embed_models_correctness(hf_runner, vllm_runner,
 @pytest.mark.parametrize("model_info", RERANK_MODELS)
 def test_rerank_models_mteb(hf_runner, vllm_runner,
                             model_info: RerankModelInfo) -> None:
-    mteb_test_rerank_models(hf_runner, vllm_runner, model_info)
+
+    vllm_extra_kwargs: dict[str, Any] = {}
+    if model_info.architecture == "GteNewForSequenceClassification":
+        vllm_extra_kwargs["hf_overrides"] = {
+            "architectures": ["GteNewForSequenceClassification"]
+        }
+
+    mteb_test_rerank_models(hf_runner,
+                            vllm_runner,
+                            model_info,
+                            vllm_extra_kwargs=vllm_extra_kwargs)
 
 
 @pytest.mark.parametrize("model_info", RERANK_MODELS)
 def test_rerank_models_correctness(hf_runner, vllm_runner,
                                    model_info: RerankModelInfo) -> None:
-    ping_pong_test_score_models(hf_runner, vllm_runner, model_info)
+
+    vllm_extra_kwargs: dict[str, Any] = {}
+    if model_info.architecture == "GteNewForSequenceClassification":
+        vllm_extra_kwargs["hf_overrides"] = {
+            "architectures": ["GteNewForSequenceClassification"]
+        }
+
+    ping_pong_test_score_models(hf_runner,
+                                vllm_runner,
+                                model_info,
+                                vllm_extra_kwargs=vllm_extra_kwargs)

tests/models/registry.py

@@ -301,9 +301,13 @@ def check_available_online(
 _CROSS_ENCODER_EXAMPLE_MODELS = {
     # [Text-only]
     "BertForSequenceClassification": _HfExamplesInfo("cross-encoder/ms-marco-MiniLM-L-6-v2"),  # noqa: E501
+    "GteNewForSequenceClassification": _HfExamplesInfo("Alibaba-NLP/gte-multilingual-reranker-base",  # noqa: E501
+                                                       hf_overrides={
+                                                           "architectures": ["GteNewForSequenceClassification"] # noqa: E501
+                                                       }),
+    "ModernBertForSequenceClassification": _HfExamplesInfo("Alibaba-NLP/gte-reranker-modernbert-base"),  # noqa: E501
     "RobertaForSequenceClassification": _HfExamplesInfo("cross-encoder/quora-roberta-base"),  # noqa: E501
     "XLMRobertaForSequenceClassification": _HfExamplesInfo("BAAI/bge-reranker-v2-m3"),  # noqa: E501
-    "ModernBertForSequenceClassification": _HfExamplesInfo("Alibaba-NLP/gte-reranker-modernbert-base"),  # noqa: E501
 }
 
 _MULTIMODAL_EXAMPLE_MODELS = {

vllm/model_executor/models/bert_with_rope.py

@@ -20,15 +20,21 @@
                                                QKVParallelLinear,
                                                ReplicatedLinear,
                                                RowParallelLinear)
+from vllm.model_executor.layers.pooler import ClassifierPooler
 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 (
     VocabParallelEmbedding)
 from vllm.model_executor.model_loader.weight_utils import default_weight_loader
 from vllm.model_executor.models import SupportsV0Only
-from vllm.model_executor.models.interfaces import SupportsQuant
-from vllm.model_executor.models.utils import WeightsMapper
-from vllm.sequence import IntermediateTensors
+from vllm.model_executor.models.bert import BertPooler
+from vllm.model_executor.models.interfaces import (SupportsCrossEncoding,
+                                                   SupportsQuant)
+from vllm.model_executor.models.utils import WeightsMapper, maybe_prefix
+from vllm.model_executor.pooling_metadata import PoolingMetadata
+from vllm.sequence import IntermediateTensors, PoolerOutput
+from vllm.transformers_utils.config import (
+    get_cross_encoder_activation_function)
 
 logger = init_logger(__name__)
 
@@ -405,16 +411,23 @@ def forward(
 class BertWithRope(nn.Module, SupportsV0Only, SupportsQuant):
     hf_to_vllm_mapper = WeightsMapper(orig_to_new_prefix={"model.": ""})
 
-    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
+    def __init__(self,
+                 *,
+                 vllm_config: VllmConfig,
+                 prefix: str = "",
+                 add_pooling_layer=False):
         super().__init__()
         self.vllm_config = vllm_config
+        self.add_pooling_layer = add_pooling_layer
         self.config = self.config_verify(vllm_config)
         self.embeddings = BertWithRopeEmbedding(self.config)
         self.encoder = BertWithRopeEncoder(
             vllm_config=vllm_config,
             bias=getattr(self.config, "bias", True),
             rotary_kwargs=self.config.rotary_kwargs,
             prefix=f"{prefix}.encoder")
+        if self.add_pooling_layer:
+            self.pooler = BertPooler(self.config)
 
     def config_verify(self, vllm_config):
         raise NotImplementedError
@@ -450,7 +463,7 @@ def load_weights(self, weights: Iterable[tuple[str,
         params_dict = dict(self.named_parameters())
         loaded_params: set[str] = set()
         for name, loaded_weight in weights:
-            if "pooler" in name:
+            if not self.add_pooling_layer and "pooler" in name:
                 continue
             for (param_name, weight_name, shard_id) in stacked_params_mapping:
                 if weight_name not in name:
@@ -591,8 +604,8 @@ class GteNewModel(BertWithRope):
             "attention.o_proj": "attn.out_proj",
         })
 
-    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
-        super().__init__(vllm_config=vllm_config, prefix=prefix)
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = "", **kwargs):
+        super().__init__(vllm_config=vllm_config, prefix=prefix, **kwargs)
 
         # GteNewModel only gate_up_proj does not have bias.
         # Hack method learned from vllm/model_executor/models/glm.py
@@ -762,3 +775,65 @@ def load_weights(self, weights: Iterable[tuple[str,
                                                    torch.Tensor]]) -> set[str]:
         weights = self.jina_merge_lora_weights(weights)
         return super().load_weights(weights)
+
+
+class GteNewForSequenceClassification(nn.Module, SupportsCrossEncoding,
+                                      SupportsQuant):
+
+    def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
+        super().__init__()
+        config = vllm_config.model_config.hf_config
+
+        self.default_activation_function = \
+            get_cross_encoder_activation_function(config)
+
+        self.num_labels = config.num_labels
+        self.new = GteNewModel(vllm_config=vllm_config,
+                               prefix=maybe_prefix(prefix, "new"),
+                               add_pooling_layer=True)
+        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+        self._pooler = ClassifierPooler(vllm_config.model_config,
+                                        self.classifier, self.new.pooler)
+
+    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]):
+
+        self_weights = []
+
+        def weight_filter():
+            for name, weight in weights:
+                if name.startswith("new."):
+                    yield (name[len("new."):], weight)
+                else:
+                    self_weights.append((name, weight))
+
+        self.new.load_weights(weight_filter())
+
+        params_dict = dict(self.named_parameters())
+
+        for name, loaded_weight in self_weights:
+            if name.startswith("classifier"):
+                param = params_dict[name]
+                weight_loader = getattr(param, "weight_loader",
+                                        default_weight_loader)
+                weight_loader(param, loaded_weight)
+
+    def pooler(
+        self,
+        hidden_states: torch.Tensor,
+        pooling_metadata: PoolingMetadata,
+    ) -> Optional[PoolerOutput]:
+        return self._pooler(hidden_states, pooling_metadata)
+
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor],
+        positions: torch.Tensor,
+        intermediate_tensors: Optional[IntermediateTensors] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        token_type_ids: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        return self.new(input_ids=input_ids,
+                        positions=positions,
+                        inputs_embeds=inputs_embeds,
+                        intermediate_tensors=intermediate_tensors,
+                        token_type_ids=token_type_ids)

vllm/model_executor/models/registry.py

@@ -172,9 +172,10 @@
     "ModernBertForSequenceClassification": ("modernbert",
                                             "ModernBertForSequenceClassification"),
     # [Auto-converted (see adapters.py)]
-    "Qwen2ForSequenceClassification": ("qwen2", "Qwen2ForCausalLM"), # noqa: E501
-    "Qwen3ForSequenceClassification": ("qwen3", "Qwen3ForSequenceClassification"), # noqa: E501
     "GemmaForSequenceClassification": ("gemma", "GemmaForCausalLM"),
+    "GteNewForSequenceClassification": ("bert_with_rope", "GteNewForSequenceClassification"), # noqa: E501
+    "Qwen2ForSequenceClassification": ("qwen2", "Qwen2ForCausalLM"),
+    "Qwen3ForSequenceClassification": ("qwen3", "Qwen3ForSequenceClassification"), # noqa: E501
 }
 
 _MULTIMODAL_MODELS = {