#16618 is the best representative issue because it has the clearest user-facing problem statement and the most discussion activity among the non-duplicate candidates.

Issue #16618 is the most concrete and broadly framed of the three, centered on a specific model-loading failure for 'bert-base-uncased'.

Tapas tokenization behavior and a bert-base-uncased loading failure are different code paths and different user problems; no evidence they share the same underlying bug.

Both mention model loading/authentication-related failures, but #15980 is specifically about a bad error when downloading a private model without login, while #16618 is about failing to load bert-base-uncased; these are not clearly the same bug.

Summary: These three issues do not appear to be duplicates of one another. Two are about model-loading/authentication errors, while one is about Tapas tokenization behavior, which is unrelated.


issue:44509 best represents the only strong duplicate pair in the set and is the most general issue for that docs cleanup.

issue:44509 is the cleaner canonical for the docs-removal cluster: it describes the broader v5 documentation cleanup, while issue:44512 is a narrower variant about the removed run command.

Different Qwen3.5 problems: a config attribute error vs a streaming chat/completions failure.

Different models and failure modes: Mistral-3 dtype mismatch vs GPT-OSS AMD GPU runtime failure.

Both are model/runtime errors, but the concrete issue is different: Phi-tiny-MoE autocast dtype mismatch vs GPT-OSS on AMD GPUs.

Different model and symptom: Qwen-3-8B-NVFP4 runtime error vs GPT-OSS AMD GPU failure.

Unrelated bugs: Deepspeed ZeRO3 collective mismatch vs ModernBERT ONNX export error.

Different concrete problems: ONNX export for ModernBERT vs FineGrainedFP8Config failure on Qwen3Moe.

Different failure modes and code paths: ONNX export vs auto device mapping CUDA assert.

Both are v5 docs cleanup issues about removed/renamed items still mentioned in documentation, so they look like the same underlying documentation change.

Both mention IndexError, but the concrete reports differ too much: ZeRO3/non-pretrained Bert initialization vs a mask/tensor shape mismatch.

Different issues: ModernBERT export error vs missing GenerationMixin import.

Shared ZeRO3/Bert theme is not enough here; the reported errors and contexts are different enough to avoid treating them as duplicates.

Different models and problems: generic mask shape IndexError vs GPT-OSS tensor-parallel support issue.

Different failure modes and contexts: mask/tensor shape IndexError vs Qwen3.5 embedding unpacking with TRL SFT trainer.

Summary: This cluster is mostly a false-positive mix of unrelated model/runtime issues. The only clear duplicate-like pair is the two v5 docs cleanup issues; the ZeRO3/BERT and Qwen/GPT-OSS items are similar in topic but not the same concrete bug.


issue:43596 is the best single issue to keep because it states the concrete failure clearly and covers the broader reproducer; 43638 reads like the same bug in a narrower non-pretrained variant.

issue:43596 is the cleanest representative of the one real duplicate cluster: the same DeepSpeed ZeRO3 + BERT init path hitting an index-out-of-bounds error.

Different bugs: tokenizer mapping/model-addition logic versus a tensor-mask shape mismatch. Similar generic error reporting, but no shared code path.

Both involve DeepSpeed/ZeRO3, but one is a collective mismatch and the other is an index-out-of-bounds during BERT init; not the same underlying failure.

Unrelated domains: BarkProcessor voice preset handling versus ModernBERT ONNX export.

Same concrete bug: DeepSpeed ZeRO3 initialization with BERT hitting an index-0-out-of-bounds error, with the second issue describing a narrower variant of the same failure.

Different problems: detokenization for DeepSeek Coder versus LoRA merge/save/reload output mismatch.

Liger kernel cross-entropy routing is unrelated to GPT-OSS tensor-parallel/MoE execution.

Qwen-3 NVFP4 runtime failure and LoRA merge/reload inconsistency are different code paths and symptoms.

Activation checkpointing with FSDP/accelerate is a different failure mode than a mask/tensor indexing shape mismatch.

Both mention DeepSpeed, but one is a weight-dimension error and the other is a collective synchronization mismatch; not the same bug.

DeepSeek tokenizer detokenization and GPT-OSS AMD GPU runtime issues are unrelated.

Shared DeepSpeed flavor only; BERT ZeRO3 init index error is unrelated to GPT-OSS MoE TP not working.

Training-time activation checkpointing/FSDP mismatch is unrelated to CustomTrainer compute_loss signature breakage.

Different models and failures: BERT ZeRO3 init index error versus GPT-OSS MoE tensor-parallel behavior.

Gemma3 vLLM config attribute error and Mistral regex patch/tokenizer backend crash are different tokenizer/model integration bugs.

Summary: These items are mostly unrelated false-positive similarity matches across different model/runtime bugs. The only strong duplicate pair is the two DeepSpeed ZeRO3 + BERT initialization IndexError reports (43596/43638).


Both mention MoE/TP-type behavior, but one is an autocast dtype mismatch in Phi-tiny-MoE and the other is a GPT-OSS tensor-parallel issue; the failure modes are different.

Torch 2.10 incompatibility is a version-wide support issue, while Qwen-3-8B-NVFP4 is a model/runtime-specific failure; not the same bug.

Mixtral grouped_mm errors during torch dynamo tracing and a Mistral-3 image preprocessor dtype mismatch are different code paths and different symptoms.

TRL SFTTrainer embedding unpacking is unrelated to GPT-OSS tensor-parallel-only failures; they do not look like one underlying bug.

FSDP + activation checkpointing tensor recomputation mismatch is unrelated to Qwen3 auto device mapping causing cudaErrorAssert.

Autocast dtype mismatch and Qwen-3-8B-NVFP4 runtime failure are different model/runtime problems.

Mistral-3 image preprocessor dtype mismatch is not the same underlying issue as Qwen-3-8B-NVFP4 execution failure.

Qwen-3-8B-NVFP4 failure and TRL SFTTrainer input-embedding unpacking failure are distinct bugs.

Liger Kernel cross_entropy being called is unrelated to Qwen3.5 embedding unpacking in TRL SFTTrainer.

Both are ZeRO-3 index errors, but one occurs when loading Gemma3 and the other during training a non-pretrained Bert model; too different to merge.

Both are docs removals, but they target different deprecated commands/sections; this looks like separate documentation cleanup items.

A dtype mismatch in Mistral-3 image preprocessing is not the same as a StopIteration error in Qwen3-vl video embedding.

Mistral-3 image dtype mismatch and Qwen3.5/TRl embedding unpacking are unrelated failures.

Liger Kernel cross_entropy behavior and an autocast dtype mismatch are different subsystems and different concrete failures.

ZeRO-3 collective mismatch with Jamba-v01 is unrelated to a CustomTrainer.compute_loss signature change.

Liger Kernel cross_entropy invocation is unrelated to a mask-shape IndexError.

Summary: The cluster is heterogeneous: it mixes unrelated model/runtime failures (ZeRO-3, FSDP, autocast, dynamo tracing, device mapping, trainer API changes) plus separate docs cleanup items. I don’t see any pair that clearly shares the same underlying bug/change, so no soft merges should be accepted.


Issue 43596 is the strongest representative of the cluster: it captures the shared zero-sized tensor / ZeRO-3 loading crash in a model-agnostic way and matches the closest duplicate candidate.

Issue 43596 is the best canonical issue because it describes the generic DeepSpeed ZeRO-3 / index-out-of-bounds failure without tying it to one model family, so it cleanly subsumes the similar Gemma3 report.

Unrelated failures: one is an activation-checkpointing/FSDP tensor-size mismatch, the other is a GenerationMixin import error.

Same underlying bug pattern: both report the exact out-of-bounds IndexError during model loading with DeepSpeed ZeRO-3, so they plausibly share one fix.

Both are docs-related, but they cover different documentation problems and different behavior changes; not the same issue.

Different concrete failures: a Gemma3/vLLM config attribute error versus a Qwen3 auto device-mapping CUDA assert.

No shared code-path problem; Liger Kernel cross-entropy dispatch and Qwen3-VL video StopIteration are unrelated.

Both involve model loading, but one is a corrupted checkpoint report and the other is NemotronH checkpoint compatibility; too different to merge.

Different model families and different failure modes: GLM-4.7-Flash unit-test loading versus an Ovis2 checkpoint corruption report.

Unrelated regressions: Torch 2.10 incompatibility versus a pydantic/PretrainedConfig field issue in v5.4.0.

Both mention sliding_window, but the concrete bugs differ: missing Gemma3TextConfig attribute in vLLM versus Qwen3-MoE sliding_window behavior.

Different index errors with different shapes and model contexts; no evidence they share the same root cause.

Summary: Only one soft edge looks like a true duplicate pair: the two DeepSpeed ZeRO-3 index-out-of-bounds loading failures. The rest are distinct bugs, docs issues, or model-specific regressions that should stay separate.


issue:45070 is the strongest representative overall: open, recent, and phrased as a general framework regression rather than a narrow model-specific failure.

issue:45070 is the best cluster anchor because it is the only open item and describes the broadest, most general regression in this set.

Both involve Qwen3.5/chat, but one is a generic crash in transformers chat and the other is a streaming chat/completions API failure for a different Qwen3.5 size; not the same bug.

Whisper model loading/runtime failure is unrelated to a pydantic/PretrainedConfig field regression.

Mistral3 weight tying in image-text generation is a model implementation bug; Ovis2 checkpoint corruption is a different artifact integrity issue.

Grouped_mm torch-dynamo tracing failure in Mixtral is a different code path from Phi-tiny-MoE dtype mismatch under autocast.

GenerationMixin import error and Gemma3Config missing sliding_window_pattern are separate API/config regressions.

Voxtral processor failure and non-template-node compilation error are distinct processing/compiler issues with no clear shared root cause.

Mask/tensor shape mismatch during indexing and DeepSpeed ZeRO-3 out-of-bounds loading are different runtime failures.

PaddleOCR-VL loading failure with vLLM is not the same as adding GGUF support for gpt-oss architecture.

StableLmConfig missing pad_token_idx is a config-field omission, but it is not the same regression as the pydantic PretrainedConfig field issue.

Summary: This set is heterogeneous: the soft pairs share superficial transformer/model-runtime wording, but each pair points to a different concrete bug or regression. I do not see any true duplicate pairs here.


issue:43994 is the strongest global issue candidate because it is specific, reproducible, and aligns closely with the duplicate SigLIP2 symptom report.

issue:43994 is the best canonical issue: it names the exact model and concrete user-visible failure with AutoModel/pipeline, making it the clearest representative of the SigLIP2 regression.

Both are v5 regressions, but one is an int4 quantization OOM and the other is a tied-weights translation-model issue; different failure modes and code paths.

