A high-throughput and memory-efficient inference and serving engine for LLMs
[Model] Remove obsolete ERNIE models (#45127)
Signed-off-by: Xianbao QIAN <xianbao.qian@gmail.com> Co-authored-by: Claude <noreply@anthropic.com>
Tiezhen WANG committed
Jun 10, 2026 at 20:54 UTC
77f42d9725a523ddc9b3d850e8c61549a2b14e7b
9 files changed
+4
-309
docs/models/pooling_models/classify.md
-1
@@ -31,7 +31,6 @@ The most fundamental application of classification models is to categorize input
31
32
| Architecture | Models | Example HF Models | [LoRA](../../features/lora.md) | [PP](../../serving/parallelism_scaling.md) |
33
| ------------ | ------ | ----------------- | ------------------------------ | ------------------------------------------ |
34
-| `ErnieForSequenceClassification` | BERT-like Chinese ERNIE | `Forrest20231206/ernie-3.0-base-zh-cls` | | |
34
| `GPT2ForSequenceClassification` | GPT2 | `nie3e/sentiment-polish-gpt2-small` | | |
35
| `Qwen2ForSequenceClassification`<sup>C</sup> | Qwen2-based | `jason9693/Qwen2.5-1.5B-apeach` | | |
36
| `*Model`<sup>C</sup>, `*ForCausalLM`<sup>C</sup>, etc. | Generative models | N/A | \* | \* |
docs/models/pooling_models/embed.md
-1
@@ -39,7 +39,6 @@ You can compute pairwise similarity scores to build a similarity matrix using th
39
| ------------ | ------ | ----------------- | ------------------------------ | ------------------------------------------ |
40
| `BertModel` | BERT-based | `BAAI/bge-base-en-v1.5`, `Snowflake/snowflake-arctic-embed-xs`, etc. | | |
41
| `BertSpladeSparseEmbeddingModel` | SPLADE | `naver/splade-v3` | | |
42
-| `ErnieModel` | BERT-like Chinese ERNIE | `shibing624/text2vec-base-chinese-sentence` | | |
42
| `Gemma2Model`<sup>C</sup> | Gemma 2-based | `BAAI/bge-multilingual-gemma2`, etc. | ✅︎ | ✅︎ |
43
| `Gemma3TextModel`<sup>C</sup> | Gemma 3-based | `google/embeddinggemma-300m`, etc. | ✅︎ | ✅︎ |
44
| `GritLM` | GritLM | `parasail-ai/GritLM-7B-vllm`. | ✅︎ | ✅︎ |
docs/models/pooling_models/token_classify.md
-1
@@ -44,7 +44,6 @@ The BAAI/bge-m3 model leverages token classification for sparse retrieval. For m
44
| Architecture | Models | Example HF Models | [LoRA](../../features/lora.md) | [PP](../../serving/parallelism_scaling.md) |
45
| ------------ | ------ | ----------------- | --------------------------- | --------------------------------------- |
46
| `BertForTokenClassification` | bert-based | `boltuix/NeuroBERT-NER` (see note), etc. | | |
47
-| `ErnieForTokenClassification` | BERT-like Chinese ERNIE | `gyr66/Ernie-3.0-base-chinese-finetuned-ner` | | |
47
| `ModernBertForTokenClassification` | ModernBERT-based | `disham993/electrical-ner-ModernBERT-base` | | |
48
| `Qwen3ForTokenClassification`<sup>C</sup> | Qwen3-based | `bd2lcco/Qwen3-0.6B-finetuned` | | |
49
| `*Model`<sup>C</sup>, `*ForCausalLM`<sup>C</sup>, etc. | Generative models | N/A | \* | \* |
tests/models/language/pooling/test_classification.py
-2
@@ -18,7 +18,6 @@ from vllm.platforms import current_platform
18
pytest.mark.slow_test,
19
],
20
),
21
- pytest.param("Forrest20231206/ernie-3.0-base-zh-cls"),
21
],
22
)
23
@pytest.mark.parametrize("dtype", ["half"] if current_platform.is_rocm() else ["float"])
@@ -48,6 +47,5 @@ def test_models(
47
assert torch.allclose(
48
hf_output,
49
vllm_output,
51
- atol=1e-3 if dtype == "float" else 1e-2,
50
rtol=2e-3 if dtype == "float" else 1e-2,
51
)
tests/models/language/pooling/test_token_classification.py
+1
-2
@@ -24,13 +24,12 @@ def seed_everything():
24
"model",
25
[
26
"boltuix/NeuroBERT-NER",
27
- "gyr66/Ernie-3.0-base-chinese-finetuned-ner",
27
],
28
)
29
# The float32 is required for this tiny model to pass the test.
30
@pytest.mark.parametrize("dtype", ["float"])
31
@torch.inference_mode
33
-def test_bert_like_models(
32
+def test_bert_models(
33
hf_runner,
34
vllm_runner,
35
example_prompts,
tests/models/language/pooling_mteb_test/test_ernie.py
deleted
-45
@@ -1,45 +0,0 @@
1
-# SPDX-License-Identifier: Apache-2.0
2
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3
-
4
-import pytest
5
-
6
-from tests.models.language.pooling.embed_utils import correctness_test_embed_models
7
-from tests.models.utils import EmbedModelInfo
8
-
9
-from .mteb_embed_utils import mteb_test_embed_models
10
-
11
-MODELS = [
12
- EmbedModelInfo(
13
- "shibing624/text2vec-base-chinese-sentence",
14
- architecture="ErnieModel",
15
- mteb_score=0.536523112,
16
- seq_pooling_type="MEAN",
17
- attn_type="encoder_only",
18
- is_prefix_caching_supported=False,
19
- is_chunked_prefill_supported=False,
20
- enable_test=True,
21
- ),
22
-]
23
-
24
-
25
-@pytest.mark.parametrize("model_info", MODELS)
26
-def test_embed_models_mteb(hf_runner, vllm_runner, model_info: EmbedModelInfo) -> None:
27
- mteb_test_embed_models(
28
- hf_runner,
29
- vllm_runner,
30
- model_info,
31
- vllm_extra_kwargs={"gpu_memory_utilization": 0.2},
32
- )
33
-
34
-
35
-@pytest.mark.parametrize("model_info", MODELS)
36
-def test_embed_models_correctness(
37
- hf_runner, vllm_runner, model_info: EmbedModelInfo, example_prompts
38
-) -> None:
39
- correctness_test_embed_models(
40
- hf_runner,
41
- vllm_runner,
42
- model_info,
43
- example_prompts,
44
- vllm_extra_kwargs={"gpu_memory_utilization": 0.2},
45
- )
tests/models/registry.py
-7
@@ -610,7 +610,6 @@ _TEXT_GENERATION_EXAMPLE_MODELS = {
610
_EMBEDDING_EXAMPLE_MODELS = {
611
# [Text-only]
612
"BertModel": _HfExamplesInfo("BAAI/bge-base-en-v1.5"),
613
- "ErnieModel": _HfExamplesInfo("shibing624/text2vec-base-chinese-sentence"),
613
"BertSpladeSparseEmbeddingModel": _HfExamplesInfo(
614
"naver/splade-v3",
615
hf_overrides={"architectures": ["BertSpladeSparseEmbeddingModel"]},
@@ -740,9 +739,6 @@ _REWARD_EXAMPLE_MODELS = {
739
740
_TOKEN_CLASSIFICATION_EXAMPLE_MODELS = {
741
"BertForTokenClassification": _HfExamplesInfo("boltuix/NeuroBERT-NER"),
743
- "ErnieForTokenClassification": _HfExamplesInfo(
744
- "gyr66/Ernie-3.0-base-chinese-finetuned-ner"
745
- ),
742
"ModernBertForTokenClassification": _HfExamplesInfo(
743
"disham993/electrical-ner-ModernBERT-base"
744
),
@@ -752,9 +748,6 @@ _SEQUENCE_CLASSIFICATION_EXAMPLE_MODELS = {
748
"BertForSequenceClassification": _HfExamplesInfo(
749
"cross-encoder/ms-marco-MiniLM-L-6-v2"
750
),
755
- "ErnieForSequenceClassification": _HfExamplesInfo(
756
- "Forrest20231206/ernie-3.0-base-zh-cls",
757
- ),
751
"GPT2ForSequenceClassification": _HfExamplesInfo(
752
"nie3e/sentiment-polish-gpt2-small"
753
),
vllm/model_executor/models/ernie.py
deleted
-247
@@ -1,247 +0,0 @@
1
-# SPDX-License-Identifier: Apache-2.0
2
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3
-
4
-from collections.abc import Iterable
5
-
6
-import torch
7
-from torch import nn
8
-from transformers import BertConfig
9
-
10
-from vllm.config import VllmConfig
11
-from vllm.model_executor.layers.pooler import DispatchPooler
12
-from vllm.model_executor.layers.pooler.tokwise import pooler_for_token_classify
13
-from vllm.model_executor.layers.vocab_parallel_embedding import VocabParallelEmbedding
14
-from vllm.sequence import IntermediateTensors
15
-
16
-from .bert import (
17
- TOKEN_TYPE_SHIFT,
18
- BertEmbedding,
19
- BertEmbeddingModel,
20
- BertModel,
21
- BertPoolingModel,
22
- _decode_token_type_ids,
23
- _encode_token_type_ids,
24
-)
25
-from .interfaces import SupportsCrossEncoding, SupportsQuant
26
-from .interfaces_base import attn_type, default_pooling_type
27
-from .utils import AutoWeightsLoader, WeightsMapper, maybe_prefix
28
-
29
-_LEGACY_SUFFIX_MAPPER = WeightsMapper(
30
- orig_to_new_suffix={
31
- ".gamma": ".weight",
32
- ".beta": ".bias",
33
- }
34
-)
35
-
36
-
37
-class ErnieEmbedding(BertEmbedding):
38
- def __init__(self, config: BertConfig):
39
- super().__init__(config)
40
-
41
- task_type_vocab_size = max(1, getattr(config, "task_type_vocab_size", 1))
42
- self.task_type_embeddings = VocabParallelEmbedding(
43
- task_type_vocab_size, config.hidden_size
44
- )
45
-
46
- def forward(
47
- self,
48
- input_ids: torch.Tensor,
49
- position_ids: torch.Tensor,
50
- inputs_embeds: torch.Tensor | None = None,
51
- ) -> torch.Tensor:
52
- token_type_ids = _decode_token_type_ids(input_ids)
53
- task_type_ids = torch.zeros_like(token_type_ids)
54
-
55
- if inputs_embeds is None:
56
- inputs_embeds = self.word_embeddings(input_ids)
57
-
58
- position_embeddings = self.position_embeddings(position_ids)
59
- token_type_embeddings = self.token_type_embeddings(token_type_ids)
60
- task_type_embeddings = self.task_type_embeddings(task_type_ids)
61
-
62
- embeddings = (
63
- inputs_embeds
64
- + token_type_embeddings
65
- + task_type_embeddings
66
- + position_embeddings
67
- )
68
- embeddings = self.LayerNorm(embeddings)
69
- return embeddings
70
-
71
-
72
-@default_pooling_type(seq_pooling_type="CLS")
73
-class ErnieModel(BertModel):
74
- def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
75
- super().__init__(
76
- vllm_config=vllm_config,
77
- prefix=prefix,
78
- embedding_class=ErnieEmbedding,
79
- )
80
-
81
-
82
-class ErniePoolingModel(BertPoolingModel):
83
- def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
84
- super().__init__(
85
- vllm_config=vllm_config,
86
- prefix=prefix,
87
- embedding_class=ErnieEmbedding,
88
- )
89
-
90
-
91
-@default_pooling_type(seq_pooling_type="CLS")
92
-class ErnieEmbeddingModel(BertEmbeddingModel):
93
- def _build_model(self, vllm_config: VllmConfig, prefix: str = "") -> ErnieModel:
94
- return ErnieModel(vllm_config=vllm_config, prefix=prefix)
95
-
96
- def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]):
97
- weights_list = list(weights)
98
- has_model_prefix = any(name.startswith("model.") for name, _ in weights_list)
99
- has_ernie_prefix = any(name.startswith("ernie.") for name, _ in weights_list)
100
-
101
- mapper: WeightsMapper | None = None
102
- if not has_model_prefix:
103
- if has_ernie_prefix:
104
- mapper = WeightsMapper(orig_to_new_prefix={"ernie.": "model."})
105
- else:
106
- mapper = WeightsMapper(orig_to_new_prefix={"": "model."})
107
- if mapper is None:
108
- mapper = _LEGACY_SUFFIX_MAPPER
109
- else:
110
- mapper = mapper | _LEGACY_SUFFIX_MAPPER
111
-
112
- loader = AutoWeightsLoader(self, skip_prefixes=["lm_head.", "cls."])
113
- return loader.load_weights(weights_list, mapper=mapper)
114
-
115
-
116
-@default_pooling_type(seq_pooling_type="CLS")
117
-class ErnieForSequenceClassification(nn.Module, SupportsCrossEncoding, SupportsQuant):
118
- is_pooling_model = True
119
-
120
- def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
121
- super().__init__()
122
- config = vllm_config.model_config.hf_config
123
-
124
- self.num_labels = config.num_labels
125
- self.ernie = ErniePoolingModel(
126
- vllm_config=vllm_config,
127
- prefix=maybe_prefix(prefix, "ernie"),
128
- )
129
- self.classifier = nn.Linear(
130
- config.hidden_size,
131
- config.num_labels,
132
- dtype=vllm_config.model_config.head_dtype,
133
- )
134
-
135
- pooler_config = vllm_config.model_config.pooler_config
136
- assert pooler_config is not None
137
-
138
- self.pooler = DispatchPooler.for_seq_cls(
139
- pooler_config,
140
- pooling=self.ernie.pooler,
141
- classifier=self.classifier,
142
- )
143
-
144
- def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:
145
- return self.ernie.embed_input_ids(input_ids)
146
-
147
- def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]):
148
- weights_list = list(weights)
149
- has_ernie_prefix = any(name.startswith("ernie.") for name, _ in weights_list)
150
- has_bert_prefix = any(name.startswith("bert.") for name, _ in weights_list)
151
-
152
- mapper: WeightsMapper | None = None
153
- if has_bert_prefix and not has_ernie_prefix:
154
- mapper = WeightsMapper(orig_to_new_prefix={"bert.": "ernie."})
155
- if mapper is None:
156
- mapper = _LEGACY_SUFFIX_MAPPER
157
- else:
158
- mapper = mapper | _LEGACY_SUFFIX_MAPPER
159
-
160
- loader = AutoWeightsLoader(self, skip_prefixes=["cls.", "lm_head."])
161
- return loader.load_weights(weights_list, mapper=mapper)
162
-
163
- def forward(
164
- self,
165
- input_ids: torch.Tensor | None,
166
- positions: torch.Tensor,
167
- intermediate_tensors: IntermediateTensors | None = None,
168
- inputs_embeds: torch.Tensor | None = None,
169
- token_type_ids: torch.Tensor | None = None,
170
- ) -> torch.Tensor:
171
- if token_type_ids is not None:
172
- assert self.ernie.config.vocab_size < (1 << TOKEN_TYPE_SHIFT)
173
- assert input_ids is not None
174
- _encode_token_type_ids(input_ids, token_type_ids)
175
-
176
- return self.ernie(
177
- input_ids=input_ids,
178
- positions=positions,
179
- inputs_embeds=inputs_embeds,
180
- intermediate_tensors=intermediate_tensors,
181
- )
182
-
183
-
184
-@attn_type("encoder_only")
185
-@default_pooling_type(tok_pooling_type="ALL")
186
-class ErnieForTokenClassification(nn.Module):
187
- is_pooling_model = True
188
-
189
- def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
190
- super().__init__()
191
- config = vllm_config.model_config.hf_config
192
- self.head_dtype = vllm_config.model_config.head_dtype
193
- self.num_labels = config.num_labels
194
- self.ernie = ErnieModel(
195
- vllm_config=vllm_config,
196
- prefix=maybe_prefix(prefix, "ernie"),
197
- )
198
- self.classifier = nn.Linear(
199
- config.hidden_size, config.num_labels, dtype=self.head_dtype
200
- )
201
-
202
- pooler_config = vllm_config.model_config.pooler_config
203
- assert pooler_config is not None
204
-
205
- self.pooler = pooler_for_token_classify(pooler_config)
206
-
207
- def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:
208
- return self.ernie.embed_input_ids(input_ids)
209
-
210
- def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]):
211
- weights_list = list(weights)
212
- has_ernie_prefix = any(name.startswith("ernie.") for name, _ in weights_list)
213
- has_bert_prefix = any(name.startswith("bert.") for name, _ in weights_list)
214
-
215
- mapper: WeightsMapper | None = None
216
- if has_bert_prefix and not has_ernie_prefix:
217
- mapper = WeightsMapper(orig_to_new_prefix={"bert.": "ernie."})
218
- if mapper is None:
219
- mapper = _LEGACY_SUFFIX_MAPPER
220
- else:
221
- mapper = mapper | _LEGACY_SUFFIX_MAPPER
222
-
223
- loader = AutoWeightsLoader(self, skip_prefixes=["cls.", "lm_head."])
224
- return loader.load_weights(weights_list, mapper=mapper)
225
-
226
- def forward(
227
- self,
228
- input_ids: torch.Tensor | None,
229
- positions: torch.Tensor,
230
- intermediate_tensors: IntermediateTensors | None = None,
231
- inputs_embeds: torch.Tensor | None = None,
232
- token_type_ids: torch.Tensor | None = None,
233
- ) -> torch.Tensor:
234
- if token_type_ids is not None:
235
- assert self.ernie.config.vocab_size < (1 << TOKEN_TYPE_SHIFT)
236
- assert input_ids is not None
237
- _encode_token_type_ids(input_ids, token_type_ids)
238
-
239
- hidden_states = self.ernie(
240
- input_ids=input_ids,
241
- positions=positions,
242
- inputs_embeds=inputs_embeds,
243
- intermediate_tensors=intermediate_tensors,
244
- )
245
-
246
- hidden_states = hidden_states.to(self.head_dtype)
247
- return self.classifier(hidden_states)
vllm/model_executor/models/registry.py
+3
-3
@@ -225,7 +225,6 @@ _EMBEDDING_MODELS = {
225
# [Text-only]
226
"BertModel": ("bert", "BertEmbeddingModel"),
227
"BertSpladeSparseEmbeddingModel": ("bert", "BertSpladeSparseEmbeddingModel"),
228
- "ErnieModel": ("ernie", "ErnieEmbeddingModel"),
228
"BgeM3EmbeddingModel": ("roberta", "BgeM3EmbeddingModel"),
229
"DeciLMForCausalLM": ("nemotron_nas", "DeciLMForCausalLM"),
230
"Gemma2Model": ("gemma2", "Gemma2ForCausalLM"),
@@ -300,7 +299,6 @@ _REWARD_MODELS = {
299
300
_TOKEN_CLASSIFICATION_MODELS = {
301
"BertForTokenClassification": ("bert", "BertForTokenClassification"),
303
- "ErnieForTokenClassification": ("ernie", "ErnieForTokenClassification"),
302
"ModernBertForTokenClassification": (
303
"modernbert",
304
"ModernBertForTokenClassification",
@@ -314,7 +312,6 @@ _TOKEN_CLASSIFICATION_MODELS = {
312
_SEQUENCE_CLASSIFICATION_MODELS = {
313
"BertForSequenceClassification": ("bert", "BertForSequenceClassification"),
314
"GPT2ForSequenceClassification": ("gpt2", "GPT2ForSequenceClassification"),
317
- "ErnieForSequenceClassification": ("ernie", "ErnieForSequenceClassification"),
315
"GteNewForSequenceClassification": (
316
"bert_with_rope",
317
"GteNewForSequenceClassification",
@@ -715,6 +712,9 @@ _PREVIOUSLY_SUPPORTED_MODELS = {
712
"Phi4FlashForCausalLM": "0.10.2",
713
"Phi4MultimodalForCausalLM": "0.12.0",
714
"JAISLMHeadModel": "0.22.0",
715
+ "ErnieModel": "0.23.0",
716
+ "ErnieForSequenceClassification": "0.23.0",
717
+ "ErnieForTokenClassification": "0.23.0",
718
# encoder-decoder models except whisper
719
# have been removed for V0 deprecation.
720
"DonutForConditionalGeneration": "0.10.2",