A high-throughput and memory-efficient inference and serving engine for LLMs
[Model] Remove Dots1ForCausalLM (#45637)
Signed-off-by: Xianbao QIAN <xianbao.qian@gmail.com> Co-authored-by: Claude <noreply@anthropic.com>
Tiezhen WANG committed
Jun 17, 2026 at 00:32 UTC
89e8645a9e5970367e363ce42d664f577b7b4246
4 files changed
+1
-562
docs/models/supported_models.md
-1
@@ -386,7 +386,6 @@ th {
386
| `DeepseekV2ForCausalLM` | DeepSeek-V2 | `deepseek-ai/DeepSeek-V2`, `deepseek-ai/DeepSeek-V2-Chat`, etc. | ✅︎ | ✅︎ |
387
| `DeepseekV3ForCausalLM` | DeepSeek-V3 | `deepseek-ai/DeepSeek-V3`, `deepseek-ai/DeepSeek-R1`, `deepseek-ai/DeepSeek-V3.1`, etc. | ✅︎ | ✅︎ |
388
| `DeepseekV4ForCausalLM` | DeepSeek-V4 | `deepseek-ai/DeepSeek-V4-Flash`, `deepseek-ai/DeepSeek-V4-Pro`, etc. | | ✅︎ |
389
-| `Dots1ForCausalLM` | dots.llm1 | `rednote-hilab/dots.llm1.base`, `rednote-hilab/dots.llm1.inst`, etc. | | ✅︎ |
389
| `DotsOCRForCausalLM` | dots_ocr | `rednote-hilab/dots.ocr` | ✅︎ | ✅︎ |
390
| `Ernie4_5ForCausalLM` | Ernie4.5 | `baidu/ERNIE-4.5-0.3B-PT`, etc. | ✅︎ | ✅︎ |
391
| `Ernie4_5_MoeForCausalLM` | Ernie4.5MoE | `baidu/ERNIE-4.5-21B-A3B-PT`, `baidu/ERNIE-4.5-300B-A47B-PT`, etc. | ✅︎ | ✅︎ |
tests/models/registry.py
-1
@@ -595,7 +595,6 @@ _TEXT_GENERATION_EXAMPLE_MODELS = {
595
"MiMoV2ForCausalLM": _HfExamplesInfo(
596
"XiaomiMiMo/MiMo-V2.5-Pro", trust_remote_code=True
597
),
598
- "Dots1ForCausalLM": _HfExamplesInfo("rednote-hilab/dots.llm1.inst"),
598
}
599
600
_EMBEDDING_EXAMPLE_MODELS = {
vllm/model_executor/models/dots1.py
deleted
-559
@@ -1,559 +0,0 @@
1
-# SPDX-License-Identifier: Apache-2.0
2
-# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3
-
4
-# Adapted from
5
-# https://github.com/huggingface/transformers/blob/v4.28.0/src/transformers/models/llama/modeling_llama.py
6
-# Copyright 2025 The rednote-hilab team.
7
-# Copyright 2023 The vLLM team.
8
-# Copyright 2023 DeepSeek-AI and the HuggingFace Inc. team. All rights reserved.
9
-#
10
-# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX
11
-# and OPT implementations in this library. It has been modified from its
12
-# original forms to accommodate minor architectural differences compared
13
-# to GPT-NeoX and OPT used by the Meta AI team that trained the model.
14
-#
15
-# Licensed under the Apache License, Version 2.0 (the "License");
16
-# you may not use this file except in compliance with the License.
17
-# You may obtain a copy of the License at
18
-#
19
-# http://www.apache.org/licenses/LICENSE-2.0
20
-#
21
-# Unless required by applicable law or agreed to in writing, software
22
-# distributed under the License is distributed on an "AS IS" BASIS,
23
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
24
-# See the License for the specific language governing permissions and
25
-# limitations under the License.
26
-"""Inference-only dots1 model."""
27
-
28
-from collections.abc import Iterable
29
-from itertools import islice
30
-
31
-import torch
32
-from torch import nn
33
-from transformers import Dots1Config
34
-
35
-from vllm.compilation.decorators import support_torch_compile
36
-from vllm.config import CacheConfig, ModelConfig, VllmConfig
37
-from vllm.distributed import (
38
- get_pp_group,
39
- get_tensor_model_parallel_world_size,
40
-)
41
-from vllm.model_executor.layers.activation import SiluAndMul
42
-from vllm.model_executor.layers.attention import Attention
43
-from vllm.model_executor.layers.fused_moe import (
44
- FusedMoE,
45
- fused_moe_make_expert_params_mapping,
46
-)
47
-from vllm.model_executor.layers.layernorm import RMSNorm
48
-from vllm.model_executor.layers.linear import (
49
- MergedColumnParallelLinear,
50
- QKVParallelLinear,
51
- ReplicatedLinear,
52
- RowParallelLinear,
53
-)
54
-from vllm.model_executor.layers.logits_processor import LogitsProcessor
55
-from vllm.model_executor.layers.quantization import QuantizationConfig
56
-from vllm.model_executor.layers.rotary_embedding import get_rope
57
-from vllm.model_executor.layers.vocab_parallel_embedding import (
58
- ParallelLMHead,
59
- VocabParallelEmbedding,
60
-)
61
-from vllm.model_executor.model_loader.weight_utils import (
62
- default_weight_loader,
63
- maybe_remap_kv_scale_name,
64
-)
65
-from vllm.sequence import IntermediateTensors
66
-
67
-from .interfaces import SupportsLoRA, SupportsPP
68
-from .utils import (
69
- AutoWeightsLoader,
70
- PPMissingLayer,
71
- is_pp_missing_parameter,
72
- make_empty_intermediate_tensors_factory,
73
- make_layers,
74
- maybe_prefix,
75
-)
76
-
77
-
78
-class Dots1MLP(nn.Module):
79
- def __init__(
80
- self,
81
- hidden_size: int,
82
- intermediate_size: int,
83
- hidden_act: str,
84
- quant_config: QuantizationConfig | None = None,
85
- reduce_results: bool = True,
86
- prefix: str = "",
87
- ) -> None:
88
- super().__init__()
89
- self.gate_up_proj = MergedColumnParallelLinear(
90
- hidden_size,
91
- [intermediate_size] * 2,
92
- bias=False,
93
- quant_config=quant_config,
94
- prefix=f"{prefix}.gate_up_proj",
95
- )
96
- self.down_proj = RowParallelLinear(
97
- intermediate_size,
98
- hidden_size,
99
- bias=False,
100
- quant_config=quant_config,
101
- reduce_results=reduce_results,
102
- prefix=f"{prefix}.down_proj",
103
- )
104
- if hidden_act != "silu":
105
- raise ValueError(
106
- f"Unsupported activation: {hidden_act}. Only silu is supported for now."
107
- )
108
- self.act_fn = SiluAndMul()
109
-
110
- def forward(self, x):
111
- gate_up, _ = self.gate_up_proj(x)
112
- x = self.act_fn(gate_up)
113
- x, _ = self.down_proj(x)
114
- return x
115
-
116
-
117
-class Dots1MoE(nn.Module):
118
- def __init__(
119
- self,
120
- config: Dots1Config,
121
- quant_config: QuantizationConfig | None = None,
122
- prefix: str = "",
123
- ):
124
- super().__init__()
125
- self.routed_scaling_factor = config.routed_scaling_factor
126
- self.n_shared_experts = config.n_shared_experts
127
-
128
- if config.hidden_act != "silu":
129
- raise ValueError(
130
- f"Unsupported activation: {config.hidden_act}. "
131
- "Only silu is supported for now."
132
- )
133
-
134
- self.gate = ReplicatedLinear(
135
- config.hidden_size,
136
- config.n_routed_experts,
137
- bias=False,
138
- quant_config=None,
139
- prefix=f"{prefix}.gate",
140
- )
141
- if config.topk_method == "noaux_tc":
142
- self.gate.e_score_correction_bias = nn.Parameter(
143
- torch.empty(config.n_routed_experts)
144
- )
145
- else:
146
- self.gate.e_score_correction_bias = None
147
-
148
- if config.n_shared_experts is not None:
149
- intermediate_size = config.moe_intermediate_size * config.n_shared_experts
150
- self.shared_experts = Dots1MLP(
151
- hidden_size=config.hidden_size,
152
- intermediate_size=intermediate_size,
153
- hidden_act=config.hidden_act,
154
- quant_config=quant_config,
155
- reduce_results=False,
156
- prefix=f"{prefix}.shared_experts",
157
- )
158
- else:
159
- self.shared_experts = None
160
-
161
- self.experts = FusedMoE(
162
- shared_experts=self.shared_experts,
163
- num_experts=config.n_routed_experts,
164
- top_k=config.num_experts_per_tok,
165
- hidden_size=config.hidden_size,
166
- intermediate_size=config.moe_intermediate_size,
167
- renormalize=config.norm_topk_prob,
168
- quant_config=quant_config,
169
- use_grouped_topk=True,
170
- num_expert_group=config.n_group,
171
- topk_group=config.topk_group,
172
- prefix=f"{prefix}.experts",
173
- scoring_func=config.scoring_func,
174
- e_score_correction_bias=self.gate.e_score_correction_bias,
175
- routed_scaling_factor=self.routed_scaling_factor,
176
- apply_routed_scale_to_output=True,
177
- )
178
-
179
- def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
180
- num_tokens, hidden_dim = hidden_states.shape
181
- hidden_states = hidden_states.view(-1, hidden_dim)
182
-
183
- router_logits, _ = self.gate(hidden_states)
184
-
185
- final_hidden_states = self.experts(
186
- hidden_states=hidden_states, router_logits=router_logits
187
- )
188
- return final_hidden_states.view(num_tokens, hidden_dim)
189
-
190
-
191
-class Dots1Attention(nn.Module):
192
- def __init__(
193
- self,
194
- hidden_size: int,
195
- num_heads: int,
196
- num_kv_heads: int,
197
- config: Dots1Config,
198
- max_position_embeddings: int = 8192,
199
- cache_config: CacheConfig | None = None,
200
- quant_config: QuantizationConfig | None = None,
201
- prefix: str = "",
202
- ) -> None:
203
- super().__init__()
204
- self.hidden_size = hidden_size
205
- tp_size = get_tensor_model_parallel_world_size()
206
- self.total_num_heads = num_heads
207
- assert self.total_num_heads % tp_size == 0
208
- self.num_heads = self.total_num_heads // tp_size
209
- self.total_num_kv_heads = num_kv_heads
210
- if self.total_num_kv_heads >= tp_size:
211
- # Number of KV heads is greater than TP size, so we partition
212
- # the KV heads across multiple tensor parallel GPUs.
213
- assert self.total_num_kv_heads % tp_size == 0
214
- else:
215
- # Number of KV heads is less than TP size, so we replicate
216
- # the KV heads across multiple tensor parallel GPUs.
217
- assert tp_size % self.total_num_kv_heads == 0
218
- self.num_kv_heads = max(1, self.total_num_kv_heads // tp_size)
219
- self.head_dim = getattr(config, "head_dim", hidden_size // self.total_num_heads)
220
- self.q_size = self.num_heads * self.head_dim
221
- self.kv_size = self.num_kv_heads * self.head_dim
222
- self.scaling = self.head_dim**-0.5
223
- self.max_position_embeddings = max_position_embeddings
224
- attention_bias = config.attention_bias
225
-
226
- self.qkv_proj = QKVParallelLinear(
227
- hidden_size,
228
- self.head_dim,
229
- self.total_num_heads,
230
- self.total_num_kv_heads,
231
- bias=attention_bias,
232
- quant_config=quant_config,
233
- prefix=f"{prefix}.qkv_proj",
234
- )
235
-
236
- self.o_proj = RowParallelLinear(
237
- self.total_num_heads * self.head_dim,
238
- hidden_size,
239
- bias=False,
240
- quant_config=quant_config,
241
- prefix=f"{prefix}.o_proj",
242
- )
243
-
244
- self.rotary_emb = get_rope(
245
- self.head_dim,
246
- max_position=max_position_embeddings,
247
- rope_parameters=config.rope_parameters,
248
- )
249
- self.attn = Attention(
250
- self.num_heads,
251
- self.head_dim,
252
- self.scaling,
253
- num_kv_heads=self.num_kv_heads,
254
- cache_config=cache_config,
255
- quant_config=quant_config,
256
- prefix=f"{prefix}.attn",
257
- )
258
- self.q_norm = RMSNorm(self.head_dim, eps=config.rms_norm_eps)
259
- self.k_norm = RMSNorm(self.head_dim, eps=config.rms_norm_eps)
260
-
261
- def forward(
262
- self, positions: torch.Tensor, hidden_states: torch.Tensor
263
- ) -> torch.Tensor:
264
- qkv, _ = self.qkv_proj(hidden_states)
265
- q, k, v = qkv.split([self.q_size, self.kv_size, self.kv_size], dim=-1)
266
- q = self.q_norm(q.reshape(-1, self.num_heads, self.head_dim)).reshape(q.shape)
267
- k = self.k_norm(k.reshape(-1, self.num_kv_heads, self.head_dim)).reshape(
268
- k.shape
269
- )
270
- q, k = self.rotary_emb(positions, q, k)
271
- attn_output = self.attn(q, k, v)
272
- output, _ = self.o_proj(attn_output)
273
- return output
274
-
275
-
276
-class Dots1DecoderLayer(nn.Module):
277
- def __init__(
278
- self,
279
- config: Dots1Config,
280
- prefix: str,
281
- model_config: ModelConfig,
282
- cache_config: CacheConfig | None = None,
283
- quant_config: QuantizationConfig | None = None,
284
- ) -> None:
285
- super().__init__()
286
- self.hidden_size = config.hidden_size
287
- max_position_embeddings = getattr(config, "max_position_embeddings", 8192)
288
- layer_idx = int(prefix.split(sep=".")[-1])
289
- self.layer_idx = layer_idx
290
-
291
- self.self_attn = Dots1Attention(
292
- hidden_size=self.hidden_size,
293
- num_heads=config.num_attention_heads,
294
- num_kv_heads=config.num_key_value_heads,
295
- config=config,
296
- max_position_embeddings=max_position_embeddings,
297
- cache_config=cache_config,
298
- quant_config=quant_config,
299
- prefix=f"{prefix}.self_attn",
300
- )
301
- if (
302
- config.n_routed_experts is not None
303
- and layer_idx >= config.first_k_dense_replace
304
- and layer_idx % config.moe_layer_freq == 0
305
- ):
306
- self.mlp = Dots1MoE(
307
- config=config, quant_config=quant_config, prefix=f"{prefix}.mlp"
308
- )
309
- else:
310
- self.mlp = Dots1MLP(
311
- hidden_size=config.hidden_size,
312
- intermediate_size=config.intermediate_size,
313
- hidden_act=config.hidden_act,
314
- quant_config=quant_config,
315
- prefix=f"{prefix}.mlp",
316
- )
317
- self.input_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
318
- self.post_attention_layernorm = RMSNorm(
319
- config.hidden_size, eps=config.rms_norm_eps
320
- )
321
- self.routed_scaling_factor = config.routed_scaling_factor
322
-
323
- def forward(
324
- self,
325
- positions: torch.Tensor,
326
- hidden_states: torch.Tensor,
327
- residual: torch.Tensor | None,
328
- ) -> torch.Tensor:
329
- if residual is None:
330
- residual = hidden_states
331
- hidden_states = self.input_layernorm(hidden_states)
332
- else:
333
- hidden_states, residual = self.input_layernorm(hidden_states, residual)
334
- hidden_states = self.self_attn(positions=positions, hidden_states=hidden_states)
335
- hidden_states, residual = self.post_attention_layernorm(hidden_states, residual)
336
- hidden_states = self.mlp(hidden_states)
337
- return hidden_states, residual
338
-
339
-
340
-@support_torch_compile
341
-class Dots1Model(nn.Module):
342
- fall_back_to_pt_during_load = False
343
-
344
- def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
345
- super().__init__()
346
-
347
- config = vllm_config.model_config.hf_config
348
- model_config = vllm_config.model_config
349
- cache_config = vllm_config.cache_config
350
- quant_config = vllm_config.quant_config
351
- self.config = config
352
-
353
- self.vocab_size = config.vocab_size
354
-
355
- if get_pp_group().is_first_rank:
356
- self.embed_tokens = VocabParallelEmbedding(
357
- config.vocab_size,
358
- config.hidden_size,
359
- quant_config=quant_config,
360
- prefix=f"{prefix}.embed_tokens",
361
- )
362
- else:
363
- self.embed_tokens = PPMissingLayer()
364
-
365
- self.start_layer, self.end_layer, self.layers = make_layers(
366
- config.num_hidden_layers,
367
- lambda prefix: Dots1DecoderLayer(
368
- config,
369
- prefix,
370
- model_config=model_config,
371
- cache_config=cache_config,
372
- quant_config=quant_config,
373
- ),
374
- prefix=f"{prefix}.layers",
375
- )
376
-
377
- if get_pp_group().is_last_rank:
378
- self.norm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
379
- else:
380
- self.norm = PPMissingLayer()
381
- self.make_empty_intermediate_tensors = make_empty_intermediate_tensors_factory(
382
- ["hidden_states", "residual"], config.hidden_size
383
- )
384
-
385
- def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:
386
- return self.embed_tokens(input_ids)
387
-
388
- def forward(
389
- self,
390
- input_ids: torch.Tensor | None,
391
- positions: torch.Tensor,
392
- intermediate_tensors: IntermediateTensors | None,
393
- inputs_embeds: torch.Tensor | None = None,
394
- ) -> torch.Tensor | IntermediateTensors:
395
- if get_pp_group().is_first_rank:
396
- if inputs_embeds is not None:
397
- hidden_states = inputs_embeds
398
- else:
399
- hidden_states = self.embed_input_ids(input_ids)
400
- residual = None
401
- else:
402
- assert intermediate_tensors is not None
403
- hidden_states = intermediate_tensors["hidden_states"]
404
- residual = intermediate_tensors["residual"]
405
- for layer in islice(self.layers, self.start_layer, self.end_layer):
406
- hidden_states, residual = layer(
407
- positions,
408
- hidden_states,
409
- residual,
410
- )
411
- if not get_pp_group().is_last_rank:
412
- return IntermediateTensors(
413
- {"hidden_states": hidden_states, "residual": residual}
414
- )
415
- hidden_states, _ = self.norm(hidden_states, residual)
416
- return hidden_states
417
-
418
- def get_expert_mapping(self) -> list[tuple[str, str, int, str]]:
419
- return fused_moe_make_expert_params_mapping(
420
- self,
421
- ckpt_gate_proj_name="gate_proj",
422
- ckpt_down_proj_name="down_proj",
423
- ckpt_up_proj_name="up_proj",
424
- num_experts=self.config.n_routed_experts,
425
- )
426
-
427
- def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
428
- stacked_params_mapping = [
429
- ("qkv_proj", "q_proj", "q"),
430
- ("qkv_proj", "k_proj", "k"),
431
- ("qkv_proj", "v_proj", "v"),
432
- ("gate_up_proj", "gate_proj", 0),
433
- ("gate_up_proj", "up_proj", 1),
434
- ]
435
-
436
- params_dict = dict(self.named_parameters())
437
- loaded_params: set[str] = set()
438
- expert_params_mapping = self.get_expert_mapping()
439
- for name, loaded_weight in weights:
440
- if "rotary_emb.inv_freq" in name:
441
- continue
442
- for param_name, weight_name, shard_id in stacked_params_mapping:
443
- if weight_name not in name:
444
- continue
445
- if ("mlp.experts." in name) and name not in params_dict:
446
- continue
447
- name = name.replace(weight_name, param_name)
448
- if name.endswith(".bias") and name not in params_dict:
449
- continue
450
- if is_pp_missing_parameter(name, self):
451
- continue
452
- param = params_dict[name]
453
- weight_loader = param.weight_loader
454
- weight_loader(param, loaded_weight, shard_id)
455
- break
456
- else:
457
- for mapping in expert_params_mapping:
458
- param_name, weight_name, expert_id, shard_id = mapping
459
- if weight_name not in name:
460
- continue
461
- name = name.replace(weight_name, param_name)
462
-
463
- if is_pp_missing_parameter(name, self):
464
- continue
465
-
466
- param = params_dict[name]
467
- weight_loader = param.weight_loader
468
- weight_loader(
469
- param,
470
- loaded_weight,
471
- name,
472
- shard_id=shard_id,
473
- expert_id=expert_id,
474
- )
475
- break
476
- else:
477
- if name.endswith(".bias") and name not in params_dict:
478
- continue
479
- name = maybe_remap_kv_scale_name(name, params_dict)
480
- if name is None:
481
- continue
482
- if is_pp_missing_parameter(name, self):
483
- continue
484
- param = params_dict[name]
485
- weight_loader = getattr(
486
- param, "weight_loader", default_weight_loader
487
- )
488
- weight_loader(param, loaded_weight)
489
- loaded_params.add(name)
490
- return loaded_params
491
-
492
-
493
-class Dots1ForCausalLM(nn.Module, SupportsPP, SupportsLoRA):
494
- packed_modules_mapping = {
495
- "qkv_proj": [
496
- "q_proj",
497
- "k_proj",
498
- "v_proj",
499
- ],
500
- "gate_up_proj": [
501
- "gate_proj",
502
- "up_proj",
503
- ],
504
- }
505
-
506
- def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
507
- super().__init__()
508
- config = vllm_config.model_config.hf_config
509
- quant_config = vllm_config.quant_config
510
- self.config = config
511
- self.quant_config = quant_config
512
- self.model = Dots1Model(
513
- vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")
514
- )
515
- if get_pp_group().is_last_rank:
516
- self.lm_head = ParallelLMHead(
517
- config.vocab_size,
518
- config.hidden_size,
519
- quant_config=quant_config,
520
- prefix=maybe_prefix(prefix, "lm_head"),
521
- )
522
- else:
523
- self.lm_head = PPMissingLayer()
524
- self.logits_processor = LogitsProcessor(config.vocab_size)
525
- self.make_empty_intermediate_tensors = (
526
- self.model.make_empty_intermediate_tensors
527
- )
528
-
529
- def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:
530
- return self.model.embed_input_ids(input_ids)
531
-
532
- def forward(
533
- self,
534
- input_ids: torch.Tensor | None,
535
- positions: torch.Tensor,
536
- intermediate_tensors: IntermediateTensors | None = None,
537
- inputs_embeds: torch.Tensor | None = None,
538
- ) -> torch.Tensor | IntermediateTensors:
539
- hidden_states = self.model(
540
- input_ids,
541
- positions,
542
- intermediate_tensors,
543
- inputs_embeds,
544
- )
545
- return hidden_states
546
-
547
- def compute_logits(
548
- self,
549
- hidden_states: torch.Tensor,
550
- ) -> torch.Tensor | None:
551
- logits = self.logits_processor(self.lm_head, hidden_states)
552
- return logits
553
-
554
- def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
555
- loader = AutoWeightsLoader(self)
556
- return loader.load_weights(weights)
557
-
558
- def get_expert_mapping(self) -> list[tuple[str, str, int, str]]:
559
- return self.model.get_expert_mapping()
vllm/model_executor/models/registry.py
+1
-1
@@ -99,7 +99,6 @@ _TEXT_GENERATION_MODELS = {
99
"DeepseekV3ForCausalLM": ("deepseek_v2", "DeepseekV3ForCausalLM"),
100
"DeepseekV32ForCausalLM": ("deepseek_v2", "DeepseekV3ForCausalLM"),
101
"DeepseekV4ForCausalLM": ("vllm.models.deepseek_v4", "DeepseekV4ForCausalLM"),
102
- "Dots1ForCausalLM": ("dots1", "Dots1ForCausalLM"),
102
"Ernie4_5ForCausalLM": ("ernie45", "Ernie4_5ForCausalLM"),
103
"Ernie4_5_MoeForCausalLM": ("ernie45_moe", "Ernie4_5_MoeForCausalLM"),
104
"ExaoneForCausalLM": ("exaone", "ExaoneForCausalLM"),
@@ -733,6 +732,7 @@ _PREVIOUSLY_SUPPORTED_MODELS = {
732
"DonutForConditionalGeneration": "0.10.2",
733
"MllamaForConditionalGeneration": "0.10.2",
734
"XverseForCausalLM": "0.23.0",
735
+ "Dots1ForCausalLM": "0.23.0",
736
}
737
738
_OOT_SUPPORTED_MODELS = {