Both mention MoE-related model behavior, but Mixtral grouped_mm tracing and GPT-OSS tensor-parallel support are distinct problems.

Autocast dtype mismatch in Phi-tiny-MoE is unrelated to a chat/completions streaming API failure on Qwen3.5.

init_empty_weights argument handling and pydantic PretrainedConfig field breakage are separate compatibility issues.

Sliding-window behavior for Qwen3-MoE is unrelated to the pydantic PretrainedConfig regression.

GPT-OSS GGUF architecture support and Qwen3.5 streaming inference are different model/API concerns.

Tokenizer-mapping failure in add-new-model-like is a registry bug, not the same as a streaming inference API error.

Grouped_mm tracing on Mixtral and missing Float8 storage are different runtime errors.

Gemma3 sliding_window_pattern with vLLM and MobileLLM key-error loading are separate model/config issues.

Both reports concern SigLIP2 producing poor or nonsensical outputs; they appear to describe the same underlying regression in model behavior.

Mask-shape mismatch during indexing and zero-sized tensor index-out-of-bounds under deepspeed zero3 are both index errors but clearly different bugs.

Summary: This cluster is mostly a mix of unrelated model-loading/runtime issues. The only plausible duplicate pair is the two SigLIP2 reports, which both describe degraded or nonsensical outputs for the same model family.


issue:45005 is the best representative issue because it describes a reusable regression class and is more central than the highly specific runtime/model reports.

issue:45005 is the broadest and most umbrella-like bug report in the set, covering a general tied-weights regression across v5 translation models rather than a single model-specific symptom.

Both are runtime failures in specialized model paths, but one is FP8/Qwen3Moe and the other is float32/Mixtral during dynamo tracing; different code paths and symptoms.

Perplexity degradation on gpt-oss-20b is unrelated to the generic GLM5 issue; no shared concrete failure mode is evident.

FSDP 2-D weight error and Qwen3.5/TRL embedding unpacking are different stack traces and different subsystems.

Both mention tied weights, but one is a Mistral3 model bug and the other is a broader translation-model regression; not the same concrete issue.

Custom-model notebook initialization in v5 is unrelated to flash-attn2 fallback being blocked by checks.

PagedAttentionCache linear_attention crash on Qwen3.5 is a cache/kernel issue, not a tied-weights regression.

NemotronH checkpoint-loading failure is a model implementation/load-path problem, distinct from tied-weights handling.

Quantization offloading behavior is a separate feature area from v5 tied-weights issues.

FP8/Qwen3Moe failure and flash-attn2 fallback gating are unrelated bug classes.

A DSA indexer ReLU discussion and a docs typo are clearly different topics.

Incorrect detokenization in v5 and an NVFP4 runtime error for Qwen-3-8B are different symptoms and likely different fixes.

A cache-strategy typo is just documentation/editing; it is not the same as stale docs about the removed run command.

Summary: These items are mostly unrelated model-specific bugs, docs issues, and one broader v5 tied-weights regression. None of the soft pairs looks like the same underlying bug/change closely enough to merge as duplicates.


issue:43950 is the best global issue representative because it is the most precise statement of the only clear duplicate topic in the set and subsumes the broader wording of issue:43644 and issue:44534.

issue:43950 is the clearest and most specific representative of the non-persistent buffer regression: it names the exact failure mode (`from_pretrained()` corrupting `register_buffer(persistent=False)`) and the Transformers 5.x regression context.

Same underlying bug: both report Transformers v5 filling non-persistent buffers with junk/corruption during load.

Same regression and same failure mode; 43950 is just the more detailed wording of the non-persistent buffer corruption bug.

Both are training/numerics problems, but the concrete failures differ: dtype mismatch under autocast vs NaN/SDPA fallback gradient explosion.

Both involve SigLIP2, but one is a broken docs example and the other is degraded text embedding quality; not the same bug.

Different models and different issues: Voxtral tokenizer error messaging vs Molmo tied-weights attribute failure.

Corrupted Ovis2 checkpoint is not the same as generic loading noise/unnecessary warnings.

Unrelated failures: custom trainer API mismatch vs Gemma3 DeepSpeed ZeRO-3 loading index error.

Both are model-loading problems, but they concern different models and different failure paths.

Different incompatibilities: bitsandbytes kwarg mismatch vs missing Float8 storage object.

Same model family, but one is zero probabilities and the other is poor embedding quality; too broad to treat as the same bug.

Summary: This cluster is mostly a grab-bag of unrelated Transformers issues; the only strong duplicate subcluster is the Transformers 5.x non-persistent buffer regression. The remaining soft pairs are only thematically similar, not the same underlying bug.


issue:45020 is the best single issue to keep as a representative umbrella for the cluster because it is the most general and actionable regression report among otherwise unrelated model-specific reports.

issue:45020 is the broadest and most representative issue in the set, covering a recurring remote_code regression pattern that is more general than the other specific loading failures.

Different symptoms and contexts: LoRA/gradient checkpointing versus int4 quantization memory/OOM.

Unrelated models and failure modes; one is GLM-4V loading, the other is a Molmo tied-weights attribute error.

Related SigLIP2 topic, but one reports degraded embeddings while the other reports an HF-vs-JAX implementation discrepancy; not clearly the same concrete bug.

One is a general loading-noise complaint, the other is a specific model load failure for ScandiBERT.

Both mention training/memory concerns, but the concrete problems differ: checkpointing behavior versus MoE memory efficiency.

No clear overlap: Qwen3VL weight_only loading error versus a generic GLM5 issue.

Both involve remote_code, but one is a specific missing-fields bug in AutoConfig while the other is a broad umbrella report; not enough to prove the same underlying change.

Both concern model loading, but the first is generic noise while the second is a concrete sleng-bert load failure.

Different model families and symptoms; Qwen3_moe LoRA compatibility versus a warning about tie_word_embeddings.

Different model/config combinations and different failure modes; Gemma3 ZeRO-3 indexing error versus Qwen3 MoE FP8 failure.

Summary: These issues are mostly separate model-loading or training regressions across unrelated models/subsystems. None of the soft-edge pairs is a clear duplicate based on titles alone; the only near-overlaps are in the remote_code and SigLIP2 areas, but they still read as different concrete bugs.


Issue 44509 is the strongest global representative among the submitted issues: it is specific, actionable, and closest to a likely dedupe target with broader coverage of the same docs bug.

Issue 44509 is the best representative for the docs-regression cluster because it states the broader v5 pipeline-removal documentation problem more completely than the narrower 43827 report.

Both concern model/tokenizer loading behavior, but one is a detokenization regression and the other is a load failure for a different model; not the same underlying bug.

45356 is a specific Kimi-K2.5 tokenizer regression, while 45020 is a broader remote_code breakage report; related area, different failure and fix scope.

Importing a model class and a bitsandbytes Int8Params constructor incompatibility are separate code paths and separate bugs.

`add-new-model-like` mapping logic and remote_code loading regressions are different issues; same general packaging area but not the same defect.

Both are loading-related, but they affect different models and describe different symptoms/root causes.

Both mention embedding quality/dtype, but one is a quality regression for SigLIP2 text embeddings and the other is a training/eval dtype mismatch; not clearly the same bug.

Tokenizer loading for a specific model and flash-attn fallback selection are unrelated failures.

Both are audio/Whisper-related, but one is a general 'can't run' report and the other is a specific fbank feature extraction issue; not enough evidence they are the same bug.

Both report v5 docs still mentioning removed text-generation/summarization/translation pipeline tasks; same documentation cleanup bug and plausibly one PR.

Tokenizer regex patching and flash-attn fallback gating are separate mechanisms and separate issues.

Summary: Most pairs are related only at a broad subsystem level and should stay separate. The only clear duplicate-like pair is the v5 docs cleanup around removed pipeline tasks.


issue:44291 is the best representative issue in this set because it captures the shared loading regression without being overly model-specific.

issue:44291 is the broader, cleaner description of the `_is_hf_initialized` TypeError regression; issue:43872 looks like a specific bitsandbytes manifestation of the same underlying problem.

Both concern loading behavior, but one is a tied-weight bug in Mistral3 while the other is silent corruption of non-persistent buffers; different code paths and failure modes.

Qwen3Moe FP8 config failure is a concrete quantization/config issue, while the other is a broad remote_code regression; not the same bug.

These are different tokenizer problems on different models: one is a bad error message, the other is an actual tokenizer-loading failure.

Both mention Qwen/Ovis model loading, but the models and symptoms differ; no evidence they stem from the same underlying conversion or checkpoint bug.

A key error when loading MobileLLM and a flash-attn fallback-blocking issue are unrelated code paths.

MobileLLM key errors and remote_code breakage are both general loading failures, but they are not the same concrete defect.

Both describe the same `_is_hf_initialized` constructor/initialization TypeError during model loading; 44291 is the broader report and 43872 a specific downstream manifestation.

Both are DeepSpeed ZeRO-3 weight-loading failures, but they affect different Qwen variants with different missing-weight symptoms; insufficient evidence they are the same bug.

Different tokenizer-loading failures for different models; one is specifically about Voxtral's error message, the other about sleng-bert failing to load.

Both are model loading failures, but one is a unit-test/load issue for GLM-4.7-Flash and the other is NemotronH checkpoint compatibility; too different to merge.

Qwen3 MOE weight-conversion/loading under accelerate+deepspeed is not the same as a gradient-averaging bug during training.

Summary: Mostly a heterogeneous set of model-loading regressions and unrelated tokenizer / training / quantization bugs. The only clear duplicate-like pair is the `_is_hf_initialized` loading regression (43872 ↔ 44291); the rest look like distinct issues despite some shared wording around DeepSpeed, Qwen, or tokenizer loading.


41093 is the strongest issue representative overall because its title is broad enough to cover the duplicate mask-shape error pattern, and it has more discussion than the later variant.

If a single issue must anchor the cluster, 41093 is the best representative of the only clear duplicate subgroup: it states the generic mask/tensor shape mismatch and predates the near-identical later report 44805.

Different failures: a trainer API TypeError versus an IndexError in mask/tensor shape alignment.

Same underlying error class: both report the same mask-vs-indexed-tensor shape mismatch IndexError, with only the concrete shapes/examples differing.

Both describe the same Qwen video-input regression in transformers 5.3.0; 44560 is a specific StopIteration manifestation of that video-processing path.

Different model/runtime problems: PagedAttentionCache linear_attention crash versus NemotronH checkpoint loading failure.

Unrelated bugs: bitsandbytes Int8Params constructor incompatibility versus a compile-time template-node error.

Completely different subsystems and symptoms: DeepSpeed training weight-dimension error versus image processor void segmentation map handling.

No shared code-path or concrete bug; one is GGUF architecture support, the other is an autocast dtype mismatch in a MoE model.

Different issues in different model families: GGUF gpt-oss support versus Qwen3-MoE sliding_window behavior.

Both touch Qwen/video-adjacent areas, but the concrete failures differ: video StopIteration versus TRL SFT embedding unpacking.

Unrelated regressions: non-persistent buffer corruption in from_pretrained versus a Qwen2.5-VL rope/position_ids scaling bug.

Summary: This cluster is mostly heterogeneous, but two soft-linked subgroups look like real duplicates: the mask-shape IndexError pair and the Qwen video regression pair. The remaining pairs are unrelated on their actual failure modes.


43646 is the strongest overall issue anchor in this set because it is broad, user-facing, and describes a concrete regression in the custom-model initialization path more generally than its sibling report.

Issue 43646 is the best representative of the clearest duplicate-like subthread: it states the broader Transformers 5.0.0 custom model initialization regression, while 43645 is just a notebook-specific variant.

Same underlying Transformers 5.0.0 custom-model initialization regression; 43645 appears to be a notebook-specific manifestation of the broader 43646 report.

Different bugs: GGUF gpt-oss architecture support vs a Float8 storage/type error during model handling.

Both involve attention/compiled execution, but they describe different concrete failures on different models and code paths (SDPA torch.compile vs Flash Attention position_ids handling).

Importing a missing exported class is not the same bug as meta-device loading breaking some models; related area, but different failure modes.

Qwen3Moe + FineGrainedFP8Config failure is a different issue from meta-device loading regressions.

Unrelated: a 3d_parallel.py execution problem versus GGUF gpt-oss support.

Same siglip2-base-patch16-224 output regression; one report calls out zero probabilities and the other describes nonsensical outputs via AutoModel/pipeline.

Custom-model initialization regression and non-persistent buffer corruption are distinct bugs in different load paths.

Different concrete failures: Qwen3-vl-embedding video StopIteration versus a tensor/mask shape mismatch.

ImportError for GenerationMixin is unrelated to the Qwen3Moe FineGrainedFP8Config failure.

Both mention config validation, but they concern different models and lack evidence of the same underlying validation bug.

Summary: This cluster is mostly heterogeneous, with two likely true duplicate pairs: the custom-model initialization regression and the siglip2 wrong-output regression. The other soft-similarity pairs look related only at a broad subsystem level, not the same underlying bug.


Issue 43644 is the strongest issue representative overall because it most clearly describes the shared regression in the accepted duplicate pair.

Issue 43644 is the best canonical issue for the only clear duplicate topic: it states the core non-persistent-buffer regression directly and predates the later re-report in 44534.

Both mention failures, but one is a DeepSpeed ZeRO-3/BertModel initialization IndexError and the other is an add-new-model-like tokenizer mapping failure; different code paths and bugs.

One is a BertModel ZeRO-3 empty-shard IndexError, the other is a tokenizer/model registration issue; too different to be the same bug.

Both are memory/offload related, but one is dequantized model loading with device_map=auto and the other is mmap OOM on Strix Halo; not the same underlying fix.

These describe the same regression: non-persistent buffers being incorrectly filled with junk in Transformers v5/v5.0.0.

One is ZeRO-3 loading failure for Qwen3.5 language_model weights; the other is save_pretrained writing incorrect visual encoder keys. Different directions and bugs.

Both involve SigLIP2, but one reports zero probabilities from a model, while the other is a documentation example with model/processor mismatch and quantization errors; not the same issue.

Different models and symptoms: GLM5 vs Qwen3.5 flash-attention generation failure. No shared concrete code-path bug is evident.

Both are model-loading failures for different models, but there is no evidence they stem from the same regression or code path.

Trainer checkpoint resume max_steps miscalculation and SGD args being ignored are unrelated bugs.

Summary: The cluster is mostly heterogeneous. Only the two issues about Transformers v5/non-persistent buffers being filled with junk look like the same underlying bug; the rest are topic-adjacent at best but not duplicate-level matches.


No single issue cleanly represents the whole set because these are several unrelated model-loading / quantization / processor bugs. If one had to be picked as the most representative standalone report, issue 43873 is the best candidate only because it is open and has inbound references, but it does not cover the others.

Both mention Qwen3 and memory/quantization, but one is about MoE training memory usage while the other is about offloading behavior under quantization; different concrete bugs.

Both are Qwen3-related failures, but one is an auto device mapping cuda assert and the other is a FineGrainedFP8Config failure for Qwen3Moe; not the same bug.

Both are tokenizer-loading regressions for different models, but the affected models and failure details differ; too broad to treat as one duplicate.

Both involve SigLIP2, but 39692 is a docs/example mismatch plus quantization failure, while 43994 is about nonsensical outputs from AutoModel/pipeline; related area, not clearly the same underlying bug.

Different models and different loading failures: GLM-4.7-Flash unit-test loading versus Qwen3-VL weight-shape mismatch.

Both are chat/serve crashes, but they hit different code paths and different model types; not one concrete bug.

Both concern loading-time compatibility, but one is Qwen3 MoE LoRA across hf4.x/hf5.x and the other is BitNet packed-weight handling in accelerate; separate root causes.

Qwen3 MoE LoRA compatibility and Gemma4 embedding resize behavior are unrelated bugs.

Both mention model loading under accelerate/deepspeed, but the reported models and failures are different; no evidence of the same underlying defect.

Tokenizer-mapping model-generation failure and compiled flex_attention torch-version failure are unrelated.

Summary: The soft edges mostly connect thematically similar but distinct bugs. A few share a model family or loading path, but the underlying failures differ enough that they should stay separate.


If a single issue must be kept as the representative, 45276 is the closest anchor because it has the strongest semantic overlap with another item (45335) around resize_token_embeddings; however, it still is not a true duplicate cluster.

No canonical issue: the cluster is heterogeneous, and none of the candidate pairs describe the same concrete bug across the same code path.

Different problems: Qwen3 MoE LoRA compatibility/versioning versus disabling mmap on Strix Halo to avoid OOM. No shared code-path bug.

Both mention memory, but one is about Qwen3 MoE training efficiency and the other about int4 quantization reserving too much CUDA memory. Different failure modes and fixes.

Separate regressions in Transformers 5.0.0: one about non-persistent buffers being initialized incorrectly, the other about custom models in Jupyter notebooks. Not the same bug.

One is a LoRA/version compatibility issue for qwen3_moe; the other is a shape-mismatch loading error for Qwen3-VL-30B-A3B-Instruct. Different root causes.

Closest pair, but they affect different model families and different embeddings paths (Gemma4 vs T5Gemma, per-layer/output embeddings vs decoder.embed_tokens). Too model-specific to treat as one bug.

LoRA compatibility on hf5.x versus memory usage during Qwen3 MoE training are unrelated issues, even though both involve Qwen3/MoE.

Both are weight-tying bugs, but in different model classes and different multimodal pathways (Mistral3ForConditionalGeneration vs AyaVisionConfig). Not mergeable as one fix.

ImportError for GenerationMixin and Whisper pipeline return_language regression are unrelated code paths.

Both concern model save/load behavior, but one is extra_state serialization and the other is init_empty_weights/_is_hf_initialized argument handling. Distinct bugs.

One is a Qwen3 auto device mapping CUDA assert; the other is AudioFlamingo3 batched inference leaking embeddings/tokens between tracks. No underlying shared bug.

Summary: This set is mostly a false-positive cluster: the issues share broad Transformers themes (Qwen3, memory, resizing embeddings, loading/saving) but do not describe the same underlying bug or change. No soft pair is safe to merge as a duplicate, though 45276/45335 are the closest in wording.


`issue:45292` is the best overall issue candidate: it is open, broadly phrased, and matches the clearest duplicate pair on the same API behavior. `issue:45276` is a narrower model-specific variant of the same bug.

No single canonical issue fits the whole set because the items span multiple unrelated bug classes. If forced to pick the strongest duplicate target, `issue:45292` is the best canonical issue because it is the broader open report covering the shared `resize_token_embeddings` failure mode.

Both describe the same kind of model-loading failure involving tokenizer special-token ids/vocab-size mismatch in BERT-style models; they plausibly stem from the same loader bug.

Both mention quantization and memory/offloading, but one is about offloading behavior while the other is an int4 CUDA reserved-memory/OOM regression; too broad and not the same concrete bug.

Different models and different failure modes; the only overlap is that both are model-related issues, which is far too broad.

One is a CUDA int4 memory regression, the other is mmap on Strix Halo causing OOM; these are distinct code paths and likely distinct fixes.

Both are compatibility/loading issues, but one is specifically Torch 2.10 incompatibility and the other is a `torch.device("meta")` / model-loading breakage; not the same underlying bug.

Both involve gradient checkpointing, but one is about PEFT LoRA not enabling it effectively during training and the other is about eval-mode usage; different behaviors and fixes.

Both are quantized-model loading problems, but they concern different quantization formats, different models, and different symptoms; too weak to treat as one bug.

Completely different reports: GLM-4.7-Flash test loading versus Qwen3.5 checkpoint saving regression.

`init_empty_weights` TypeError from an unexpected argument is unrelated to disabling mmap to avoid OOM.

These are clearly the same underlying bug: `resize_token_embeddings` does not propagate correctly to output embeddings, with `45276` just being a gemma4-specific manifestation.

Summary: This cluster is mostly a set of unrelated issues, with only one strong duplicate pair: the two `resize_token_embeddings` reports. The other soft pairs look like neighboring or thematically similar bugs, but not the same concrete underlying problem.


45292 is the best representative issue because it states the core regression in a model-agnostic way and subsumes the narrower t5gemma variant.

Issue 45292 is the broader, generic report of the embedding-resize bug; 45335 is a model-specific manifestation of the same problem.

Different models and failure modes: recurrent cache/state reset in qwen3_5 vs a GLM5 topic with no clear shared code path.

Gradient checkpointing eval-mode behavior is unrelated to the Qwen3.5 SDPA/BF16 NaN regression.

Model loading on torch.device("meta") is a different class of bug from disabling mmap for Strix Halo OOM.

save/from_pretrained extra_state handling is unrelated to mmap/OOM behavior.

Custom model initialization in notebooks is unrelated to incorrect max_steps computation during resume_from_checkpoint.

Both report the same resize_token_embeddings regression; 45335 is the t5gemma-specific instance of the broader output embedding mismatch.

Video-input regression for Qwen variants is unrelated to strict config blocking granite_speech loading.

Both mention loading/tokenizer issues, but one is a specific vocab-size mismatch and the other is only a generic inability to load a model; not enough to treat as the same bug.

Breaking custom model initialization in Jupyter is distinct from failing to handle extra_state in save/from_pretrained.

torch.export failures due to torch_compilable_check are a different code path from Perceiver interpolation/resize-position issues.

Summary: This set is mostly heterogeneous and does not form one duplicate cluster. The only clear duplicate-style pair is the resize_token_embeddings regression: the generic report and the t5gemma-specific report describe the same underlying failure to propagate resized embeddings. All other soft pairs appear to be distinct bugs touching different code paths or models.


Both mention dtype/compatibility problems, but one is a Torch 2.10 incompatibility report and the other is an autocast-specific mismatch on a specific MoE model; different failure paths and fixes.

Both are model-loading failures, but they concern different model families and different conversion/implementation issues; not the same concrete bug.

Superficially similar dtype/loading symptoms, but one is an autocast model execution error and the other is a meta-device load regression affecting some models; different code paths.

One is a missing Float8 storage object error, the other is an mmap/OOM workaround on Strix Halo; unrelated root causes.

The first is an isolated reproduction of an earlier issue, while the second is a Qwen3.5 PagedAttentionCache crash with a different invalid group type; not the same bug.

Both are checkpoint loading failures, but the affected models and mismatch causes differ; no evidence they stem from one shared defect.

Whisper pipeline return_language behavior and MXFP4 quantization fallback are unrelated features and failures.

Torch version incompatibility is a different problem from the Mistral-3 image preprocessor/model dtype mismatch.

Both are Transformers 5.0 breakages, but one is about base_model_prefix loading and the other about notebook-defined custom model initialization; too broad and not the same fix.

PagedAttentionCache group-type crash and template-node compilation error are distinct compiler/runtime failures.

Both are docs-related, but one is about a stale return_all_scores mention and the other about removed pipeline task names; separate documentation issues.

Summary: This cluster is not a duplicate set; it contains several unrelated regressions and docs issues around model loading, dtype mismatches, and pipeline changes in Transformers 5.x. None of the soft pairs look like the same underlying bug or change.


Issue #44079 is the best representative only in the sense that it is a concise internal library bug with a clear code-path symptom; however, it is not a true umbrella for the rest of the cluster.

No single issue cleanly represents the whole set because the items are unrelated bugs; if one must be chosen as the most generic core-library defect, issue #44079 is the closest fit, but it does not cover the others.

Different failure modes: one is Qwen3VL MoE loading breaking in v5.0.dev0, the other is a weight-shape mismatch for Qwen3-VL-30B-A3B-Instruct.

Both are model/input regressions, but one is a video-input bug across Qwen VL variants while the other is a tensor mask shape mismatch IndexError; not the same code path.

Different subsystems and symptoms: DeepSpeed ZeRO-3/BertModel initialization versus compiled flex_attention compatibility on torch >= 2.9.

Unrelated compile/runtime problems: missing Float8 storage object versus Triton/template-node compilation error.

Both mention memory, but one is Qwen3 MoE training inefficiency and the other is a Strix Halo mmap/OOM platform workaround; not the same bug.

Both are model behavior regressions, but one is SigLIP2 inference quality and the other is ModelOutput key assignment logic.

Perplexity on a specific model/data pair and ineffective gradient checkpointing with PEFT LoRA are distinct training/evaluation issues.

Torch 2.10 incompatibility is a versioning/backend issue, while Qwen3.5 embedding unpacking in TRL SFT trainer is a trainer integration bug.

Both are tokenizer/model-loading regressions in v5, but CamemBERT masked-LM predictions and EMBEDDIA/est-roberta tokenizer loading are different concrete failures.

Summary: The candidate pairs are mostly superficial similarities within Transformers-related bugs, but they describe different failures, models, or code paths. None look like true duplicates or mergeable into one fix.


Different problems: Whisper pipeline `return_language` regression vs CamemBERT masked-LM prediction changes in v5; different models and code paths.

One is a T5 tokenizer `add_special_tokens` naming conflict, the other is a `gguf_file` loading failure for AutoTokenizer/AutoModelForCausalLM; not the same bug.

Both involve tokenizer loading, but they target different models and failures: EMBEDDIA/est-roberta load breakage vs Mistral regex patch crashing on a missing backend tokenizer attribute.

Unrelated issues: Apple Silicon `caching_allocator_warmup` TypeError vs Transformers v5 breaking `_is_hf_initialized`.

Trainer distributed broadcast `NoneType` error is unrelated to Whisper pipeline `return_language` behavior.

Both are loading/saving related, but one is a `torch.device("meta")` model-loading regression and the other is failure to preserve `extra_state` in save/from_pretrained; different underlying mechanisms.

Different tokenizer/model failures: loading `cjvt/sleng-bert` vs Mistral tokenizer regex patch crash.

High perplexity on gpt-oss-20b is a model evaluation/behavior issue, while the other is a tokenizer backend post-processor update bug.

Molmo missing `all_tied_weights_keys` is a model attribute bug, not a tokenizer loading failure for `cjvt/sleng-bert`.

Torch 2.10 incompatibility and GPT-OSS MoE tensor-parallel failure are both environment/model-parallel related, but they are not the same concrete code-path problem.

Serialization `extra_state` handling and Qwen VL video-input regression are distinct bugs with different subsystems.

Summary: This cluster is a grab bag of unrelated bugs across tokenizers, model loading, distributed training, and model-specific regressions; there is no single clear duplicate canon. All soft pairs are false positives based on superficial similarity only.


issue:43611 is the strongest representative issue overall due to its broad loading-regression framing and likely higher reuse as an umbrella reference than the more model-specific reports.

issue:43611 is the best single anchor because it is the broadest and most generally described regression in the set, with clear version-scoped impact and substantive discussion activity.

Both are multimodal-related failures, but one is torch.export on torch_compilable_check and the other is an OmDet-Turbo processor/image-size mismatch; different code paths and failure modes.

Both are model-loading regressions, but they target different models and likely different breakpoints in the v5/v5.1 loader path; not enough evidence of one underlying bug.

One is a Mistral-3 image-preprocessor dtype mismatch, the other is a template-compilation TypeError; unrelated subsystems and error causes.

Both are Transformers 5.0 regressions, but one is about base_model_prefix model loading and the other about non-persistent buffer initialization; separate concrete bugs.

Both touch audio preprocessing, but one is an unsupported center argument in LasrFeatureExtractor and the other is a _torch_extract_fbank_features issue; different call sites and likely different fixes.

PEFT/LoRA gradient checkpointing and Strix Halo mmap OOM are unrelated problems with no shared code path.

TrainerState token counting and IterableDataset multi-image finetuning are distinct training issues; the overlap is only that they happen during training.

One is a missing all_tied_weights_keys attribute in Molmo save/load behavior, the other is a tokenizer load regression for a different model; different failure modes.

Both involve GGUF/model loading, but one is a generic gguf_file breakage in AutoTokenizer/AutoModelForCausalLM.from_pretrained and the other is a Qwen2.5-GGUF v5-specific loading failure; not clearly the same bug.

Summary: The set is heterogeneous: it spans unrelated Transformers regressions in loading, audio, vision, export, training stats, and memory behavior. None of the soft pairs look like the same underlying bug, so I would not merge any of them as duplicates.


issue:43644 is the best single issue to anchor the cluster because it is specific enough to describe a real code-path regression, yet general enough to represent the broader set of v5 breakage reports better than the more model-specific or UI/message-only issues.

issue:43644 is the strongest representative of the cluster: it is a concrete Transformers v5 regression report with a clear loading/state-management symptom, and it sits in the middle of the broader “v5 broke model behavior” theme seen across the set.

Both are v5 regression reports, but one is about junk-filled non-persistent buffers and the other about custom model initialization. Those are related at a high level, not the same bug or a single fixable code path.

Both mention runtime errors, but they concern different failures: Mixtral grouped_mm tracing vs. a template compilation error. No shared concrete bug or fix path.

These are different subsystems and symptoms: AutoConfig with trust_remote_code loses fields, while Qwen3.5 cache crashes on linear_attention group type. Not a duplicate.

Both are model-loading failures, but one is a specific model compatibility issue and the other is a transformers>=5.1.0 loading regression for a different repo/model. Too broad to treat as the same bug.

These involve different loading paths and failure modes: device_map/offload dequantized model loading versus Qwen2.5-GGUF loading on v5. No evidence of the same underlying defect.

The T5 tokenizer add_special_tokens conflict and the Qwen3Moe FineGrainedFP8Config failure are unrelated model/runtime issues.

Audio chat-template sampling-rate defaulting and MIMI encoder batch-vs-single output mismatch are both audio-related, but they are different behaviors with different likely fixes.

Both are Qwen3.5/Qwen2.5-VL model-specific bugs, but one concerns output_hidden_states and the other rope index scaling for still images. Different code paths, no duplicate evidence.

Whisper pipeline return_language behavior and a pipeline translation-task error message are unrelated; one is a feature regression, the other is messaging/validation.

These are distinct model-specific failures: Qwen3Moe FineGrainedFP8Config versus Qwen3.5 PagedAttentionCache linear_attention handling. Not the same bug.

Summary: These are mostly separate Transformers bug reports spanning different models and code paths. A few are thematically close because they all mention v5 regressions, but none of the soft pairs look like the same underlying bug/change, so I would not merge any of them as duplicates.


issue:45216 is the most general and original report of the shared Qwen3.5 save_pretrained bug; issue:45357 reads like a later, narrower follow-up on the same failure mode.

issue:45216 is the earlier, broader regression report for the Qwen3.5 save_pretrained checkpoint corruption, making it the best anchor for the duplicate cluster.

Both are tokenizer-loading failures, but they affect different models and likely different loader paths; not the same underlying bug.

T5 tokenizer attribute conflict and custom model initialization in notebooks are distinct failures with different triggers.

Both mention lm_head weight/tied weights, but one is a model-specific tie bug and the other is a save_pretrained serialization inconsistency; different concrete issues.

Custom model initialization breakage and non-persistent buffer junk are unrelated v5 regressions.

One is generic loading noise, the other is a Mistral tokenizer crash caused by fix_mistral_regex; not the same bug.

Notebook/custom-model initialization and buffer corruption are separate problems.

Different multimodal model families and different runtime failures; no shared code-path evidence.

Both concern processor/model input mismatch, but they involve different models and symptoms; too broad to be the same bug.

Both report the same Qwen3.5 save_pretrained regression causing incorrect checkpoint serialization; 45357 looks like a later version-specific continuation of issue:45216.

Loading failure for a specific model and a Mistral regex patch crash are different tokenizer-loading bugs.

Summary: Most pairs are clearly different bugs across unrelated models or code paths. The only likely duplicate is the Qwen3.5 save_pretrained regression pair, which describes the same incorrect checkpoint serialization issue across versions.


issue:45081 is the most actionable standalone report: it has a concrete stack trace, clear repro conditions, and inbound references, but it is not a duplicate of the other issues.

Different failures: `_torch_extract_fbank_features()` is an audio feature-extraction bug, while 44683 is about compiled flex_attention on torch >= 2.9.

Different models and mechanisms: MIMI batching/padding-mask mismatch vs DAC `from_latents` missing STE behavior.

Unrelated subsystems: Voxtral AutoTokenizer error messaging vs Apple Silicon `caching_allocator_warmup` TypeError.

Different regressions: `_is_hf_initialized` flag breakage vs disabling mmap on Strix Halo to avoid OOM.

Qwen3MoE + FineGrainedFP8Config is a model/config issue; 45084 is a template compilation error. No shared code path.

Both are loading-time failures, but one is `physical-intelligence/fast` under transformers>=5.1.0 and the other is a Mistral tokenizer regex patch AttributeError; different root causes.

Both involve weight tying, but one is Mistral3 lm_head tying for image-text-to-text and the other is LoRA merge with extended vocabulary; not the same bug.

Different model-specific issues: PaddleOCR-VL load failure in vLLM vs Qwen3-MoE sliding_window handling.

`AddedToken(special=...)` constructor conflict is distinct from the `physical-intelligence/fast` loading failure.

Summary: These issues are only superficially similar; they span unrelated bugs across tokenizer loading, model-specific regressions, quantization, attention compilation, allocator behavior, and LoRA/vocab interactions. No soft pair looks like the same underlying defect.


No single issue is a good global representative: none captures the cluster as a whole, and any choice would mischaracterize several unrelated regressions.

No canonical issue stands out because the items do not form one underlying defect; they span unrelated failure modes in tokenization, model loading, precision/quantization, export, and multimodal handling.

Both concern Qwen2.5-VL/Qwen video-position logic, but one is a broad video-input regression while the other is a specific still-image rope-index scaling bug; not the same concrete path.

Unrelated tokenizer/output issues: perplexity on gpt-oss is not the same bug as Whisper batch_decode ignoring skip_special_tokens.

Different subsystems and symptoms: device_map/offload loading failure vs Qwen3 MoE training memory inefficiency.

torch.export failure with torch_compilable_check and bfloat16 dtype mismatches are different code paths and fixes.

Both involve Transformers v5 loading/init, but one is a Qwen3Moe FineGrainedFP8Config failure and the other is an init_empty_weights/_is_hf_initialized argument error; not the same bug.

The _is_hf_initialized flag regression and non-persistent buffer junk filling are unrelated model-state initialization problems.

base_model_prefix loading breakage is a separate issue from junk-filled non-persistent buffers.

Tokenizer method-name conflict and MobileLLM KeyError are different loading failures with no shared underlying cause.

Both mention float8/quantization-adjacent behavior, but one is a Qwen3Moe FP8 config failure while the other is a missing Float8 storage type during load; distinct bugs.

Both involve special tokens, but one is runtime post-processor synchronization and the other is add_special_tokens not inserting BOS/EOS for a specific tokenizer; different behaviors and fixes.

Summary: This cluster is heterogeneous: most items are distinct Transformers regressions across loading, tokenizers, quantization, multimodal/video, and export paths. The soft pairs share only broad surface similarity, not the same concrete bug or change.


Issue 45020 is the most umbrella-like and still open, but it does not represent the other reports well; there is no strong global best issue for this cluster.

Issue 45020 is the broadest open report, so it is the least-bad anchor, but the set is not cohesive enough to justify a real canonical duplicate.

Both concern Qwen2.5-VL, but one is a multi-image IterableDataset finetuning failure while the other is a still-image rope-index regression; different code paths and fixes.

Video-LLaVA weight/temporal-attention corruption is unrelated to Qwen3.5 save_pretrained writing wrong visual encoder keys.

torch>=2.9 flex_attention compile failure is unrelated to recent transformers breaking remote_code models.

Qwen3-MoE sliding_window behavior and granite_speech config strictness are different problems in different subsystems.

AutoImageProcessor URL loading and non-template-node compilation errors are not the same bug.

Torch 2.10 incompatibility is unrelated to the loading noise/verbosity report.

Tokenizer method-name conflict and Qwen3 auto device-mapping cuda assert are different failure modes with no shared code path.

Whisper-large-v2 runtime failure and missing Float8 storage type are distinct compatibility issues.

LayoutLMv2Tokenizer crashing on NER/padding is unrelated to torch.export failures around torch_compilable_check.

Summary: No true duplicate cluster emerges here: the items span unrelated bugs across tokenizers, vision-language models, export/compile, config loading, and version compatibility. All soft-similarity pairs should be rejected.


No single true canonical issue stands out because the set is heterogeneous; if one representative is needed, issue 44534 is the broadest Transformers v5 regression in the group, but it does not duplicate the others.

Different failures: noisy loading/logging vs tokenizer loading error for a specific model.

Both are Qwen-VL related, but one is multi-GPU training and the other is iterable-dataset/multi-image finetuning failure; different bug paths.

Progressive generation with inputs_embeds/past_key_values is unrelated to multi-image iterable-dataset finetuning.

ModelOutput key bookkeeping and non-persistent buffer initialization are distinct internals with different symptoms.

Different models and errors: Qwen2.5-GGUF loading failure vs Llama4Config missing pad_token_id.

init_empty_weights argument mismatch is a different incompatibility from the Float8 storage-object loading failure.

CPU offload device mismatch in bark-small is not the same code path as torch.export failing on torch_compilable_check.

Different model bugs: bark-small CPU offload mismatch vs DAC.from_latents not matching forward with missing STE.

FSDP CPU RAM efficient loading and ModelOutput key assignment are unrelated regressions.

CLIPVision hidden_states regression and ModelOutput key assignment are separate issues.

Non-persistent buffer junk filling and ModelOutput key assignment are different bug classes.

Summary: The soft pairs are only superficially similar (same broad model family or same Transformers v5 context) and do not describe the same underlying bug, so none should be merged as duplicates.


issue:45325 is the strongest representative issue overall because it is specific, actionable, and aligns with the only accepted soft duplicate edge.

issue:45325 is the clearest, most concrete report in the only near-duplicate pair: it names the exact Qwen2.5-VL get_rope_index / position_ids regression and the affected version.

Different models and symptoms; both are loading failures, but there is no clear shared underlying bug or fix path.

One is about multi-image IterableDataset finetuning, the other about Qwen2.5-VL video position_ids; same broad model family is not enough.

Qwen3-MoE sliding_window behavior and init_empty_weights/_is_hf_initialized are unrelated code paths.

TensorFlow optional dependency packaging vs PaddleOCR-VL loading in vLLM are different problems.

A800 cudaErrorAssert with auto device mapping is unrelated to a Mistral tokenizer backend_tokenizer AttributeError.

OmDet-Turbo image size mismatch and Qwen2.5-VL position_ids scaling are distinct model-specific bugs.

Both report Qwen2.5-VL position_id/rope-index regressions in transformers 5.3.0, likely the same underlying code-path affecting image/video handling.

torch.autocast dtype mismatch in Phi-tiny-MoE is not the same as compiled flex_attention failing on torch >= 2.9.

An initialization-flag regression in Transformers v5 is unrelated to bfloat16 dtype mismatches in SwitchTransformers/TimmWrapperModel.

CUDA OOM under int4 quantization and SAM3Video OOM are too broad and have different likely causes/code paths.

Summary: Most items are unrelated bugs across different models/subsystems. The only plausible duplicate pair is the Qwen2.5-VL position_id regression reports in transformers 5.3.0; everything else should stay separate.


Issue 43611 is the best overall anchor for the cluster because it captures the central loading-regression pattern more cleanly than the narrower, model-specific reports.

Issue 43611 is the broadest and most representative of the repeated Transformers 5.x model-loading regression theme in this set.

Both are Transformers 5.x loading problems, but one is about base_model_prefix handling and the other about custom model initialization; they read as related regressions, not the same bug.

Both concern SigLIP2 producing wrong outputs and point to the same model-implementation discrepancy path; the second looks like a user-visible manifestation of the first.

Different models and different failure modes: Qwen3Moe FP8 config vs Qwen2.5 GGUF loading under v5.

Both mention tied weights/lm_head, but one is a generation bug in AyaVisionConfig and the other is serialization inconsistency across device placement; not the same concrete bug.

Unrelated components and symptoms: BEiT fast processor label reduction vs Molmo tied-weights attribute error.

Both are loading-related, but Whisper failing to run and meta-device loading regressions are not the same underlying issue.

Different failure surface and subsystem: glm-4v-9b model loading vs tokenizer loading for est-roberta.

Tokenizer NER/padding crash and bf16 dtype mismatches are distinct bugs in different code paths.

These describe the same quantization/offload problem: device_map=auto fails when loading dequantized or quantized models with CPU/GPU offload.

Summary: This cluster is mostly about Transformers 5.x load/regression issues, but it is heterogeneous; only the quantization/offload pair and the SigLIP2 pair look like true duplicates. The rest are related at a broad theme level but not the same underlying bug.


Audio processor chat-template sampling-rate bug vs GraniteSpeech PEFT/local checkpoint loading bug; different component and failure mode.

Perceiver non-default-resolution image sizing issue vs Qwen2.5-VL rope index/temporal position bug; unrelated subsystems.

BarkProcessor voice_preset not working vs progressive generation with inputs_embeds/past_key_values; no shared code path.

init_empty_weights/_is_hf_initialized TypeError vs strict config blocking granite_speech config; one is model init API breakage, the other config validation.

_is_hf_initialized flag breakage vs save/from_pretrained extra_state handling; both loading/saving related but distinct bugs.

torch.compile with SDPA on Bamba-9B-v2 vs BitNet packed-weights loading in accelerate; different models and failure mechanisms.

Generation with inputs_embeds/past_key_values vs Qwen3 auto device mapping cudaErrorAssert; unrelated generation vs device-placement bug.

OmDet-Turbo processor output/input size mismatch vs Perceiver resolution interpolation failure; both vision-related but different models and causes.

MIMI encoder batch padding mask discrepancy vs OmDet-Turbo image size mismatch; unrelated audio encoder vs vision processor bug.

MIMI encoder padding-mask bug vs Perceiver positional interpolation issue; different models and code paths.

PaddleOCR-VL model loading under transformers 4.53/vLLM vs tokenizer loading failure for EMBEDDIA/est-roberta in transformers >=5; separate loading failures.

PaddleOCR-VL/vLLM loading failure vs strict granite_speech config validation; unrelated model families and error sources.

Summary: This cluster is not a duplicate set; it mixes many unrelated bugs across audio processors, model loading/init, vision, and model-specific runtime failures. All soft edges appear to be superficial text similarity only, so none should be merged.


If one issue had to anchor the cluster, issue 43454 is the clearest self-contained bug report, but it is not a duplicate representative of the others.

No single issue is a valid canonical duplicate here: the reports cover different models, different failure modes, and different code paths (documentation, training, loading, serialization, attention, preprocessing).

Different problems: FSDP CPU RAM-efficient loading vs v5 non-persistent buffer serialization junk. Same broad theme of loading/state handling, but not the same bug or fix.

Both are multimodal-related, but one is a SigLIP2 docs/model-processor mismatch and quantization example failure; the other is Qwen2.5-VL finetuning with IterableDataset and multiple images per prompt. Different code paths and symptoms.

Both involve save_pretrained/serialization, but one is tied lm_head.weight serialization depending on device, while the other is incorrect visual encoder keys for Qwen3.5. Not the same underlying bug.

Different runtime failures: torch.compile with SDPA on Bamba vs CPU offload device mismatch on bark-small. No shared concrete code-path bug.

AyaVision lm_head tying bug causing bad generation is unrelated to SwitchTransformers/TimmWrapperModel bf16 dtype mismatch.

Whisper model loading/running failure and compiled flex_attention failure on torch >= 2.9 are unrelated issues.

One is a missing lm_head tie in AyaVision; the other is a torch.compile/SDPA failure in Bamba. Same area (model execution) but different bugs.

Qwen3 auto device mapping cudaErrorAssert and Llava Next segmentation fault are different model/runtime failures with no evidence of the same root cause.

Both concern input preprocessing, but one is a LayoutLMv2 tokenizer crash on NER/batching and the other is OmDet-Turbo processor producing the wrong image size. Different failures and fixes.

Both mention Qwen, but the bugs differ: auto device mapping assertion on A800 vs flash-attention generation issues in Qwen3.5.

Both touch model saving/weight handling, but one is untied lm_head weights in Mistral3ForConditionalGeneration and the other is incorrect visual encoder keys in Qwen3.5 save_pretrained. Not the same issue.

Summary: This cluster is a set of distinct bug reports across unrelated models/features. None of the soft-linked pairs look like the same underlying issue, so all soft edges should be rejected and there is no true canonical duplicate within this set.


Issue #43873 is the best standalone issue candidate: it has the most activity and references, a concrete failure mode, and an open status. It is still not a merge target for any of the other items.

No single canonical duplicate stands out because the set is heterogeneous. If an anchor is needed, issue #43873 is the strongest standalone report due to higher discussion/inbound references and a clear reproducible bug, but it is not a duplicate of the others.

Different components and symptoms: BeitImageProcessorFast label reduction vs glm-4v-9b model loading failure. No shared underlying bug.

Both involve transformers serve, but the failures are different AttributeErrors in different processors/code paths, so they are not the same bug.

AyaVision lm_head tying bug and BitNet packed-weight loading bug affect different models and different code paths.

TrainerState token accounting not updating is unrelated to extreme perplexity on gpt-oss-20b/WikiText-2.

Both mention memory-related behavior, but one is quantization offloading not working and the other is mmap causing OOM on Strix Halo; different root causes and fixes.

Model dtype casting on Blip2 is unrelated to resume_from_checkpoint max_steps calculation with batch-size changes.

MIMI encoder padding-mask batching bug and Whisper batch_decode skip_special_tokens bug are separate preprocessing/decoding issues.

Different tokenizer implementations and different failure modes; these are not the same bug.

3d_parallel.py execution failure and Qwen3Moe FineGrainedFP8Config failure are unrelated.

Summary: These items are a grab bag of unrelated bugs across trainer state, model loading, tokenizers, multimodal serving, quantization/offloading, and hardware-specific memory issues. None of the soft pairs look like the same underlying bug or change.


`#44918` is the strongest representative only in the sense of clarity and specificity, not because it duplicates the others; it has a narrow, reproducible trainer-related failure with a clearly named model family.

No pull requests are present in this cluster.

There is no clear canonical duplicate in this set because the issues are heterogeneous. If one issue must serve as a stand-in, `#44918` is the best candidate because it has the most concrete, actionable regression description and context.

Both mention Qwen variants, but one is a video-input regression and the other is a TRL SFT embedding unpacking failure; different code paths and symptoms.

A strict config-loading bug for `granite_speech` is unrelated to a tokenizer loading failure for `EMBEDDIA/est-roberta`.

Both involve loading/offload scenarios, but one is a CPU-offload device mismatch and the other is unpacked packed weights during Accelerate loading; not the same bug.

Quantized model saving failure and GGUF loading failure in v5 are different operations with different failure modes.

These are separate model-loading issues: one with FineGrainedFP8Config on Qwen3Moe, the other with `device_map=auto` dequantized offload behavior.

A trainer API kwarg mismatch is unrelated to a Qwen3Moe FP8 configuration failure.

CamemBERT masked-LM prediction regressions and Qwen3.5 recurrent-state reset behavior are distinct model-specific bugs.

Both are config/API consistency reports, but they concern different fields, models, and serialization behavior; not the same underlying defect.

Torch.compile/SDPA failure for Bamba-9B-v2 is unrelated to a tokenizer special-token registration problem in BigBirdTokenizer.

Unexpected `compute_loss()` kwarg and failure to run `3d_parallel.py` do not point to the same code-path or root cause.

Summary: This cluster is a loose set of unrelated bug reports across different models, configs, tokenizers, and training/loading paths. None of the soft-similarity pairs look like the same underlying defect, so no duplicates should be merged here.


Issue #43873 is the best representative issue among this set because it has the widest scope and the most discussion/inbound references, even though the rest of the cluster is heterogeneous.

Issue #43873 is the broadest and most active report here, centered on offloading/quantization behavior, but the cluster overall does not have a single true duplicate hub.

Both involve inference-time mismatches, but one is Perceiver image classification with interpolate_pos_encoding and the other is SwitchTransformers/TimmWrapper bfloat16 dtype mismatch; different models and code paths.

One is a CPU offload device-mismatch bug in bark-small; the other is a tokenizer special-token registration problem causing empty decode output. Different subsystems.

Qwen3-MoE sliding_window behavior is unrelated to StableLmConfig missing pad_token_idx after a version update.

Qwen-3-8B-NVFP4 runtime failure and a video-input regression across several Qwen VL/3.5 variants are different bugs affecting different features.

Auto device mapping on Qwen3 with cudaErrorAssert is a specific placement/runtime crash; GPT-OSS MoE only-TP failure is a separate parallelism issue.

Qwen3 auto device mapping crash and failure to run 3d_parallel.py do not appear to share the same underlying failure mode or model path.

gather_for_metrics dropping tuple labels is a training/evaluation batching bug, while SAM3 PCS text-and-box weirdness is a multimodal prompting/interaction issue.

Both mention Qwen3 multimodal models, but one is video-input processing in Qwen3OmniMoe and the other is from_pretrained weight_only=True loading in Qwen3VL; different code paths.

Qwen3Moe FineGrainedFP8Config failure and Llava Next segmentation fault are unrelated model/runtime failures.

Auto device mapping causing cudaErrorAssert on Qwen3 is not the same as quantization/offloading not working as expected; overlap is only in broad device-placement themes.

Summary: These are mostly unrelated model- or subsystem-specific bug reports. The soft pairs share superficial themes (Qwen, offloading, dtype/device issues, multimodal inputs) but not the same concrete failure path, so none should be merged as duplicates.


Issue 44514 is the strongest representative in this set because it is the earliest report of the only confirmed duplicate bug and has the fuller original description.

Issue 44514 is the earlier, more detailed report of the same Qwen2_5_VLProcessor.apply_chat_template crash on batched input with padding=False, so it is the best canonical issue over 44545.

Different surfaces and failure modes: Gemma4Processor _tokenizer AttributeError in serve vs Qwen3.5 streaming inference failure in chat/completions.

Unrelated problems: GenerationMixin import error vs inability to run 3d_parallel.py; no shared concrete bug path.

Same exact bug report: Qwen2_5_VLProcessor.apply_chat_template crashes on batched input when padding=False, with essentially identical title and symptom.

Different issues: MacOS bus error with a CLIP model vs progressive generation using inputs_embeds/past_key_values.

Different components and symptoms: image processor void segmentation maps vs BarkProcessor voice_preset not working.

Different model/runtime failures: Qwen3 auto device mapping cudaErrorAssert vs GraniteSpeech PEFT/local checkpoint loading.

Both are docs/content-related, but one is a typo in cache strategies and the other is stale pipeline-task docs; not the same underlying bug or change.

Different tokenizer vs loading issues: BigBirdTokenizer special-token registration vs BitNet packed-weight unpacking during accelerate loading.

Different regressions affecting different model behaviors: tie_word_embeddings warning vs incorrect visual encoder keys in save_pretrained.

Summary: There is one clear duplicate pair: the two Qwen2_5_VLProcessor.apply_chat_template padding=False crash reports. The other soft-similarity pairs describe different models, different code paths, or different bug classes and should stay separate.


issue:44843 is the strongest issue anchor in the set: specific failure mode, concrete code path, and it best explains the related offline-cache report.

issue:44843 is the clearest representative of the one likely duplicate pair because it names the concrete root cause: `_patch_mistral_regex` unconditionally calling `model_info()` and breaking `HF_HUB_OFFLINE` mode.

Both mention training/gradient behavior, but one is eval-mode checkpointing and the other is ZeRO-3 gradient explosion; different bugs.

Both are device/dtype mismatch reports, but for different models and different runtime paths (CPU offload vs bfloat16 inference).

Both are Qwen VLM issues, but one is a weight-only loading error and the other is wrong video `vision_position_ids`; not the same bug.

Different failure points: TRL SFT embedding unpacking vs `trainer.evaluate()` after `trainer.train()`.

Both are tokenizer/model loading regressions, but they affect different models and the failure details are different enough to not treat as one bug.

`torch.compile` with SDPA on Bamba is unrelated to TimmWrapper/SwitchTransformers bfloat16 dtype mismatches.

Voice preset handling in BarkProcessor is unrelated to Qwen3 auto device mapping cuda assert failures.

A compile/SDPA model bug is unrelated to an MLukeTokenizer AttributeError on tasks.

AddedToken keyword-argument duplication is a tokenizer-construction bug, not the same as a model-specific tokenizer loading failure.

These describe the same offline-tokenizer failure: loading from cache with `HF_HUB_OFFLINE=1` and the unconditional `model_info()` call that breaks offline mode.

Summary: Mostly heterogeneous bug reports with no strong global duplicate cluster; only the offline-tokenizer pair looks like the same underlying issue.


No global best issue; none of the items is a good representative for the others because the pairwise overlaps are thematic rather than the same underlying defect.

No single canonical issue: the set spans unrelated bugs in tokenizers, configs, generation, image processing, and model-specific behaviors.

Both involve tokenizer/special-token handling, but one is about runtime post-processor refresh and the other about config losing custom token IDs after save/load; different failure modes and code paths.

Different models and bugs: BitNet loading/unpacking weights versus DAC latent conversion/STE behavior.

TrainerState token counting and progressive generation with inputs_embeds/past_key_values are unrelated issues.

Sliding-window behavior in Qwen3-MoE is unrelated to the float8 storage lookup error during serialization/loading.

Both are load-time regressions in transformers, but one concerns a specific model load failure and the other an image-processor dependency issue; not the same bug.

Different model-specific prediction regressions with different symptoms and likely distinct code paths.

One is about disallowing optional post_init in PatchTSMixer; the other is about num_labels propagation in Qwen3.5 config.

Both touch tokenizer special-token handling, but one is a post-processor refresh bug while the other is a BigBird mask-token registration/decode issue.

Tokenizer-related, but the reported problems are different: special-token post-processor updates versus LayoutLMv2 NER padding/truncation crashes.

Completely different components and failures: tokenizer batching errors versus Perceiver image classification with positional interpolation.

Summary: These issues are largely unrelated and do not form a duplicate cluster; the soft pairs are only superficially similar at the subsystem level and should be rejected.


Issue 43873 is the broadest and still open, so it is the closest thing to a cluster anchor, but it should not be treated as a duplicate umbrella for the rest.

No single issue cleanly represents this cluster because the reports span different models and failure modes; if forced, 43873 is the broadest open issue, but it is not a true canonical duplicate target.

Different models and bugs: OmDet-Turbo input size mismatch vs bfloat16 dtype mismatch in SwitchTransformers/TimmWrapperModel.

Both involve tokenizer internals, but the concrete failures differ: backend_tokenizer AttributeError vs Kimi-K2.5 codec/regression behavior and warning mismatch.

Both mention processor/model mismatch, but they are different models and distinct failure modes, so not the same underlying bug.

Unrelated bugs: DeepSpeed ZeRO3/BertModel index error vs _torch_extract_fbank_features() failure.

Different code paths and symptoms: missing pad_token_id on Llama4Config vs sliding_window behavior in Qwen3-MoE.

Different subsystems and concrete problems: PEFT/local checkpoint loading for GraniteSpeech vs Qwen2.5-VL video vision_position_ids.

Both are multimodal model bugs, but one is a video ValueError in Qwen3OmniMoe and the other is a variable-name collision causing audio_mel_mask AttributeError in Gemma3nModel.

Completely different issues: tokenizer special-token registration bug vs DAC.from_latents forward/STE mismatch.

Different functionality: fbank feature extraction failure vs add-new-model-like breaking when the model appears in TOKENIZER_MAPPING_NAMES.

One is a SigLIP2 documentation example bug; the other is a broad quantization/offloading runtime issue.

Different model/runtime bugs: torch.compile+SDPA failure in Bamba-9B-v2 vs DAC.from_latents mismatch with missing STE.

Summary: This is a heterogeneous set of unrelated bug reports across tokenizers, multimodal inputs, quantization/offloading, and model-specific config/runtime failures. None of the soft pairs look like the same underlying bug or a mergeable PR-equivalent change.


Issue 44843 is the strongest representative candidate because it has a clear repro, references, and a narrowly defined regression in one helper path. It is still not a duplicate target for the other issues.

No single canonical issue: this set is not a duplicate cluster, but a collection of distinct bugs in different components. If forced to pick a representative, issue 44843 is the most actionable and well-scoped of the group.

Both involve _patch_mistral_regex, but 44843 is an offline-mode model_info() call bug while 45081 is an AttributeError on missing backend_tokenizer; same area, different underlying failures.

Different models and bugs: Mistral-3 image-preprocessor dtype mismatch versus Gemma3n forward() variable name collision.

Completely different subsystems and failure modes: Qwen2.5-VL iterable multi-image finetuning versus GraniteSpeech PEFT local checkpoint loading.

Both mention loading/offloading concerns, but one is PEFT checkpoint loading and the other is quantization/offloading behavior; not the same concrete bug.

CLIP attentions assignment regression and RTDetrV2 output differences are unrelated model-specific issues.

Both are tokenizer-related, but one is a LayoutLMv2 NER/padding crash and the other is AutoTokenizer failing to load a specific tokenizer class.

Different model configuration bugs with different mechanisms: sparse-layer creation in SwitchTransformers versus RoPE-layer dropping in Smollm3.

BitNet accelerate-loading unpacking bug and bfloat16 dtype mismatch in SwitchTransformers/TimmWrapperModel are unrelated.

AddedToken keyword duplication and a model-specific AutoTokenizer load failure are not the same bug or code path.

Summary: These items are mostly unrelated bug reports across different models and tokenizer paths. The only near-match is the pair of Mistral regex issues, but they describe different failure modes, so no soft pair should be merged.


Issue 45020 is the most central/open and widest-scoped report among the items, making it the best general anchor for related remote_code breakages even though it does not subsume the other issues exactly.

If a representative issue is needed, issue 45020 is the broadest umbrella for the remote_code regression family, but the set is too heterogeneous to treat as one true duplicate cluster.

Both involve token/processor behavior, but one is runtime special-token/post-processor syncing and the other is Whisper batch_decode skip_special_tokens handling; different code paths and bugs.

Completely unrelated: image segmentation-map processing vs an import error for GenerationMixin.

Both are video-related Qwen issues, but they affect different models and different failure modes (ValueError in Qwen3OmniMoe vs incorrect vision_position_ids in Qwen2.5-VL).

Different models and problems: BLIP2 dtype propagation vs Video-LLaVA tower architecture/weight sharing.

Both concern config loading, but one is missing fields with trust_remote_code and the other is strict config validation for granite_speech; not the same concrete bug.

Same broad Qwen family, but the reported failures are distinct: weight_only loading error vs flash-attention generation behavior.

Both are v5 output regressions, but they affect different models and likely different implementation paths; too broad to merge as duplicates.

No meaningful overlap: BLIP2 dtype issue versus Apple Silicon allocator warmup TypeError.

45020 is a broad umbrella for remote_code breakages, but 44561 is a specific regression tied to is_torch_fx_available removal; not enough evidence of the same underlying bug.

Unrelated: Qwen3-MoE sliding_window behavior versus AutoConfig trust_remote_code field loss.

Summary: These look like loosely related Transformers regression reports rather than a single duplicate cluster; most soft pairs share only a broad subsystem/theme and do not appear to describe the same concrete bug. No PRs are present.


Both involve loading/runtime behavior, but one is about non-persistent buffers being initialized with junk in Transformers 5.0 and the other is a specific FSDP CPU RAM efficient loading regression. Different failure modes and likely different fixes.

The first is about an incorrect pipeline() error message for translation support; the second is a model-specific bad output issue with AutoModel/pipeline. They do not describe the same bug or code path.

DAC.from_latents missing STE behavior and MLukeTokenizer AttributeError on tasks are unrelated components with different symptoms and fixes.

A tensor mask shape mismatch during indexing is a different bug from trainer.evaluate() failing after trainer.train(). The symptoms and likely code paths do not align.

Packed-weight unpacking during accelerate loading for BitNet is unrelated to OmDet-Turbo producing the wrong input size. Different models, components, and root causes.

Qwen3 auto device mapping causing cudaErrorAssert is unrelated to tokenizer loading failure for EMBEDDIA/est-roberta. No shared underlying bug.

Both mention pipeline removals, but one is a runtime error message bug and the other is stale documentation references. That is the same theme, not the same concrete issue.

Missing TensorFlow from the torch extra and a Mistral regex patch crash are unrelated. They touch different installation/loading paths and different failure mechanisms.

'ADD THE DATA' is not a technical bug report and does not match the isolated reproduction of issue 38071.

Both are tokenizer/processor attribute errors, but they involve different classes, different attributes (_backend_tokenizer vs _tokenizer), and different entrypoints. Not the same concrete bug.

Summary: This cluster is heterogeneous: the soft-paired issues cover unrelated bugs in loading, tokenizers, pipelines, docs, and model-specific behavior. None of the candidate edges look like the same underlying issue, so all soft matches should be rejected.


No global best issue for deduping: any one item would misrepresent the rest of the cluster.

No single canonical issue: the items do not describe one shared bug or change, but many unrelated reports.

Different failures in different areas: image processor void segmentation maps vs a custom trainer compute_loss signature error.

Both involve Qwen/VL, but one is a weight_only load error and the other is a rope index scaling bug in get_rope_index; different code paths.

GLM-5 RoPE implementation discussion is unrelated to docs still referencing removed pipeline tasks.

BarkProcessor voice_preset failure is unrelated to an ImportError for GenerationMixin from transformers.generation.

Both mention Qwen3/Qwen3.5 tied-weights warnings, but one is a specific incorrect tying bug and the other is a user-facing warning during LoRA fine-tuning; not the same defect.

Apple Silicon allocator warmup TypeError is unrelated to LwDetrImageLoss crashing under float16 CUDA AMP.

FSDP CPU RAM efficient loading breakage is a different problem from init_empty_weights rejecting unexpected _is_hf_initialized.

BeitImageProcessorFast reduce_labels bug is unrelated to RTDetrV2 output drift in Transformers v5.

BigBirdTokenizer special-token registration/empty decode issue is unrelated to CamemBERT masked LM prediction changes in v5.

Summary: This cluster is heterogeneous: the issues cover unrelated bugs across image processing, tokenizers, trainers, model-specific configs, docs, and runtime/environment failures. None of the soft-similarity pairs look like the same underlying defect, so all soft edges should be rejected.


issue:43452 is the strongest standalone report in the set: it names a specific API failure mode (`gguf_file` affecting `AutoTokenizer.from_pretrained` and `AutoModelForCausalLM.from_pretrained`) and reads like a concrete, actionable bug report. It is not a duplicate anchor for the rest of the cluster.

Different bugs: BEiT `reduce_labels` preprocessing vs an MPS attention correctness issue. No shared codepath or concrete fix overlap.

Different subsystems: audio processor chat-template sampling-rate handling vs DAC latent decoding/STE behavior.

Unrelated: one is a `gguf_file` loading problem, the other is dtype propagation for BLIP-2. Same broad area of model loading, but not the same bug.

Both are trainer/runtime failures, but the concrete failures differ: ZeRO-3 with a non-pretrained Bert model vs `evaluate()` after `train()`.

Both involve loading/tokenizers, but the failure modes are distinct: `gguf_file` support vs a tokenizer loading regression for a specific repo.

Different behavior entirely: local checkpoint loading with PEFT adapters vs Whisper `batch_decode()` ignoring `skip_special_tokens`.

No shared bug: BigBird tokenizer special-token registration vs MXFP4 quantization fallback to bf16.

Completely unrelated: BarkProcessor voice preset configuration vs a `CustomTrainer.compute_loss()` signature mismatch.

Both are model-generation failures, but they concern different models and different underlying issues: GLM-4.7-Flash loading in tests vs Qwen3.5 flash-attention generation problems.

Summary: This cluster does not look like a duplicate set. The items span unrelated bugs across audio processors, tokenizers, training loops, quantization, and model loading, so none of the soft similarity pairs are safe to merge.


Issue 43749 is the best single representative of the cluster because it is active, well-discussed, and describes a clearly actionable broken code path.

Issue 43749 has the strongest triage signal in the set: high discussion activity, inbound references, and a concrete runtime regression affecting FSDP CPU RAM efficient loading.

Different bugs: a missing storage object error versus an image backend dependency regression. Same library, but not the same failure path.

Qwen3 MoE weight conversion under accelerate/deepspeed is unrelated to a multimodal token counting bug in the video branch.

Both are tokenizer regressions, but they affect different models and different mechanics: special-token insertion versus codec handling/warning behavior.

One is a loading/conversion bug; the other is an out-of-memory failure. No shared underlying code-path problem.

Both involve vision model inputs, but the concrete problems differ: zero probabilities for SigLIP2 versus a 640px/224px processor-model mismatch for OmDet-Turbo.

Both relate to Transformers 5.0 breakage, but one is an import error for GenerationMixin and the other is a Jupyter custom-model initialization regression.

Both mention quantization, but they are different models and different failures: a docs example mismatch/quantization failure versus MXFP4 fallback on git-oss-20b.

Package/backend installation mismatch is unrelated to Python 3.14 load failures; they do not point to the same bug.

Both are loading/memory-related, but one is FSDP CPU RAM efficient loading and the other is mmap-induced OOM on Strix Halo. Different code paths and fixes.

Summary: These are mostly unrelated Transformer issues, with the soft pairs only sharing broad themes (loading, tokenization, quantization, vision processing) rather than the same underlying defect. I rejected all soft-edge matches.


No single best issue for the cluster; if forced to pick a representative, issue:43257 has the most discussion and a concrete reproducible loading failure, but it still does not represent the other items.

No clear canonical issue: these are separate bugs across unrelated areas (audio, video/VLM, quantization, loading, training, and model-specific regressions), so no single issue subsumes the rest.

Both concern processor behavior, but one is about `apply_chat_template()` default sampling rate and the other about `batch_decode()` ignoring `skip_special_tokens`; different API paths and different bugs.

These are unrelated: Qwen3-MoE `sliding_window` behavior versus PIL image processors requiring torchvision.

Both touch video/VLM code, but one is an undefined-name bug in multimodal token counting while the other is a broader video-input regression across models; not the same concrete failure.

Different model families and different problems: deepspeed/accelerate weight conversion for Qwen3 MoE versus RoPE layer dropping in Smollm3.

One is a torch.compile + SDPA failure for Bamba, the other is MXFP4 quantization fallback for git-oss-20b; different code paths and symptoms.

Importing `GenerationMixin` and a custom trainer `compute_loss()` signature mismatch are unrelated failures.

RTDetrV2 output differences in v5 and incorrect visual encoder keys during `save_pretrained` are distinct model-specific regressions.

Both involve Qwen3-family models, but one is a Qwen3 MoE loading/conversion issue and the other is a Qwen3-VL weight-shape mismatch; different underlying bugs.

`gguf_file` loading failures and an Apple Silicon allocator warmup `TypeError` are unrelated subsystems and failure modes.

Summary: The cluster is heterogeneous: the soft-paired items share broad language or subsystem overlap, but each pair describes a different bug with a different concrete failure mode. I would not merge any of the soft pairs as duplicates.


issue:44479 is the strongest global representative because it names a concrete regression, has the widest affected surface, and is more general than the more model-specific or symptom-specific reports.

issue:44479 is the broadest and most representative bug report in the set: it describes a v5.3.0 video-input regression affecting multiple Qwen VL/Omni variants, making it the most likely umbrella issue among the candidates.

Both mention Qwen3 and failures, but one is a device-mapping cuda assert on A800 while the other is a video-input ValueError in Qwen3OmniMoe; different code paths and symptoms.

Both are tokenizer-related, but they fail in different components: MLukeTokenizer task handling vs AutoTokenizer loading FastSpeech2ConformerTokenizer.

Both involve video processing, but one is an internal token-counting bug with undefined variables and the other is a batched-shape output issue in video processors; not the same bug.

Both are tokenizer loading errors, but the first is an AddedToken keyword conflict and the second is a model-specific failure for EMBEDDIA/est-roberta on transformers>=5.0.0.

These are related in theme, but 44479 is a broad multi-model video regression while 45381 is a specific vision_position_ids problem for qwen2.5-vl; not clearly the same concrete code-path bug.

Both concern dtype mismatches, but they affect different model families and different inference paths (BLIP2/QFormer vs SwitchTransformers/TimmWrapperModel).

Both are Qwen video issues, but one is a ValueError in Qwen3OmniMoe video input processing and the other is a StopIteration in Qwen3-vl-embedding; too different to merge as one bug.

These are unrelated: one is an init_empty_weights/_is_hf_initialized argument error, the other is a PIL backend image-processor dependency regression.

No meaningful overlap: one is about TensorFlow not being included in a torch extra install, the other is an ImportError for a missing Qwen2_5_VL class.

Summary: These are mostly unrelated closed issues spanning tokenizer loading, video-processing regressions, dtype mismatches, and backend packaging. No pair is clearly the same underlying bug/change; the cluster’s best anchor is the broad Qwen video regression issue.


Different failures: Qwen3Moe FP8 config handling vs AutoImageProcessor loading from URL. No shared code path or concrete duplicate symptom.

Packaging/backend extra omission vs a model load failure. They are unrelated issues with different root causes.

Both involve video inputs, but the affected models and reported behavior differ enough that this does not clearly indicate the same underlying bug.

FP8 config failure for Qwen3Moe is unrelated to a key error when loading MobileLLM-125M.

An isolated reproduction of an older issue is not enough to match this specific Qwen2.5-VL video position_ids regression.

BitNet packed-weight loading and Perceiver positional-encoding handling are distinct code paths and bugs.

Completely different domains: MacOS bus error with CLIP vs TrainerState token counting.

Save-pretrained sharding behavior and AutoProcessor kwargs forwarding are separate concerns, not the same bug.

Apple Silicon allocator warmup TypeError and Qwen3VL weight_only load error are unrelated runtime/loading problems.

Summary: This cluster is heterogeneous: the soft pairs span unrelated bugs in model loading, video processing, packaging, training state, and Apple Silicon/runtime issues. I do not see a single duplicate target for the cluster.


Both involve RoPE/position handling in vision models, but they are different model families and different failures (Smollm3 layer usage vs Qwen2.5-VL temporal position scaling).

DeepSpeed ZeRO3 deque errors and a PEFT version bump are unrelated; one is a runtime training bug, the other is a packaging/version requirement issue.

These are both import/backend-related, but one is a missing PyTorch import dependency and the other is TensorFlow not being included in a torch extra install.

Both are vision-model inference problems, but they affect different architectures and different code paths; no evidence of the same underlying bug.

Both mention config fields being lost, but one is a generic trust_remote_code/AutoConfig behavior and the other is a specific model config field omitted by strict serialization.

These are separate 5.0-era breakages: custom model initialization vs FSDP CPU RAM efficient loading. Same version window is not enough to merge them.

Both fail while loading models, but one is a KeyError for a specific model and the other is a TypeError from init_empty_weights/_is_hf_initialized handling.

Tokenizer-related crashes, but the concrete failures differ: AddedToken special-arg duplication versus Mistral regex patching on a Tokenizer without backend_tokenizer.

Both are loading/import problems, but one is missing PyTorch in the environment and the other is a model-loading regression for Llama 3.2 Vision.

Summary: No duplicate cluster emerges here: the items span unrelated regressions in model loading, tokenizers, configs, training, versioning, and backend packaging. All soft-similarity pairs are broad-topic matches only and should be rejected.


Issue 44821 is the best standalone representative because it is specific, reproducible, and clearly scoped to a single failure mode in model loading from URL.

No single issue cleanly represents the whole cluster because the items are heterogeneous and do not describe the same underlying defect. If one must be chosen as the most representative standalone report, issue 44821 is the clearest actionable model-loading bug.

Both involve loading/runtime errors, but one is about `init_empty_weights` and an unexpected argument, while the other is about `AutoImageProcessor` loading from a URL. Different code paths and fixes.

Both are model-loading complaints, but one is specifically about `gguf_file` handling in AutoTokenizer/AutoModelForCausalLM and the other is a failure to load a particular BERT model. No clear shared root cause.

Different tokenizer/model families and different symptoms: special-token decode behavior vs an AttributeError in tasks. Not the same bug.

PyTorch import availability is unrelated to LayoutLMv3 box validation/error messaging.

Both touch trainer code, but `num_input_tokens_seen` not updating and `compute_loss` receiving an unexpected kwarg are distinct bugs with different fixes.

Different subsystems and failure modes: auxiliary-loss normalization in MoE models vs broken FSDP CPU RAM-efficient loading.

Both are multimodal-model loading/generation issues, but they concern different models and different failing paths; not enough evidence they share one fix.

Both mention `trust_remote_code`, but one is missing fields in `AutoConfig` output and the other is a v5 regression from removing `is_torch_fx_available`. Different underlying problems.

BigBird tokenizer special-token registration and DiaConfig custom token-ID persistence are unrelated bugs.

Summary: This cluster is mostly a set of unrelated Hugging Face Transformers bugs spanning tokenizers, model loading, trainer internals, multimodal models, and config serialization. The soft pairs share broad themes but not the same concrete bug or fix path, so none should be merged as duplicates.